@qusaieilouti99/call-manager 0.1.61 → 0.1.62

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.61",
+  "version": "0.1.62",
   "description": "Call manager",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",