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

package/android/bin/build.gradle

@@ -0,0 +1,81 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Callingx_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "kotlin-parcelize"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Callingx_" + name]).toInteger()
+}
+
+android {
+  namespace "io.getstream.rn.callingx"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni",
+        "build/generated/source/codegen/java",
+        "build/generated/source/codegen/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "androidx.core:core-telecom:1.0.1"
+}

package/android/bin/gradle.properties

@@ -0,0 +1,5 @@
+Callingx_kotlinVersion=2.0.21
+Callingx_minSdkVersion=24
+Callingx_targetSdkVersion=34
+Callingx_compileSdkVersion=35
+Callingx_ndkVersion=27.1.12297006

package/android/bin/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Mon Dec 08 18:11:18 CET 2025
+sdk.dir=/Users/greenfrvr/Library/Android/sdk

package/android/bin/src/main/AndroidManifest.xml

@@ -0,0 +1,30 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_PHONE_CALL" />
+  <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
+
+  <application>
+    <activity
+      android:name="io.getstream.rn.callingx.notifications.NotificationReceiverActivity"
+      android:excludeFromRecents="true"
+      android:exported="false"
+      android:noHistory="true"
+      android:taskAffinity=""
+      android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+
+    <service
+      android:name="io.getstream.rn.callingx.notifications.NotificationReceiverService"
+      android:exported="false" />
+
+    <service
+      android:name="io.getstream.rn.callingx.CallService"
+      android:enabled="true"
+      android:exported="false"
+      android:foregroundServiceType="phoneCall"
+      android:stopWithTask="true" />
+
+  </application>
+</manifest>

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

