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

package/android/build.gradle

@@ -26,6 +26,10 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Callingx_" + name]).toInteger()
 }
 
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.newArchEnabled == "true"
+}
+
 android {
   namespace "io.getstream.rn.callingx"
 
@@ -63,6 +67,11 @@ android {
         "build/generated/source/codegen/java",
         "build/generated/source/codegen/jni"
       ]
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += ["src/newarch"]
+      } else {
+        java.srcDirs += ["src/oldarch"]
+      }
     }
   }
 }

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

@@ -20,7 +20,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
-import java.util.concurrent.ConcurrentHashMap
 
 /**
  * This service handles the app call logic (show notification, record mic, display audio, etc..). It
@@ -72,7 +71,6 @@ class CallService : Service(), CallRepository.Listener {
 
     private val binder = CallServiceBinder()
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob())
-    private val trackedCallIds = ConcurrentHashMap.newKeySet<String>()
 
     private var isInForeground = false
 
@@ -85,7 +83,7 @@ class CallService : Service(), CallRepository.Listener {
         callRepository = CallRepositoryFactory.create(applicationContext)
         callRepository.setListener(this)
 
-        sendBroadcastEvent(CallingxModule.SERVICE_READY_ACTION)
+        sendBroadcastEvent(CallingxModuleImpl.SERVICE_READY_ACTION)
     }
 
     override fun onDestroy() {
@@ -102,7 +100,6 @@ class CallService : Service(), CallRepository.Listener {
             isInForeground = false
         }
 
-        trackedCallIds.clear()
         scope.cancel()
     }
 
@@ -188,7 +185,6 @@ class CallService : Service(), CallRepository.Listener {
                 }
             }
             is Call.Unregistered -> {
-                trackedCallIds.remove(call.id)
                 notificationManager.updateCallNotification(call)
 
                 if (isInForeground) {
@@ -200,7 +196,6 @@ class CallService : Service(), CallRepository.Listener {
                 stopSelf()
             }
             is Call.None -> {
-                trackedCallIds.clear()
                 notificationManager.updateCallNotification(call)
 
                 if (isInForeground) {
@@ -213,9 +208,9 @@ class CallService : Service(), CallRepository.Listener {
     }
 
     override fun onIsCallAnswered(callId: String, source: CallRepository.EventSource) {
-        sendBroadcastEvent(CallingxModule.CALL_ANSWERED_ACTION) {
-            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-            putExtra(CallingxModule.EXTRA_SOURCE, source.name.lowercase())
+        sendBroadcastEvent(CallingxModuleImpl.CALL_ANSWERED_ACTION) {
+            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+            putExtra(CallingxModuleImpl.EXTRA_SOURCE, source.name.lowercase())
         }
     }
 
@@ -224,62 +219,55 @@ class CallService : Service(), CallRepository.Listener {
             cause: DisconnectCause,
             source: CallRepository.EventSource
     ) {
-        if (callId != null) {
-            trackedCallIds.remove(callId)
-        }
         // we're not passing the callId here to prevent infinite loops
         // callEnd event with callId will sent only when after interaction with notification buttons
-        sendBroadcastEvent(CallingxModule.CALL_END_ACTION) {
+        sendBroadcastEvent(CallingxModuleImpl.CALL_END_ACTION) {
             if (callId != null) {
-                putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+                putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
             }
-            putExtra(CallingxModule.EXTRA_DISCONNECT_CAUSE, getDisconnectCauseString(cause))
-            putExtra(CallingxModule.EXTRA_SOURCE, source.name.lowercase())
+            putExtra(CallingxModuleImpl.EXTRA_DISCONNECT_CAUSE, getDisconnectCauseString(cause))
+            putExtra(CallingxModuleImpl.EXTRA_SOURCE, source.name.lowercase())
         }
     }
 
     override fun onIsCallInactive(callId: String) {
-        sendBroadcastEvent(CallingxModule.CALL_INACTIVE_ACTION) {
-            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        sendBroadcastEvent(CallingxModuleImpl.CALL_INACTIVE_ACTION) {
+            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
         }
     }
 
     override fun onIsCallActive(callId: String) {
-        sendBroadcastEvent(CallingxModule.CALL_ACTIVE_ACTION) {
-            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        sendBroadcastEvent(CallingxModuleImpl.CALL_ACTIVE_ACTION) {
+            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
         }
     }
 
     override fun onCallRegistered(callId: String, incoming: Boolean) {
         if (incoming) {
-            sendBroadcastEvent(CallingxModule.CALL_REGISTERED_INCOMING_ACTION) {
-                putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+            sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTERED_INCOMING_ACTION) {
+                putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
             }
         } else {
-            sendBroadcastEvent(CallingxModule.CALL_REGISTERED_ACTION) {
-                putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+            sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTERED_ACTION) {
+                putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
             }
         }
     }
 
     override fun onMuteCallChanged(callId: String, isMuted: Boolean) {
-        sendBroadcastEvent(CallingxModule.CALL_MUTED_ACTION) {
-            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-            putExtra(CallingxModule.EXTRA_MUTED, isMuted)
+        sendBroadcastEvent(CallingxModuleImpl.CALL_MUTED_ACTION) {
+            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+            putExtra(CallingxModuleImpl.EXTRA_MUTED, isMuted)
         }
     }
 
     override fun onCallEndpointChanged(callId: String, endpoint: String) {
-        sendBroadcastEvent(CallingxModule.CALL_ENDPOINT_CHANGED_ACTION) {
-            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
-            putExtra(CallingxModule.EXTRA_AUDIO_ENDPOINT, endpoint)
+        sendBroadcastEvent(CallingxModuleImpl.CALL_ENDPOINT_CHANGED_ACTION) {
+            putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callId)
+            putExtra(CallingxModuleImpl.EXTRA_AUDIO_ENDPOINT, endpoint)
         }
     }
 
-    public fun isCallTracked(callId: String): Boolean {
-        return trackedCallIds.contains(callId)
-    }
-
     public fun hasRegisteredCall(): Boolean {
         val currentCall = callRepository.currentCall.value
         return currentCall is Call.Registered
@@ -312,20 +300,18 @@ class CallService : Service(), CallRepository.Listener {
     private fun registerCall(intent: Intent, incoming: Boolean) {
         debugLog(TAG, "[service] registerCall: ${if (incoming) "in" else "out"} call")
         val callInfo = extractIntentParams(intent)
-        // Track immediately when registration flow starts, mirroring iOS semantics.
-        trackedCallIds.add(callInfo.callId)
 
         // If we have an ongoing call, notify the module that registration is
         // already done (so the pending promise resolves) and skip re-registration.
         if (callRepository.currentCall.value is Call.Registered) {
             Log.w(TAG, "[service] registerCall: Call already registered, ignoring new call request")
             if (incoming) {
-                sendBroadcastEvent(CallingxModule.CALL_REGISTERED_INCOMING_ACTION) {
-                    putExtra(CallingxModule.EXTRA_CALL_ID, callInfo.callId)
+                sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTERED_INCOMING_ACTION) {
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
                 }
             } else {
-                sendBroadcastEvent(CallingxModule.CALL_REGISTERED_ACTION) {
-                    putExtra(CallingxModule.EXTRA_CALL_ID, callInfo.callId)
+                sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTERED_ACTION) {
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
                 }
             }
             return
@@ -354,10 +340,9 @@ class CallService : Service(), CallRepository.Listener {
                 )
             } catch (e: Exception) {
                 Log.e(TAG, "[service] registerCall: Error registering call: ${e.message}")
-                trackedCallIds.remove(callInfo.callId)
 
-                sendBroadcastEvent(CallingxModule.CALL_REGISTRATION_FAILED_ACTION) {
-                    putExtra(CallingxModule.EXTRA_CALL_ID, callInfo.callId)
+                sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTRATION_FAILED_ACTION) {
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
                 }
 
                 if (isInForeground) {

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

@@ -0,0 +1,7 @@
+package io.getstream.rn.callingx
+
+import com.facebook.react.bridge.WritableMap
+
+interface CallingxEventEmitterAdapter {
+    fun emitNewEvent(value: WritableMap)
+}

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

@@ -23,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"
@@ -72,6 +74,10 @@ 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>()
@@ -95,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()
@@ -117,8 +120,7 @@ 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
@@ -128,6 +130,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             pendingDisplayPromises.clear()
         }
 
+        trackedCallIds.clear()
         unbindServiceSafely()
 
         reactApplicationContext.removeLifecycleEventListener(appStateListener)
@@ -135,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)
@@ -149,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
@@ -176,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,
@@ -198,6 +184,8 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             return
         }
 
+        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) {
@@ -232,6 +220,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             )
         } 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)
@@ -240,7 +229,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         }
     }
 
-    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
@@ -250,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,
@@ -267,6 +256,8 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             return
         }
 
+        trackedCallIds.add(callId)
+
         try {
             startCallService(
                     CallService.ACTION_OUTGOING_CALL,
@@ -279,11 +270,12 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
             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,
@@ -313,43 +305,45 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         }
     }
 
-    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 isCallTracked(callId: String): Boolean {
-        val isCallTracked = callService?.isCallTracked(callId) ?: false
-        debugLog(TAG, "[module] isCallTracked: Is call tracked: $isCallTracked")
-        return isCallTracked
+    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) {
+    fun startBackgroundTask(taskName: String, timeout: Double, promise: Promise) {
         try {
             Intent(reactApplicationContext, CallService::class.java)
                     .apply {
@@ -367,7 +361,7 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         }
     }
 
-    override fun stopBackgroundTask(taskName: String, promise: Promise) {
+    fun stopBackgroundTask(taskName: String, promise: Promise) {
         try {
             Intent(reactApplicationContext, CallService::class.java)
                     .apply {
@@ -384,12 +378,12 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
         }
     }
 
-    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 ||
@@ -398,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")
@@ -501,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()
@@ -643,6 +637,9 @@ class CallingxModule(reactContext: ReactApplicationContext) : NativeCallingxSpec
                     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) {
@@ -666,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) }
     }