@qusaieilouti99/call-manager 0.1.62 → 0.1.64

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

@@ -48,8 +48,10 @@ object CallEngine {
     private const val FOREGROUND_NOTIF_ID = 1001
 
     // Core context - initialized once and maintained
+    @Volatile
     private var appContext: Context? = null
-    private var isInitialized = AtomicBoolean(false)
+    private val isInitialized = AtomicBoolean(false)
+    private val initializationLock = Any()
 
     // Audio & Media
     private var ringtone: android.media.Ringtone? = null
@@ -83,16 +85,25 @@ object CallEngine {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    // --- INITIALIZATION - Fix for context management ---
+    // --- INITIALIZATION - Fixed for better 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()
+        synchronized(initializationLock) {
+            if (isInitialized.compareAndSet(false, true)) {
+                appContext = context.applicationContext
+                audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+                Log.d(TAG, "CallEngine initialized successfully with context: ${context.javaClass.simpleName}")
+
+                // Verify critical services are available
+                if (audioManager == null) {
+                    Log.w(TAG, "AudioManager is null after initialization")
+                }
+
+                // Initialize foreground service if needed
+                if (isCallActive()) {
+                    startForegroundService()
+                }
+            } else {
+                Log.d(TAG, "CallEngine already initialized, skipping")
             }
         }
     }
@@ -100,7 +111,9 @@ object CallEngine {
     fun isInitialized(): Boolean = isInitialized.get()
 
     private fun requireContext(): Context {
-        return appContext ?: throw IllegalStateException("CallEngine not initialized. Call initialize() first.")
+        return appContext ?: throw IllegalStateException(
+            "CallEngine not initialized. Ensure CallEngine.initialize(context) is called in Application.onCreate() before any module usage."
+        )
     }
 
     // --- Event System ---
@@ -128,38 +141,79 @@ object CallEngine {
         }
     }
 
-    // --- Audio Focus Management (Simplified) ---
+    // --- FIXED Audio Focus Management ---
     private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
         Log.d(TAG, "Audio focus changed: $focusChange")
         when (focusChange) {
-            AudioManager.AUDIOFOCUS_LOSS,
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                Log.d(TAG, "Permanent audio focus loss - another app took focus")
+                hasAudioFocus = false
+                isSystemCallActive = true
+                holdSystemCalls()
+            }
             AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                Log.d(TAG, "Transient audio focus loss - temporary interruption")
                 hasAudioFocus = false
                 isSystemCallActive = true
                 holdSystemCalls()
             }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                Log.d(TAG, "Audio focus loss with ducking - lowering volume but keeping active")
+                // Don't hold the call for ducking, just lower volume
+                hasAudioFocus = false
+            }
             AudioManager.AUDIOFOCUS_GAIN -> {
+                Log.d(TAG, "Audio focus gained")
                 hasAudioFocus = true
                 isSystemCallActive = false
+                // Delay resuming to avoid rapid hold/unhold cycles
                 Handler(Looper.getMainLooper()).postDelayed({
                     resumeSystemHeldCalls()
-                }, 1000)
+                }, 500)  // Reduced from 1000ms
+            }
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT -> {
+                Log.d(TAG, "Transient audio focus gained")
+                hasAudioFocus = true
             }
         }
         updateForegroundNotification()
     }
 
     private fun holdSystemCalls() {
-        activeCalls.values.filter { it.state == CallState.ACTIVE }.forEach { call ->
-            if (!call.wasHeldBySystem) {
+        val callsToHold = activeCalls.values.filter {
+            it.state == CallState.ACTIVE && !it.wasHeldBySystem
+        }
+
+        if (callsToHold.isEmpty()) {
+            Log.d(TAG, "No active calls to hold due to audio focus loss")
+            return
+        }
+
+        Log.d(TAG, "Holding ${callsToHold.size} calls due to audio focus loss")
+        callsToHold.forEach { call ->
+            // Add a small delay to prevent holding immediately after answering
+            val timeSinceAnswer = System.currentTimeMillis() - call.timestamp
+            if (timeSinceAnswer > 2000) {  // Only hold if call has been active for 2+ seconds
                 holdCallInternal(call.callId, heldBySystem = true)
+            } else {
+                Log.d(TAG, "Skipping hold for recently answered call: ${call.callId}")
             }
         }
         stopRingback()
     }
 
     private fun resumeSystemHeldCalls() {
-        activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
+        val callsToResume = activeCalls.values.filter {
+            it.state == CallState.HELD && it.wasHeldBySystem
+        }
+
+        if (callsToResume.isEmpty()) {
+            Log.d(TAG, "No system-held calls to resume")
+            return
+        }
+
+        Log.d(TAG, "Resuming ${callsToResume.size} system-held calls")
+        callsToResume.forEach { call ->
             unholdCallInternal(call.callId, resumedBySystem = true)
         }
     }
@@ -177,12 +231,13 @@ object CallEngine {
                             .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                             .build()
                     )
-                    .setOnAudioFocusChangeListener(audioFocusChangeListener)
+                    .setOnAudioFocusChangeListener(audioFocusChangeListener, Handler(Looper.getMainLooper()))
+                    .setAcceptsDelayedFocusGain(true)  // Added this
                     .build()
             }
             val result = audioManager?.requestAudioFocus(audioFocusRequest!!)
             hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result: $result")
+            Log.d(TAG, "Audio focus request result: $result (granted: $hasAudioFocus)")
             hasAudioFocus
         } else {
             @Suppress("DEPRECATION")
@@ -192,7 +247,7 @@ object CallEngine {
                 AudioManager.AUDIOFOCUS_GAIN
             )
             hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result (legacy): $result")
+            Log.d(TAG, "Audio focus request result (legacy): $result (granted: $hasAudioFocus)")
             hasAudioFocus
         }
     }