@@ -0,0 +1,396 @@
+package io.getstream.rn.callingx
+
+import android.app.Service
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.net.Uri
+import android.os.Binder
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import android.telecom.DisconnectCause
+import android.util.Log
+import io.getstream.rn.callingx.model.Call
+import io.getstream.rn.callingx.model.CallAction
+import io.getstream.rn.callingx.notifications.CallNotificationManager
+import io.getstream.rn.callingx.repo.CallRepository
+import io.getstream.rn.callingx.repo.CallRepositoryFactory
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+/**
+ * This service handles the app call logic (show notification, record mic, display audio, etc..). It
+ * can get started by the user or by an upcoming push notification to start a call.
+ *
+ * It holds the call scope used to register a call with the Telecom SDK in our
+ * TelecomCallRepository.
+ *
+ * When registering a call with the Telecom SDK and displaying a CallStyle notification, the SDK
+ * will grant you foreground service delegation so there is no need to make this a FGS.
+ *
+ * Note: you could potentially make this service run in a different process since audio or video
+ * calls can consume significant memory, although that would require more complex setup to make it
+ * work across multiple process.
+ */
+class CallService : Service(), CallRepository.Listener {
+
+    companion object {
+        private const val TAG = "[Callingx] CallService"
+
+        internal const val EXTRA_CALL_ID = "extra_call_id"
+        internal const val EXTRA_NAME = "extra_name"
+        internal const val EXTRA_URI = "extra_uri"
+        internal const val EXTRA_IS_VIDEO = "extra_is_video"
+        internal const val EXTRA_DISPLAY_TITLE = "displayTitle"
+        internal const val EXTRA_DISPLAY_SUBTITLE = "displaySubtitle"
+        internal const val EXTRA_DISPLAY_OPTIONS = "display_options"
+        // Background task extras
+        internal const val EXTRA_TASK_NAME = "task_name"
+        internal const val EXTRA_TASK_DATA = "task_data"
+        internal const val EXTRA_TASK_TIMEOUT = "task_timeout"
+
+        internal const val ACTION_INCOMING_CALL = "incoming_call"
+        internal const val ACTION_OUTGOING_CALL = "outgoing_call"
+        internal const val ACTION_UPDATE_CALL = "update_call"
+        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"
+    }
+
+    inner class CallServiceBinder : Binder() {
+        fun getService(): CallService = this@CallService
+    }
+
+    private lateinit var headlessJSManager: HeadlessTaskManager
+    private lateinit var notificationManager: CallNotificationManager
+    private lateinit var callRepository: CallRepository
+
+    private val binder = CallServiceBinder()
+    private val scope: CoroutineScope = CoroutineScope(SupervisorJob())
+
+    private var isInForeground = false
+
+    override fun onCreate() {
+        super.onCreate()
+        debugLog(TAG, "[service] onCreate: TelecomCallService created")
+
+        notificationManager = CallNotificationManager(applicationContext)
+        headlessJSManager = HeadlessTaskManager(applicationContext)
+        callRepository = CallRepositoryFactory.create(applicationContext)
+        callRepository.setListener(this)
+
+        sendBroadcastEvent(CallingxModule.SERVICE_READY_ACTION)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        debugLog(TAG, "[service] onDestroy: TelecomCallService destroyed")
+
+        notificationManager.cancelNotifications()
+        notificationManager.stopRingtone()
+        callRepository.release()
+        headlessJSManager.release()
+
+        if (isInForeground) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+            isInForeground = false
+        }
+
+        scope.cancel()
+    }
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        super.onTaskRemoved(rootIntent)
+        debugLog(TAG, "[service] onTaskRemoved: Task removed")
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        debugLog(TAG, "[service] onStartCommand: Received intent with action: ${intent?.action}")
+
+        if (intent == null || intent.action == null) {
+            Log.w(TAG, "[service] onStartCommand: Intent is null, returning START_NOT_STICKY")
+            return START_NOT_STICKY
+        }
+
+        when (intent.action) {
+            ACTION_INCOMING_CALL -> {
+                registerCall(intent, true)
+            }
+            ACTION_OUTGOING_CALL -> {
+                registerCall(intent, false)
+            }
+            ACTION_START_BACKGROUND_TASK -> {
+                if (!isInForeground) {
+                    debugLog(TAG, "[service] onStartCommand: Starting foreground for background task")
+                    // for now bg task is intended to be used after a call registered and
+                    // notification is shown, so we don't need to show a separate notification for
+                    // bg task
+                    // startForeground(CallNotificationManager.NOTIFICATION_ID, notification)
+                    // isInForeground = true
+                }
+
+                startBackgroundTask(intent)
+            }
+            ACTION_STOP_BACKGROUND_TASK -> {
+                stopBackgroundTask()
+            }
+            ACTION_UPDATE_CALL -> {
+                updateCall(intent)
+            }
+            else -> {
+                Log.e(TAG, "[service] onStartCommand: Unknown action: ${intent.action}")
+                stopSelf()
+                return START_NOT_STICKY
+            }
+        }
+
+        return START_STICKY
+    }
+
+    override fun onBind(intent: Intent): IBinder? = binder
+
+    override fun onUnbind(intent: Intent): Boolean {
+        debugLog(TAG, "[service] onUnbind: Service unbound")
+        return super.onUnbind(intent)
+    }
+
+    override fun onCallStateChanged(call: Call) {
+        debugLog(TAG, "[service] onCallStateChanged: Call state changed: ${call::class.simpleName}")
+        when (call) {
+            is Call.Registered -> {
+                debugLog(
+                        TAG,
+                        "[service] updateServiceState: Call registered - Active: ${call.isActive}, OnHold: ${call.isOnHold}, Muted: ${call.isMuted}"
+                )
+
+                if (call.isIncoming()) {
+                    if (!call.isActive) notificationManager.startRingtone()
+                    else notificationManager.stopRingtone()
+                }
+                // Update the call state.
+                if (isInForeground) {
+                    notificationManager.updateCallNotification(call)
+                } else {
+                    debugLog(
+                            TAG,
+                            "[service] updateServiceState: Fallback starting foreground for call: ${call.id}"
+                    )
+                    //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
+                }
+            }
+            is Call.Unregistered -> {
+                notificationManager.updateCallNotification(call)
+
+                if (isInForeground) {
+                    stopForeground(STOP_FOREGROUND_REMOVE)
+                    isInForeground = false
+                }
+
+                notificationManager.stopRingtone()
+                stopSelf()
+            }
+            is Call.None -> {
+                notificationManager.updateCallNotification(call)
+
+                if (isInForeground) {
+                    stopForeground(STOP_FOREGROUND_REMOVE)
+                    isInForeground = false
+                }
+                notificationManager.stopRingtone()
+            }
+        }
+    }
+
+    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())
+        }
+    }
+
+    override fun onIsCallDisconnected(
+            callId: String?,
+            cause: DisconnectCause,
+            source: CallRepository.EventSource
+    ) {
+        // 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) {
+            if (callId != null) {
+                putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+            }
+            putExtra(CallingxModule.EXTRA_DISCONNECT_CAUSE, getDisconnectCauseString(cause))
+            putExtra(CallingxModule.EXTRA_SOURCE, source.name.lowercase())
+        }
+    }
+
+    override fun onIsCallInactive(callId: String) {
+        sendBroadcastEvent(CallingxModule.CALL_INACTIVE_ACTION) {
+            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        }
+    }
+
+    override fun onIsCallActive(callId: String) {
+        sendBroadcastEvent(CallingxModule.CALL_ACTIVE_ACTION) {
+            putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        }
+    }
+
+    override fun onCallRegistered(callId: String) {
+        sendBroadcastEvent(CallingxModule.CALL_REGISTERED_ACTION) {
+            putExtra(CallingxModule.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)
+        }
+    }
+
+    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)
+        }
+    }
+
+    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
+    }
+
+    public fun processAction(callId: String, action: CallAction) {
+        debugLog(TAG, "[service] processAction: Processing action: ${action::class.simpleName}")
+        val currentCall = callRepository.currentCall.value
+        if (currentCall is Call.Registered && currentCall.id == callId) {
+            currentCall.processAction(action)
+        } else {
+            Log.e(
+                    TAG,
+                    "[service] processAction: Call not registered or not the current call, ignoring action"
+            )
+        }
+    }
+
+    public fun startBackgroundTask(intent: Intent) {
+        val taskName = intent.getStringExtra(EXTRA_TASK_NAME)!!
+        val data = intent.getBundleExtra(EXTRA_TASK_DATA)!!
+        val timeout = intent.getLongExtra(EXTRA_TASK_TIMEOUT, 0)
+        headlessJSManager.startHeadlessTask(taskName, data, timeout)
+    }
+
+    public fun stopBackgroundTask() {
+        headlessJSManager.stopHeadlessTask()
+    }
+
+    private fun registerCall(intent: Intent, incoming: Boolean) {
+        debugLog(TAG, "[service] registerCall: ${if (incoming) "in" else "out"} call")
+
+        // If we have an ongoing call ignore command
+        if (callRepository.currentCall.value is Call.Registered) {
+            Log.w(TAG, "[service] registerCall: Call already registered, ignoring new call request")
+            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}"
+                    )
+            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
+        }
+
+        scope.launch {
+            try {
+                callRepository.registerCall(
+                        callInfo.callId,
+                        callInfo.name,
+                        callInfo.uri,
+                        incoming,
+                        callInfo.isVideo,
+                        callInfo.displayOptions,
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "[service] registerCall: Error registering call: ${e.message}")
+
+                if (isInForeground) {
+                    stopForeground(STOP_FOREGROUND_REMOVE)
+                    isInForeground = false
+                }
+
+                notificationManager.cancelNotifications()
+                notificationManager.stopRingtone()
+                stopSelf()
+            }
+        }
+    }
+
+    private fun updateCall(intent: Intent) {
+        val callInfo = extractIntentParams(intent)
+        callRepository.updateCall(
+                callInfo.callId,
+                callInfo.name,
+                callInfo.uri,
+                callInfo.isVideo,
+                callInfo.displayOptions
+        )
+    }
+
+    private fun extractIntentParams(intent: Intent): CallInfo {
+        val callId = intent.getStringExtra(EXTRA_CALL_ID)!!
+        val name = intent.getStringExtra(EXTRA_NAME)!!
+        val uri =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    intent.getParcelableExtra(EXTRA_URI, Uri::class.java)!!
+                } else {
+                    @Suppress("DEPRECATION") intent.getParcelableExtra(EXTRA_URI)!!
+                }
+        val isVideo = intent.getBooleanExtra(EXTRA_IS_VIDEO, false)
+        val displayOptions = intent.getBundleExtra(EXTRA_DISPLAY_OPTIONS)
+
+        return CallInfo(callId, name, uri, isVideo, displayOptions)
+    }
+
+    private fun sendBroadcastEvent(action: String, applyParams: Intent.() -> Unit = {}) {
+        val intent =
+                Intent(action).apply {
+                    setPackage(packageName)
+                    applyParams(this)
+                }
+        sendBroadcast(intent)
+    }
+
+    data class CallInfo(
+            val callId: String,
+            val name: String,
+            val uri: Uri,
+            val isVideo: Boolean,
+            val displayOptions: Bundle?,
+    )
+}