@qusaieilouti99/call-manager 0.1.60 → 0.1.62

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

@@ -365,47 +365,51 @@ object CallEngine {
         }
 
         val isVideoCall = callType == "Video"
-
         if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
-            activeCalls.values.forEach {
-                if (it.state == CallState.ACTIVE) {
-                    holdCallInternal(it.callId, heldBySystem = false)
-                }
-            }
+            activeCalls.values.filter { it.state == CallState.ACTIVE }
+                .forEach { holdCallInternal(it.callId, heldBySystem = false) }
         }
 
+        // Track dialing state
         activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.DIALING)
         currentCallId = callId
-        Log.d(TAG, "Call $callId added to activeCalls. State: DIALING, callType: $callType")
+        Log.d(TAG, "Call $callId added to activeCalls. State: DIALING")
 
         registerPhoneAccount()
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         val phoneAccountHandle = getPhoneAccountHandle()
         val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
 
-        val extras = Bundle().apply {
-            putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
+        // 1) build a bundle of ONLY your own keys
+        val outgoingExtras = Bundle().apply {
             putString(MyConnectionService.EXTRA_CALL_ID, callId)
             putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
             putString(MyConnectionService.EXTRA_DISPLAY_NAME, targetName)
             putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, isVideoCall)
+            metadata?.let { putString("metadata", it) }
+        }
+
+        // 2) 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)
             putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, isVideoCall)
         }
 
         try {
             telecomManager.placeCall(addressUri, extras)
-            startForegroundService() // Fixed: Always start foreground service
+            startForegroundService()
             requestAudioFocus()
             startRingback()
             bringAppToForeground()
             keepScreenAwake(true)
             setInitialAudioRoute(callType)
-            Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
+            Log.d(TAG, "Successfully reported outgoing call to TelecomManager")
         } catch (e: SecurityException) {
-            Log.e(TAG, "SecurityException: Failed to start outgoing call via placeCall. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
+            Log.e(TAG, "SecurityException placing outgoing call: ${e.message}", e)
             endCallInternal(callId)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to start outgoing call via placeCall: ${e.message}", e)
+            Log.e(TAG, "Failed to start outgoing call: ${e.message}", e)
             endCallInternal(callId)
         }
 

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

@@ -1,33 +1,62 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
-import com.facebook.proguard.annotations.DoNotStrip
 import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.proguard.annotations.DoNotStrip
 
 @DoNotStrip
-class CallManager : HybridCallManagerSpec() {
+class CallManager : HybridCallManagerSpec() { // Match the parameterless constructor
 
     private val TAG = "CallManager"
 
-    // Remove problematic initialization - will rely on lazy initialization
+    // This method ensures CallEngine has a valid context.
+    // It primarily relies on MainApplication.onCreate, but provides a fallback.
     private fun ensureInitialized() {
         if (!CallEngine.isInitialized()) {
-            Log.w(TAG, "CallEngine not yet initialized - this should be handled by the first call requiring context")
+            // 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)
+            }
         }
     }
 
-    override fun endCall(callId: String) {
+    // --- All your overridden methods must call ensureInitialized() first ---
+
+    override fun endCall(callId: String): Unit {
         Log.d(TAG, "endCall requested for callId: $callId")
         ensureInitialized()
         CallEngine.endCall(callId)
     }
 
-    override fun endAllCalls() {
+    override fun endAllCalls(): Unit {
         Log.d(TAG, "endAllCalls requested")
         ensureInitialized()
         CallEngine.endAllCalls()
     }
 
-    override fun silenceRingtone() {
+    override fun silenceRingtone(): Unit {
         Log.d(TAG, "silenceRingtone requested.")
         ensureInitialized()
         CallEngine.stopRingtone()
@@ -39,21 +68,19 @@ class CallManager : HybridCallManagerSpec() {
         return CallEngine.getAudioDevices()
     }
 
-    override fun setAudioRoute(route: String) {
+    override fun setAudioRoute(route: String): Unit {
         Log.d(TAG, "setAudioRoute requested for route: $route")
         ensureInitialized()
         CallEngine.setAudioRoute(route)
     }
 
-    override fun keepScreenAwake(keepAwake: Boolean) {
+    override fun keepScreenAwake(keepAwake: Boolean): Unit {
         Log.d(TAG, "keepScreenAwake requested: $keepAwake")
         ensureInitialized()
         CallEngine.keepScreenAwake(keepAwake)
     }
 
-    override fun addListener(
-        listener: (event: CallEventType, payload: String) -> Unit
-    ): () -> Unit {
+    override fun addListener(listener: (event: CallEventType, payload: String) -> Unit): () -> Unit {
         Log.d(TAG, "addListener called with listener: $listener")
         ensureInitialized()
         CallEngine.setEventHandler(listener)
@@ -63,31 +90,32 @@ class CallManager : HybridCallManagerSpec() {
         }
     }
 
-    override fun startOutgoingCall(callId: String, callType: String, targetName: String, metadata: String?) {
+    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)
     }
 
-    override fun startCall(callId: String, callType: String, targetName: String, metadata: String?) {
+    override fun startCall(callId: String, callType: String, targetName: String, metadata: String?): Unit {
         Log.d(TAG, "startCall requested: callId=$callId, callType=$callType, targetName=$targetName")
         ensureInitialized()
         CallEngine.startCall(callId, callType, targetName, metadata)
     }
 
-    override fun callAnswered(callId: String) {
+    override fun callAnswered(callId: String): Unit {
         Log.d(TAG, "callAnswered (from JS) requested for callId: $callId")
         ensureInitialized()
         CallEngine.callAnsweredFromJS(callId)
     }
 
-    override fun setOnHold(callId: String, onHold: Boolean) {
+    override fun setOnHold(callId: String, onHold: Boolean): Unit {
         Log.d(TAG, "setOnHold requested for callId: $callId, onHold: $onHold")
         ensureInitialized()
         CallEngine.setOnHold(callId, onHold)
     }
 
-    override fun setMuted(callId: String, muted: Boolean) {
+    override fun setMuted(callId: String, muted: Boolean): Unit {
         Log.d(TAG, "setMuted requested for callId: $callId, muted: $muted")
         ensureInitialized()
         CallEngine.setMuted(callId, muted)

package/package.json

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