@stream-io/react-native-callingx 0.1.0-beta.7 → 0.1.1-beta.1

package/android/build.gradle

@@ -65,7 +65,7 @@ android {
         "generated/java",
         "generated/jni",
         "build/generated/source/codegen/java",
-        "build/generated/source/codegen/jni"
+        "build/generated/source/codegen/jni",
       ]
       if (isNewArchitectureEnabled()) {
         java.srcDirs += ["src/newarch"]
@@ -87,4 +87,10 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "androidx.core:core-telecom:1.0.1"
+  // Compile-time only dependency so StreamMessagingService can reference RemoteMessage.
+  // The consuming app (via @react-native-firebase/messaging) must provide the actual runtime version.
+  compileOnly "com.google.firebase:firebase-messaging-ktx:24.1.2"
+  // Optional: use Firebase native code when the app has react-native-firebase installed (peer deps)
+  implementation project(':react-native-firebase_app')
+  implementation project(':react-native-firebase_messaging')
 }

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,5 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
   <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
@@ -25,5 +26,34 @@
       android:foregroundServiceType="phoneCall"
       android:stopWithTask="true" />
 
+    <service
+      android:name="io.getstream.rn.callingx.StreamMessagingService"
+      android:exported="false">
+      <intent-filter>
+        <action android:name="com.google.firebase.MESSAGING_EVENT" />
+      </intent-filter>
+    </service>
+
+    <!-- Action values must match constants in CallingxModuleImpl.kt -->
+    <receiver
+      android:name="io.getstream.rn.callingx.CallEventBroadcastReceiver"
+      android:exported="false">
+      <intent-filter>
+        <action android:name="io.getstream.CALL_REGISTERED" />
+        <action android:name="io.getstream.CALL_REGISTERED_INCOMING" />
+        <action android:name="io.getstream.CALL_ANSWERED" />
+        <action android:name="io.getstream.CALL_INACTIVE" />
+        <action android:name="io.getstream.CALL_ACTIVE" />
+        <action android:name="io.getstream.CALL_MUTED" />
+        <action android:name="io.getstream.CALL_ENDPOINT_CHANGED" />
+        <action android:name="io.getstream.CALL_END" />
+        <action android:name="io.getstream.CALL_REGISTRATION_FAILED" />
+      </intent-filter>
+    </receiver>
+
+    <!-- Remove default FCM service so StreamMessagingService is the single handler -->
+    <service
+      android:name="io.invertase.firebase.messaging.ReactNativeFirebaseMessagingService"
+      tools:node="remove" />
   </application>
 </manifest>

package/android/src/main/java/io/getstream/rn/callingx/CallEventBroadcastReceiver.kt

@@ -0,0 +1,17 @@
+package io.getstream.rn.callingx
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+
+class CallEventBroadcastReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action ?: return
+        val extras = intent.extras ?: Bundle()
+
+        CallEventBus.publish(CallEvent(action = action, extras = extras))
+    }
+}
+

package/android/src/main/java/io/getstream/rn/callingx/CallRegistrationStore.kt

