@stream-io/react-native-callingx 0.1.0-beta.6 → 0.1.1-beta.0

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,176 @@
+package io.getstream.rn.callingx
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import java.util.concurrent.ConcurrentHashMap
+
+object CallRegistrationStore {
+
+    private const val TAG = "[Callingx] CallRegistrationStore"
+    private const val DISPLAY_TIMEOUT_MS = 10_000L
+
+    private val trackedCallIds: MutableSet<String> = ConcurrentHashMap.newKeySet()
+
+    /** Pending disconnect cause code (android.telecom.DisconnectCause code) per callId. */
+    private val pendingDisconnectCauseByCallId = ConcurrentHashMap<String, Int>()
+    private val pendingAnswerByCallId = ConcurrentHashMap<String, Boolean>()
+    private val pendingMuteByCallId = ConcurrentHashMap<String, Boolean>()
+
+    // 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)
+            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()
+    }
+
+    /**
+     * Records that a disconnect was requested for this call before it was registered.
+     * When the call becomes registered, the service should take this and run the disconnect action.
+     */
+    fun setPendingDisconnect(callId: String, disconnectCauseCode: Int) {
+        debugLog(TAG, "[store] setPendingDisconnect: callId=$callId causeCode=$disconnectCauseCode")
+        pendingDisconnectCauseByCallId[callId] = disconnectCauseCode
+    }
+
+    fun setPendingAnswer(callId: String, isAudioCall: Boolean) {
+        debugLog(TAG, "[store] setPendingAnswer: callId=$callId")
+        pendingAnswerByCallId[callId] = isAudioCall
+    }
+
+    fun setPendingMute(callId: String, isMute: Boolean) {
+        debugLog(TAG, "[store] setPendingMute: callId=$callId isMute=$isMute")
+        pendingMuteByCallId[callId] = isMute
+    }
+
+    /**
+     * Returns and removes the pending disconnect cause code for this call, if any.
+     * Used when the call has just become registered so the service can run the disconnect action.
+     */
+    fun takePendingDisconnect(callId: String): Int? {
+        val code = pendingDisconnectCauseByCallId.remove(callId)
+        if (code != null) {
+            debugLog(TAG, "[store] takePendingDisconnect: callId=$callId causeCode=$code")
+        }
+        return code
+    }
+
+    fun takePendingAnswer(callId: String): Boolean? {
+        val isAudioCall = pendingAnswerByCallId.remove(callId)
+        if (isAudioCall != null) {
+            debugLog(TAG, "[store] takePendingAnswer: callId=$callId isAudioCall=$isAudioCall")
+        }
+        return isAudioCall
+    }
+
+    fun takePendingMute(callId: String): Boolean? {
+        val isMute = pendingMuteByCallId.remove(callId)
+        if (isMute != null) {
+            debugLog(TAG, "[store] takePendingMute: callId=$callId isMute=$isMute")
+        }
+        return isMute
+    }
+
+    fun clearAll() {
+        synchronized(pendingPromises) {
+            pendingTimeouts.values.forEach { mainHandler.removeCallbacks(it) }
+            pendingTimeouts.clear()
+            pendingPromises.clear()
+        }
+        trackedCallIds.clear()
+        pendingDisconnectCauseByCallId.clear()
+        pendingAnswerByCallId.clear()
+        pendingMuteByCallId.clear()
+    }
+
+    private fun debugLog(tag: String, message: String) {
+        Log.d(tag, message)
+    }
+}
+