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

package/README.md

@@ -68,7 +68,6 @@ withCompletionHandler:(void (^)(void))completion {
                        supportsDTMF:NO
                    supportsGrouping:NO
                  supportsUngrouping:NO
-                        fromPushKit:YES
                             payload:payload.dictionaryPayload
               withCompletionHandler:completion];
 }

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

@@ -1,5 +1,6 @@
 package io.getstream.rn.callingx
 
+import android.app.Notification
 import android.app.Service
 import android.content.Intent
 import android.content.pm.ServiceInfo
@@ -57,6 +58,7 @@ class CallService : Service(), CallRepository.Listener {
         internal const val ACTION_START_BACKGROUND_TASK = "start_background_task"
         internal const val ACTION_STOP_BACKGROUND_TASK = "stop_background_task"
         internal const val ACTION_STOP_SERVICE = "stop_service"
+        internal const val ACTION_REGISTRATION_FAILED = "registration_failed"
     }
 
     inner class CallServiceBinder : Binder() {
@@ -81,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() {
@@ -179,8 +181,7 @@ class CallService : Service(), CallRepository.Listener {
                     )
                     //fallback if for some reason startForeground method is not called in onStartCommand method
                     val notification = notificationManager.createNotification(call)
-                    startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
-                    isInForeground = true
+                    startForegroundSafely(notification)
                 }
             }
             is Call.Unregistered -> {
@@ -207,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())
         }
     }
 
@@ -220,58 +221,53 @@ class CallService : Service(), CallRepository.Listener {
     ) {
         // 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 isCallRegistered(callId: String): Boolean {
-        val currentCall = callRepository.currentCall.value
-        return currentCall is Call.Registered && currentCall.id == callId
-    }
-
     public fun hasRegisteredCall(): Boolean {
         val currentCall = callRepository.currentCall.value
         return currentCall is Call.Registered
@@ -303,33 +299,33 @@ 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)
 
-        // If we have an ongoing call ignore command
+        // 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(CallingxModuleImpl.CALL_REGISTERED_INCOMING_ACTION) {
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
+                }
+            } else {
+                sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTERED_ACTION) {
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
+                }
+            }
             return
         }
-
-        val callInfo = extractIntentParams(intent)
         val tempCall = callRepository.getTempCall(callInfo, incoming)
 
         //it is better to invoke startForeground method synchronously inside onStartCommand method
         if (!isInForeground) {
             debugLog(
-                            TAG,
-                            "[service] registerCall: Starting foreground for call: ${callInfo.callId}"
-                    )
+                    TAG,
+                    "[service] registerCall: Starting foreground for call: ${callInfo.callId}"
+            )
             val notification = notificationManager.createNotification(tempCall)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                startForeground(
-                    CallNotificationManager.NOTIFICATION_ID,
-                    notification,
-                    ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
-                )
-            } else {
-                startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
-            }
-            isInForeground = true
+            startForegroundSafely(notification)
         }
 
         scope.launch {
@@ -345,6 +341,10 @@ class CallService : Service(), CallRepository.Listener {
             } catch (e: Exception) {
                 Log.e(TAG, "[service] registerCall: Error registering call: ${e.message}")
 
+                sendBroadcastEvent(CallingxModuleImpl.CALL_REGISTRATION_FAILED_ACTION) {
+                    putExtra(CallingxModuleImpl.EXTRA_CALL_ID, callInfo.callId)
+                }
+
                 if (isInForeground) {
                     stopForeground(STOP_FOREGROUND_REMOVE)
                     isInForeground = false
@@ -357,6 +357,30 @@ class CallService : Service(), CallRepository.Listener {
         }
     }
 
+    private fun startForegroundSafely(notification: Notification) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                startForeground(
+                        CallNotificationManager.NOTIFICATION_ID,
+                        notification,
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
+                )
+            } else {
+                startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
+            }
+            isInForeground = true
+        } catch (e: Exception) {
+            // If starting the foreground service fails (for example due to background start
+            // restrictions or notification issues), we log the error but avoid crashing the
+            // process so the rest of the call flow can continue and be recovered by Telecom.
+            Log.e(
+                    TAG,
+                    "[service] startForegroundSafely: Failed to start foreground service: ${e.message}",
+                    e
+            )
+        }
+    }
+
     private fun updateCall(intent: Intent) {
         val callInfo = extractIntentParams(intent)
         callRepository.updateCall(

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)
+}