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

package/android/src/main/java/io/getstream/rn/callingx/{CallingxModule.kt → CallingxModuleImpl.kt}

@@ -8,7 +8,9 @@ import android.content.IntentFilter
 import android.content.ServiceConnection
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
 import android.os.IBinder
+import android.os.Looper
 import android.telecom.DisconnectCause
 import android.util.Log
 import androidx.core.content.ContextCompat
@@ -21,14 +23,16 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import io.getstream.rn.callingx.model.CallAction
 import io.getstream.rn.callingx.notifications.NotificationChannelsManager
 import io.getstream.rn.callingx.notifications.NotificationsConfig
+import java.util.concurrent.ConcurrentHashMap
 
-@ReactModule(name = CallingxModule.NAME)
-class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec(reactContext) {
+class CallingxModuleImpl(
+        private val reactApplicationContext: ReactApplicationContext,
+        private val eventEmitter: CallingxEventEmitterAdapter
+) {
 
     companion object {
         const val TAG = "[Callingx] CallingxModule"
@@ -50,6 +54,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         const val CALL_MUTED_ACTION = "call_muted"
         const val CALL_ENDPOINT_CHANGED_ACTION = "call_endpoint_changed"
         const val CALL_END_ACTION = "call_end"
+        const val CALL_REGISTRATION_FAILED_ACTION = "call_registration_failed"
         // Background task name
         const val HEADLESS_TASK_NAME = "HandleCallBackgroundState"
         const val SERVICE_READY_ACTION = "service_ready"
@@ -69,6 +74,16 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
     private var canSendEvents = false
     private var isHeadlessTaskRegistered = false
 
+    // Synchronous call tracking set, updated before async service start to mirror iOS semantics.
+    // This ensures isCallTracked() returns true immediately after displayIncomingCall/startCall.
+    private val trackedCallIds = ConcurrentHashMap.newKeySet<String>()
+
+    // Per-callId pending promises for displayIncomingCall awaiting CALL_REGISTERED_INCOMING_ACTION
+    private val pendingDisplayPromises = mutableMapOf<String, Promise>()
+    private val pendingTimeouts = mutableMapOf<String, Runnable>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val displayTimeoutMs = 10_000L // 10 second safety timeout
+
     private val notificationChannelsManager = NotificationChannelsManager(reactApplicationContext)
     private val callEventBroadcastReceiver = CallEventBroadcastReceiver()
     private val appStateListener =
@@ -86,21 +101,18 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
 
     init {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            reactContext.registerReceiver(
+            reactApplicationContext.registerReceiver(
                     callEventBroadcastReceiver,
                     getReceiverFilter(),
                     Context.RECEIVER_NOT_EXPORTED
             )
         } else {
             @Suppress("UnspecifiedRegisterReceiverFlag")
-            reactContext.registerReceiver(callEventBroadcastReceiver, getReceiverFilter())
+            reactApplicationContext.registerReceiver(callEventBroadcastReceiver, getReceiverFilter())
         }
     }
 
-    override fun getName(): String = NAME
-
-    override fun initialize() {
-        super.initialize()
+    fun initialize() {
         reactApplicationContext.addLifecycleEventListener(appStateListener)
 
         tryToBindIfNeeded()
@@ -108,10 +120,17 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         debugLog(TAG, "[module] initialize: Initializing module")
     }
 
-    override fun invalidate() {
-        super.invalidate()
+    fun invalidate() {
         debugLog(TAG, "[module] invalidate: Invalidating module")
 
+        // Clean up pending display promises to prevent leaks
+        synchronized(pendingDisplayPromises) {
+            pendingTimeouts.values.forEach { mainHandler.removeCallbacks(it) }
+            pendingTimeouts.clear()
+            pendingDisplayPromises.clear()
+        }
+
+        trackedCallIds.clear()
         unbindServiceSafely()
 
         reactApplicationContext.removeLifecycleEventListener(appStateListener)
@@ -119,11 +138,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         isModuleInitialized = false
     }
 
-    override fun setupiOS(options: ReadableMap) {
-        // leave empty
-    }
-
-    override fun setupAndroid(options: ReadableMap) {
+    fun setupAndroid(options: ReadableMap) {
         debugLog(TAG, "[module] setupAndroid: Setting up Android: $options")
         val notificationsConfig =
                 NotificationsConfig.saveNotificationsConfig(reactApplicationContext, options)
@@ -133,24 +148,11 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         isModuleInitialized = true
     }
 
-    override fun canPostNotifications(): Boolean {
+    fun canPostNotifications(): Boolean {
         return notificationChannelsManager.getNotificationStatus().canPost
     }
 
-    override fun setShouldRejectCallWhenBusy(shouldReject: Boolean) {
-        // leave empty
-    }
-
-    override fun getInitialVoipEvents(): WritableArray {
-       // leave empty
-      return Arguments.createArray()
-    }
-
-    override fun registerVoipToken() {
-        // leave empty
-    }
-
-    override fun getInitialEvents(): WritableArray {
+    fun getInitialEvents(): WritableArray {
         // NOTE: writabel native array can be consumed only once, think of getting rid from clear
         // event and clear eat immidiate after getting initial events
         val events = delayedEvents
@@ -160,12 +162,12 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         return events
     }
 
-    override fun setCurrentCallActive(callId: String, promise: Promise) {
+    fun setCurrentCallActive(callId: String, promise: Promise) {
         debugLog(TAG, "[module] activateCall: Activating call: $callId")
         executeServiceAction(callId, CallAction.Activate, promise)
     }
 
-    override fun displayIncomingCall(
+    fun displayIncomingCall(
             callId: String,
             phoneNumber: String,
             callerName: String,
@@ -182,19 +184,52 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             return
         }
 
-        startCallService(
-                CallService.ACTION_INCOMING_CALL,
-                callId,
-                callerName,
-                phoneNumber,
-                hasVideo,
-                displayOptions
-        )
+        trackedCallIds.add(callId)
+
+        // Store the promise keyed by callId; it will be resolved when CALL_REGISTERED_INCOMING_ACTION
+        // broadcast is received, or rejected on timeout / registration failure.
+        synchronized(pendingDisplayPromises) {
+            // 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) }
+
+            pendingDisplayPromises[callId] = promise
+
+            // Per-call timeout runnable
+            val timeoutRunnable = Runnable {
+                synchronized(pendingDisplayPromises) {
+                    pendingDisplayPromises.remove(callId)?.reject(
+                            "TIMEOUT",
+                            "Timed out waiting for call registration: $callId"
+                    )
+                    pendingTimeouts.remove(callId)
+                }
+            }
+            pendingTimeouts[callId] = timeoutRunnable
+            mainHandler.postDelayed(timeoutRunnable, displayTimeoutMs)
+        }
 
-        promise.resolve(true)
+        try {
+            startCallService(
+                    CallService.ACTION_INCOMING_CALL,
+                    callId,
+                    callerName,
+                    phoneNumber,
+                    hasVideo,
+                    displayOptions
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "[module] displayIncomingCall: Failed to start foreground service: ${e.message}", e)
+            trackedCallIds.remove(callId)
+            synchronized(pendingDisplayPromises) {
+                pendingTimeouts.remove(callId)?.let { mainHandler.removeCallbacks(it) }
+                pendingDisplayPromises.remove(callId)
+            }
+            promise.reject("START_FOREGROUND_SERVICE_ERROR", e.message, e)
+        }
     }
 
-    override fun answerIncomingCall(callId: String, promise: Promise) {
+    fun answerIncomingCall(callId: String, promise: Promise) {
         debugLog(TAG, "[module] answerIncomingCall: Answering call: $callId")
         // TODO: get the call type from the call attributes
         val isAudioCall = true // TODO: get the call type from the call attributes
@@ -204,7 +239,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         executeServiceAction(callId, CallAction.Answer(isAudioCall), promise)
     }
 
-    override fun startCall(
+    fun startCall(
             callId: String,
             phoneNumber: String,
             callerName: String,
@@ -221,19 +256,26 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             return
         }
 
-        startCallService(
-                CallService.ACTION_OUTGOING_CALL,
-                callId,
-                callerName,
-                phoneNumber,
-                hasVideo,
-                displayOptions
-        )
+        trackedCallIds.add(callId)
 
-        promise.resolve(true)
+        try {
+            startCallService(
+                    CallService.ACTION_OUTGOING_CALL,
+                    callId,
+                    callerName,
+                    phoneNumber,
+                    hasVideo,
+                    displayOptions
+            )
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "[module] startCall: Failed to start foreground service: ${e.message}", e)
+            trackedCallIds.remove(callId)
+            promise.reject("START_FOREGROUND_SERVICE_ERROR", e.message, e)
+        }
     }
 
-    override fun updateDisplay(
+    fun updateDisplay(
             callId: String,
             phoneNumber: String,
             callerName: String,
@@ -247,84 +289,101 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         }
 
         // for now only display options will be updated, rest of the parameters will be ignored
-        startCallService(
-                CallService.ACTION_UPDATE_CALL,
-                callId,
-                callerName,
-                phoneNumber,
-                true,
-                displayOptions,
-        )
-        promise.resolve(true)
+        try {
+            startCallService(
+                    CallService.ACTION_UPDATE_CALL,
+                    callId,
+                    callerName,
+                    phoneNumber,
+                    true,
+                    displayOptions,
+            )
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "[module] updateDisplay: Failed to start foreground service: ${e.message}", e)
+            promise.reject("START_FOREGROUND_SERVICE_ERROR", e.message, e)
+        }
     }
 
-    override fun endCallWithReason(callId: String, reason: Double, promise: Promise) {
+    fun endCallWithReason(callId: String, reason: Double, promise: Promise) {
         debugLog(TAG, "[module] endCallWithReason: Ending call: $callId, $reason")
+        trackedCallIds.remove(callId)
         val action = CallAction.Disconnect(DisconnectCause(reason.toInt()))
         executeServiceAction(callId, action, promise)
     }
 
-    override fun endCall(callId: String, promise: Promise) {
+    fun endCall(callId: String, promise: Promise) {
         debugLog(TAG, "[module] endCall: Ending call: $callId")
+        trackedCallIds.remove(callId)
         val action = CallAction.Disconnect(DisconnectCause(DisconnectCause.LOCAL))
         executeServiceAction(callId, action, promise)
     }
 
-    override fun isCallRegistered(callId: String): Boolean {
-        val isCallRegistered = callService?.isCallRegistered(callId) ?: false
-        debugLog(TAG, "[module] isCallRegistered: Is call registered: $isCallRegistered")
-        return isCallRegistered
+    fun isCallTracked(callId: String): Boolean {
+        val isTracked = trackedCallIds.contains(callId)
+        debugLog(TAG, "[module] isCallTracked: Is call tracked: $isTracked")
+        return isTracked
     }
 
-    override fun hasRegisteredCall(): Boolean {
+    fun hasRegisteredCall(): Boolean {
         val hasRegisteredCall = callService?.hasRegisteredCall() ?: false
         debugLog(TAG, "[module] hasRegisteredCall: Has registered call: $hasRegisteredCall")
         return hasRegisteredCall
     }
 
-    override fun setMutedCall(callId: String, isMuted: Boolean, promise: Promise) {
+    fun setMutedCall(callId: String, isMuted: Boolean, promise: Promise) {
         debugLog(TAG, "[module] setMutedCall: Setting muted call: $callId, $isMuted")
         val action = CallAction.ToggleMute(isMuted)
         executeServiceAction(callId, action, promise)
     }
 
-    override fun setOnHoldCall(callId: String, isOnHold: Boolean, promise: Promise) {
+    fun setOnHoldCall(callId: String, isOnHold: Boolean, promise: Promise) {
         debugLog(TAG, "[module] setOnHoldCall: Setting on hold call: $callId, $isOnHold")
         val action = if (isOnHold) CallAction.Hold else CallAction.Activate
         executeServiceAction(callId, action, promise)
     }
 
-    override fun startBackgroundTask(taskName: String, timeout: Double, promise: Promise) {
-        Intent(reactApplicationContext, CallService::class.java)
-                .apply {
-                    this.action = CallService.ACTION_START_BACKGROUND_TASK
-                    putExtra(CallService.EXTRA_TASK_NAME, taskName)
-                    putExtra(CallService.EXTRA_TASK_DATA, Bundle())
-                    putExtra(CallService.EXTRA_TASK_TIMEOUT, timeout.toLong())
-                }
-                .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+    fun startBackgroundTask(taskName: String, timeout: Double, promise: Promise) {
+        try {
+            Intent(reactApplicationContext, CallService::class.java)
+                    .apply {
+                        this.action = CallService.ACTION_START_BACKGROUND_TASK
+                        putExtra(CallService.EXTRA_TASK_NAME, taskName)
+                        putExtra(CallService.EXTRA_TASK_DATA, Bundle())
+                        putExtra(CallService.EXTRA_TASK_TIMEOUT, timeout.toLong())
+                    }
+                    .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
 
-        promise.resolve(true)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "[module] startBackgroundTask: Failed to start foreground service: ${e.message}", e)
+            promise.reject("START_FOREGROUND_SERVICE_ERROR", e.message, e)
+        }
     }
 
-    override fun stopBackgroundTask(taskName: String, promise: Promise) {
-        Intent(reactApplicationContext, CallService::class.java)
-                .apply {
-                    this.action = CallService.ACTION_STOP_BACKGROUND_TASK
-                    putExtra(CallService.EXTRA_TASK_NAME, taskName)
-                }
-                .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+    fun stopBackgroundTask(taskName: String, promise: Promise) {
+        try {
+            Intent(reactApplicationContext, CallService::class.java)
+                    .apply {
+                        this.action = CallService.ACTION_STOP_BACKGROUND_TASK
+                        putExtra(CallService.EXTRA_TASK_NAME, taskName)
+                    }
+                    .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
 
-        isHeadlessTaskRegistered = false
-        promise.resolve(true)
+            isHeadlessTaskRegistered = false
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "[module] stopBackgroundTask: Failed to start foreground service: ${e.message}", e)
+            promise.reject("START_FOREGROUND_SERVICE_ERROR", e.message, e)
+        }
     }
 
-    override fun registerBackgroundTaskAvailable() {
+    fun registerBackgroundTaskAvailable() {
         debugLog(TAG, "[module] registerBackgroundTaskAvailable: Headless task registered")
         isHeadlessTaskRegistered = true
     }
 
-    override fun isServiceStarted(promise: Promise) {
+    fun isServiceStarted(promise: Promise) {
         val isStarted =
                 bindingState == BindingState.BOUND ||
                         bindingState == BindingState.BINDING ||
@@ -333,7 +392,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         promise.resolve(isStarted)
     }
 
-    override fun log(message: String, level: String) {
+    fun log(message: String, level: String) {
         when (level) {
             "debug" -> debugLog(TAG, "[module] log: $message")
             "info" -> Log.i(TAG, "[module] log: $message")
@@ -371,14 +430,18 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             return
         }
 
-        Intent(reactApplicationContext, CallService::class.java)
-                .apply {
-                    this.action = CallService.ACTION_START_BACKGROUND_TASK
-                    putExtra(CallService.EXTRA_TASK_NAME, taskName)
-                    putExtra(CallService.EXTRA_TASK_DATA, Bundle())
-                    putExtra(CallService.EXTRA_TASK_TIMEOUT, timeout.toLong())
-                }
-                .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+        try {
+            Intent(reactApplicationContext, CallService::class.java)
+                    .apply {
+                        this.action = CallService.ACTION_START_BACKGROUND_TASK
+                        putExtra(CallService.EXTRA_TASK_NAME, taskName)
+                        putExtra(CallService.EXTRA_TASK_DATA, Bundle())
+                        putExtra(CallService.EXTRA_TASK_TIMEOUT, timeout.toLong())
+                    }
+                    .also { ContextCompat.startForegroundService(reactApplicationContext, it) }
+        } catch (e: Exception) {
+            Log.e(TAG, "[module] startBackgroundTaskAutomatically: Failed to start foreground service: ${e.message}", e)
+        }
     }
 
     private fun executeServiceAction(callId: String, action: CallAction, promise: Promise) {
@@ -432,7 +495,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
                         putString("eventName", eventName)
                         putMap("params", paramsMap)
                     }
-            emitOnNewEvent(value)
+            eventEmitter.emitNewEvent(value)
         } else {
             debugLog(TAG, "[module] sendJSEvent: Queueing event: $eventName, $params")
             Arguments.createMap()
@@ -454,6 +517,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
                 addAction(CALL_MUTED_ACTION)
                 addAction(CALL_ENDPOINT_CHANGED_ACTION)
                 addAction(CALL_END_ACTION)
+                addAction(CALL_REGISTRATION_FAILED_ACTION)
                 addAction(SERVICE_READY_ACTION)
             }
 
@@ -563,8 +627,30 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
                     sendJSEvent("didReceiveStartCallAction", params)
                 }
                 CALL_REGISTERED_INCOMING_ACTION -> {
+                    // Resolve the pending displayIncomingCall promise for this callId
+                    if (callId != null) {
+                        synchronized(pendingDisplayPromises) {
+                            pendingTimeouts.remove(callId)?.let { mainHandler.removeCallbacks(it) }
+                            pendingDisplayPromises.remove(callId)?.resolve(true)
+                        }
+                    }
                     sendJSEvent("didDisplayIncomingCall", params)
                 }
+                CALL_REGISTRATION_FAILED_ACTION -> {
+                    if (callId != null) {
+                        trackedCallIds.remove(callId)
+                    }
+                    // Reject the pending displayIncomingCall promise for this callId
+                    if (callId != null) {
+                        synchronized(pendingDisplayPromises) {
+                            pendingTimeouts.remove(callId)?.let { mainHandler.removeCallbacks(it) }
+                            pendingDisplayPromises.remove(callId)?.reject(
+                                    "REGISTRATION_FAILED",
+                                    "Failed to register call with telecom: $callId"
+                            )
+                        }
+                    }
+                }
                 CALL_ANSWERED_ACTION -> {
                     if (intent.hasExtra(EXTRA_SOURCE)) {
                         params.putString("source", intent.getStringExtra(EXTRA_SOURCE))
@@ -577,6 +663,11 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
                         params.putString("source", source)
                     }
                     if (source == "app") {
+                        if (callId != null) {
+                            //we stop tracking the call only when it was handled by the app
+                            //in case source is "sys" we still need to know that call is tracked, otherwise we'll unable to end call from js side
+                            trackedCallIds.remove(callId)
+                        }
                         // means the call was disconnected, we're ready to unbind the service
                         unbindServiceSafely()
                     }

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

@@ -13,7 +13,7 @@ import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.Person
 import androidx.core.graphics.drawable.IconCompat
 import io.getstream.rn.callingx.CallService
-import io.getstream.rn.callingx.CallingxModule
+import io.getstream.rn.callingx.CallingxModuleImpl
 import io.getstream.rn.callingx.R
 import io.getstream.rn.callingx.ResourceUtils
 import io.getstream.rn.callingx.debugLog
@@ -78,7 +78,7 @@ class CallNotificationManager(
         val contentIntent =
                 NotificationIntentFactory.getLaunchActivityIntent(
                         context,
-                        CallingxModule.CALL_ANSWERED_ACTION,
+                        CallingxModuleImpl.CALL_ANSWERED_ACTION,
                         call.id
                 )
         val callStyle = createCallStyle(call)
@@ -190,21 +190,21 @@ class CallNotificationManager(
                     caller,
                     NotificationIntentFactory.getPendingBroadcastIntent(
                             context,
-                            CallingxModule.CALL_END_ACTION,
+                            CallingxModuleImpl.CALL_END_ACTION,
                             call.id
                     ) {
                         putExtra(
-                                CallingxModule.EXTRA_DISCONNECT_CAUSE,
+                                CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE,
                                 getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
                         )
                         putExtra(
-                                CallingxModule.EXTRA_SOURCE,
+                                CallingxModuleImpl.EXTRA_SOURCE,
                                 CallRepository.EventSource.SYS.name.lowercase()
                         )
                     },
                     NotificationIntentFactory.getPendingNotificationIntent(
                             context,
-                            CallingxModule.CALL_ANSWERED_ACTION,
+                            CallingxModuleImpl.CALL_ANSWERED_ACTION,
                             call.id,
                             CallRepository.EventSource.SYS.name.lowercase()
                     )
@@ -215,15 +215,15 @@ class CallNotificationManager(
                 caller,
                 NotificationIntentFactory.getPendingBroadcastIntent(
                         context,
-                        CallingxModule.CALL_END_ACTION,
+                        CallingxModuleImpl.CALL_END_ACTION,
                         call.id
                 ) {
                     putExtra(
-                            CallingxModule.EXTRA_DISCONNECT_CAUSE,
+                            CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE,
                             getDisconnectCauseString(DisconnectCause(DisconnectCause.LOCAL))
                     )
                     putExtra(
-                            CallingxModule.EXTRA_SOURCE,
+                            CallingxModuleImpl.EXTRA_SOURCE,
                             CallRepository.EventSource.SYS.name.lowercase()
                     )
                 },

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

@@ -4,7 +4,7 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.os.Build
-import io.getstream.rn.callingx.CallingxModule
+import io.getstream.rn.callingx.CallingxModuleImpl
 
 object NotificationIntentFactory {
   // Stable request codes for PendingIntents
@@ -29,8 +29,8 @@ object NotificationIntentFactory {
     val intent =
       Intent(context, NotificationReceiverService::class.java).apply {
         this.action = action
-        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-        putExtra(CallingxModule.EXTRA_SOURCE, source)
+        putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
       }
 
     return PendingIntent.getService(
@@ -45,8 +45,8 @@ object NotificationIntentFactory {
     val receiverIntent =
       Intent(context, NotificationReceiverActivity::class.java).apply {
         this.action = action
-        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-        putExtra(CallingxModule.EXTRA_SOURCE, source)
+        putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
       }
 
     val launchActivity = context.packageManager.getLaunchIntentForPackage(context.packageName)
@@ -68,8 +68,8 @@ object NotificationIntentFactory {
     val callIntent =
       Intent(launchIntent).apply {
         this.action = action
-        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-        source?.let { putExtra(CallingxModule.EXTRA_SOURCE, it) }
+        putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+        source?.let { putExtra(CallingxModuleImpl.EXTRA_SOURCE, it) }
         addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
       }
 
@@ -90,7 +90,7 @@ object NotificationIntentFactory {
     val intent =
       Intent(action).apply {
         setPackage(context.packageName)
-        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
         addExtras(this)
       }
 

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

@@ -3,7 +3,7 @@ package io.getstream.rn.callingx.notifications
 import android.app.Activity
 import android.content.Intent
 import android.os.Bundle
-import io.getstream.rn.callingx.CallingxModule
+import io.getstream.rn.callingx.CallingxModuleImpl
 
 // For Android 12+
 class NotificationReceiverActivity : Activity() {
@@ -27,14 +27,14 @@ class NotificationReceiverActivity : Activity() {
     }
 
     //we need it only for answered call event, as for cold start case we need to send broadcast event and to launch the app
-    if (intent.action == CallingxModule.CALL_ANSWERED_ACTION) {
-      val callId = intent.getStringExtra(CallingxModule.EXTRA_CALL_ID)
-      val source = intent.getStringExtra(CallingxModule.EXTRA_SOURCE)
-      Intent(CallingxModule.CALL_ANSWERED_ACTION)
+    if (intent.action == CallingxModuleImpl.CALL_ANSWERED_ACTION) {
+      val callId = intent.getStringExtra(CallingxModuleImpl.EXTRA_CALL_ID)
+      val source = intent.getStringExtra(CallingxModuleImpl.EXTRA_SOURCE)
+      Intent(CallingxModuleImpl.CALL_ANSWERED_ACTION)
         .apply {
           setPackage(packageName)
-          putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-          putExtra(CallingxModule.EXTRA_SOURCE, source)
+          putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+          putExtra(CallingxModuleImpl.EXTRA_SOURCE, source)
         }
         .also { sendBroadcast(it) }
     }