@@ -0,0 +1,145 @@
+package io.getstream.rn.callingx
+
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Promise
+import io.getstream.rn.callingx.model.CallAction
+import java.util.Collections
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.collections.emptyList
+
+object CallRegistrationStore {
+
+    private const val TAG = "[Callingx] CallRegistrationStore"
+    private const val DISPLAY_TIMEOUT_MS = 10_000L
+
+    private val trackedCallIds: MutableSet<String> = ConcurrentHashMap.newKeySet()
+
+    /** Pending actions per callId, queued until the call is registered in Telecom. */
+    private val pendingActionsByCallId = ConcurrentHashMap<String, MutableList<CallAction>>()
+
+    // Per-callId pending promises for displayIncomingCall awaiting CALL_REGISTERED_INCOMING_ACTION
+    private val pendingPromises = mutableMapOf<String, Promise>()
+    private val pendingTimeouts = mutableMapOf<String, Runnable>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    fun trackCallRegistration(callId: String, promise: Promise?) {
+        debugLog(
+                TAG,
+                "[store] trackCallRegistration: Tracking call registration for callId: $callId"
+        )
+        trackedCallIds.add(callId)
+
+        if (promise == null) return
+
+        synchronized(pendingPromises) {
+            // Cancel any existing timeout for this callId to avoid a stale runnable
+            // rejecting the new promise after it overwrites the old one.
+            pendingTimeouts.remove(callId)?.let { mainHandler.removeCallbacks(it) }
+
+            pendingPromises[callId] = promise
+
+            val timeoutRunnable = Runnable {
+                synchronized(pendingPromises) {
+                    pendingPromises
+                            .remove(callId)
+                            ?.reject("TIMEOUT", "Timed out waiting for call registration: $callId")
+                    pendingTimeouts.remove(callId)
+                    trackedCallIds.remove(callId)
+                }
+            }
+            pendingTimeouts[callId] = timeoutRunnable
+            mainHandler.postDelayed(timeoutRunnable, DISPLAY_TIMEOUT_MS)
+        }
+    }
+
+    fun onRegistrationSuccess(callId: String) {
+        synchronized(pendingPromises) {
+            pendingTimeouts.remove(callId)?.let { mainHandler.removeCallbacks(it) }
+            pendingPromises.remove(callId)?.resolve(true)
+        }
+    }
+
+    fun onRegistrationFailed(callId: String) {
+        reportRegistrationFail(
+                callId,
+                "REGISTRATION_FAILED",
+                "Failed to register call with telecom: $callId",
+                null
+        )
+    }
+
+    fun reportRegistrationFail(
+            callId: String,
+            code: String,
+            message: String?,
+            throwable: Throwable?
+    ) {
+        trackedCallIds.remove(callId)
+
+        synchronized(pendingPromises) {
+            pendingTimeouts.remove(callId)?.let { mainHandler.removeCallbacks(it) }
+            val promise = pendingPromises.remove(callId)
+            pendingActionsByCallId.remove(callId)
+            if (promise != null) {
+                if (throwable != null) {
+                    promise.reject(code, message, throwable)
+                } else if (message != null) {
+                    promise.reject(code, message)
+                } else {
+                    promise.reject(code, "Unknown error")
+                }
+            }
+        }
+    }
+
+    fun addTrackedCall(callId: String) {
+        debugLog(TAG, "[store] addTrackedCall: Adding tracked call: $callId")
+        trackedCallIds.add(callId)
+    }
+
+    fun removeTrackedCall(callId: String) {
+        debugLog(TAG, "[store] removeTrackedCall: Removing tracked call: $callId")
+        trackedCallIds.remove(callId)
+    }
+
+    fun isCallTracked(callId: String): Boolean {
+        val isTracked = trackedCallIds.contains(callId)
+        debugLog(TAG, "[store] isCallTracked: Is call $callId tracked: $isTracked")
+        return isTracked
+    }
+
+    fun hasRegisteredCall(): Boolean {
+        return trackedCallIds.isNotEmpty()
+    }
+
+    /**
+     * Queues an action for a call that is not yet registered.
+     * Pending actions are drained and executed once registration completes.
+     */
+    fun addPendingAction(callId: String, action: CallAction) {
+        debugLog(TAG, "[store] addPendingAction: callId=$callId action=${action::class.simpleName}")
+        pendingActionsByCallId
+                .computeIfAbsent(callId) { Collections.synchronizedList(mutableListOf()) }
+                .add(action)
+    }
+
+    /**
+     * Returns and removes all queued actions for this call.
+     * Used once a call is registered so the service can replay pending actions.
+     */
+    fun takePendingActions(callId: String): List<CallAction> {
+        val list = pendingActionsByCallId.remove(callId) ?: return emptyList()
+        synchronized(list) { return list.toList() }
+    }
+
+    fun clearAll() {
+        synchronized(pendingPromises) {
+            pendingTimeouts.values.forEach { mainHandler.removeCallbacks(it) }
+            pendingTimeouts.clear()
+            pendingPromises.clear()
+        }
+        trackedCallIds.clear()
+        pendingActionsByCallId.clear()
+    }
+}