@@ -330,7 +385,7 @@ object CallEngine {
 
         try {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
-            startForegroundService() // Fixed: Always start foreground service
+            startForegroundService()
             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)
@@ -380,7 +435,7 @@ object CallEngine {
         val phoneAccountHandle = getPhoneAccountHandle()
         val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
 
-        // 1) build a bundle of ONLY your own keys
+        // Build a bundle of ONLY your own keys
         val outgoingExtras = Bundle().apply {
             putString(MyConnectionService.EXTRA_CALL_ID, callId)
             putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
@@ -389,7 +444,7 @@ object CallEngine {
             metadata?.let { putString("metadata", it) }
         }
 
-        // 2) wrap under the single Telecom‐honored key
+        // Wrap under the single Telecom-honored key
         val extras = Bundle().apply {
             putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
             putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
@@ -399,8 +454,15 @@ object CallEngine {
         try {
             telecomManager.placeCall(addressUri, extras)
             startForegroundService()
-            requestAudioFocus()
-            startRingback()
+
+            // FIXED: Request audio focus BEFORE starting ringback
+            val audioFocusGranted = requestAudioFocus()
+            if (audioFocusGranted) {
+                startRingback()
+            } else {
+                Log.w(TAG, "Audio focus not granted for outgoing call, skipping ringback")
+            }
+
             bringAppToForeground()
             keepScreenAwake(true)
             setInitialAudioRoute(callType)
@@ -449,13 +511,13 @@ object CallEngine {
         registerPhoneAccount()
         requestAudioFocus()
         bringAppToForeground()
-        startForegroundService() // Fixed: Start foreground service for JS-initiated calls
+        startForegroundService()
         keepScreenAwake(true)
         setInitialAudioRoute(callType)
         updateLockScreenBypass()
 
-        // Emit call answered event with metadata
-        emitCallAnsweredWithMetadata(callId)
+        // Emit outgoing call answered event with metadata for JS-initiated calls
+        emitOutgoingCallAnsweredWithMetadata(callId)
     }
 
     // --- Call Answer Management ---
@@ -469,6 +531,7 @@ object CallEngine {
         coreCallAnswered(callId, isLocalAnswer = true)
     }
 
+    // FIXED: Core Call Answered Method with proper audio focus handling
     private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
         val context = requireContext()
         Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
@@ -479,13 +542,27 @@ object CallEngine {
             return
         }
 
+        // FIXED: Request audio focus FIRST, before stopping media
+        val audioFocusGranted = requestAudioFocus()
+        if (!audioFocusGranted) {
+            Log.w(TAG, "Failed to get audio focus for call $callId, but continuing...")
+            // Don't fail the call, but warn about audio issues
+        }
+
+        // Stop media AFTER getting audio focus
         stopRingtone()
         stopRingback()
         cancelIncomingCallUI()
-        requestAudioFocus()
 
-        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
-        currentCallId = callId
+        // FIXED: Only set call to ACTIVE if we have audio focus OR if it's a remote answer
+        if (audioFocusGranted || !isLocalAnswer) {
+            activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
+            currentCallId = callId
+            Log.d(TAG, "Call $callId set to ACTIVE state")
+        } else {
+            Log.w(TAG, "Call $callId not set to ACTIVE due to audio focus failure")
+            return
+        }
 
         if (!canMakeMultipleCalls) {
             activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
@@ -496,18 +573,25 @@ object CallEngine {
         }
 
         bringAppToForeground()
-        startForegroundService() // Fixed: Ensure foreground service is running
+        startForegroundService()
         keepScreenAwake(true)
         resetAudioMode()
         updateLockScreenBypass()
         updateForegroundNotification()
 
-        // Emit with metadata
-        emitCallAnsweredWithMetadata(callId)
+        // FIXED: Emit different events based on call direction
+        if (isLocalAnswer) {
+            // This is for incoming calls - user answered locally
+            emitCallAnsweredWithMetadata(callId)
+        } else {
+            // This is for outgoing calls - remote party answered
+            emitOutgoingCallAnsweredWithMetadata(callId)
+        }
 
         Log.d(TAG, "Call $callId successfully answered and UI cleaned up")
     }
 
+    // For incoming calls (local answer)
     private fun emitCallAnsweredWithMetadata(callId: String) {
         val callInfo = activeCalls[callId] ?: return
         val metadata = callMetadata[callId]
@@ -528,6 +612,27 @@ object CallEngine {
         })
     }
 
+    // For outgoing calls (remote answer)
+    private fun emitOutgoingCallAnsweredWithMetadata(callId: String) {
+        val callInfo = activeCalls[callId] ?: return
+        val metadata = callMetadata[callId]
+
+        emitEvent(CallEventType.OUTGOING_CALL_ANSWERED, JSONObject().apply {
+            put("callId", callId)
+            put("callType", callInfo.callType)
+            put("displayName", callInfo.displayName)
+            callInfo.pictureUrl?.let { put("pictureUrl", it) }
+            metadata?.let {
+                try {
+                    put("metadata", JSONObject(it))
+                } catch (e: Exception) {
+                    Log.w(TAG, "Invalid metadata JSON for callId: $callId", e)
+                    put("metadata", it) // fallback to string
+                }
+            }
+        })
+    }
+
     // --- Call Control Methods ---
     fun holdCall(callId: String) {
         holdCallInternal(callId, heldBySystem = false)
@@ -586,7 +691,7 @@ object CallEngine {
             return
         }
 
-        // Fixed: Simplified audio focus check to prevent UNHELD FAILED
+        // 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

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

@@ -1,48 +1,26 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
 import android.util.Log
-import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.proguard.annotations.DoNotStrip
 
 @DoNotStrip
-class CallManager : HybridCallManagerSpec() { // Match the parameterless constructor
+class CallManager : HybridCallManagerSpec() {
 
     private val TAG = "CallManager"
 
-    // This method ensures CallEngine has a valid context.
-    // It primarily relies on MainApplication.onCreate, but provides a fallback.
+    // Simplified approach - rely on proper Application.onCreate() initialization
+    // Remove all fallback context access attempts that don't work with Nitro modules
     private fun ensureInitialized() {
         if (!CallEngine.isInitialized()) {
-            // This log should ideally NOT be seen frequently in production.
-            // If it appears, it means CallEngine wasn't initialized by MainApplication.
-            Log.e(TAG, "CallEngine not initialized! Attempting late initialization from CallManager.")
-            try {
-                // For React Native modules (including JSI/Nitro ones),
-                // ReactApplicationContext.getCurrentApplicationContext() provides the
-                // ReactApplicationContext once the bridge is set up. From there, we get the Application context.
-                val reactContext = ReactApplicationContext.getCurrentApplicationContext()
-
-                if (reactContext != null) {
-                    val appContext = reactContext.applicationContext
-                    if (appContext != null) {
-                        CallEngine.initialize(appContext)
-                        Log.d(TAG, "CallEngine successfully (late) initialized via ReactApplicationContext.")
-                    } else {
-                        Log.e(TAG, "Error: reactContext.applicationContext is null. Cannot late-initialize CallEngine.")
-                        throw IllegalStateException("CallEngine initialization failed: Application context is null.")
-                    }
-                } else {
-                    Log.e(TAG, "Error: ReactApplicationContext.getCurrentApplicationContext() returned null. Cannot late-initialize CallEngine.")
-                    throw IllegalStateException("CallEngine initialization failed: ReactApplicationContext not available.")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Exception during CallEngine late initialization: ${e.message}", e)
-                throw IllegalStateException("CallEngine fatal error during initialization: ${e.message}", e)
-            }
+            Log.e(TAG, "CallEngine not initialized! This should not happen if Application.onCreate() was called properly.")
+            throw IllegalStateException(
+                "CallEngine must be initialized in Application.onCreate(). " +
+                "Make sure MainApplication.onCreate() calls CallEngine.initialize(this) before any native calls."
+            )
         }
     }
 
-    // --- All your overridden methods must call ensureInitialized() first ---
+    // --- All methods must call ensureInitialized() first ---
 
     override fun endCall(callId: String): Unit {
         Log.d(TAG, "endCall requested for callId: $callId")
@@ -81,7 +59,7 @@ class CallManager : HybridCallManagerSpec() { // Match the parameterless constru
     }
 
     override fun addListener(listener: (event: CallEventType, payload: String) -> Unit): () -> Unit {
-        Log.d(TAG, "addListener called with listener: $listener")
+        Log.d(TAG, "addListener called")
         ensureInitialized()
         CallEngine.setEventHandler(listener)
         return {
@@ -93,7 +71,6 @@ class CallManager : HybridCallManagerSpec() { // Match the parameterless constru
     override fun startOutgoingCall(callId: String, callType: String, targetName: String, metadata: String?): Unit {
         Log.d(TAG, "startOutgoingCall requested: callId=$callId, callType=$callType, targetName=$targetName")
         ensureInitialized()
-        // IMPORTANT: The Bundle wrapping fix for TelecomManager must still be in CallEngine.startOutgoingCall
         CallEngine.startOutgoingCall(callId, callType, targetName, metadata)
     }
 

package/package.json

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