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

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

@@ -0,0 +1,438 @@
+package io.getstream.rn.callingx.repo
+
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.telecom.DisconnectCause
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.telecom.CallAttributesCompat
+import androidx.core.telecom.CallControlResult
+import androidx.core.telecom.CallControlScope
+import androidx.core.telecom.CallsManager
+import io.getstream.rn.callingx.debugLog
+import io.getstream.rn.callingx.model.Call
+import io.getstream.rn.callingx.model.CallAction
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.scan
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * The central repository that keeps track of the current call and allows to register new calls.
+ *
+ * This class contains the main logic to integrate with Telecom SDK.
+ *
+ * @see registerCall
+ */
+@RequiresApi(Build.VERSION_CODES.O)
+class TelecomCallRepository(context: Context) : CallRepository(context) {
+
+    companion object {
+        private const val TAG = "[Callingx] TelecomCallRepository"
+    }
+
+    private var observeCallStateJob: Job? = null
+
+    private val callsManager: CallsManager
+    private var isSelfAnswered = false
+    private var isSelfDisconnected = false
+
+    init {
+        val capabilities =
+                CallsManager.CAPABILITY_SUPPORTS_CALL_STREAMING or
+                        CallsManager.CAPABILITY_SUPPORTS_VIDEO_CALLING
+        callsManager =
+                CallsManager(context.applicationContext).apply {
+                    registerAppWithTelecom(capabilities)
+                }
+        debugLog(TAG, "[repository] init: CallsManager created and registered")
+    }
+
+    override fun getTag(): String = TAG
+
+    override fun setListener(listener: Listener?) {
+        this._listener = listener
+
+        observeCallStateJob?.cancel()
+        observeCallStateJob = observeCallState()
+    }
+
+    override fun release() {
+        val currentCall = currentCall.value
+        if (currentCall is Call.Registered) {
+            currentCall.processAction(CallAction.Disconnect(DisconnectCause(DisconnectCause.LOCAL)))
+        }
+        _currentCall.value = Call.None
+
+        observeCallStateJob?.cancel()
+        observeCallStateJob = null
+        _listener = null
+
+        scope.cancel()
+    }
+
+    /**
+     * Register a new call with the provided attributes. Use the [currentCall] StateFlow to receive
+     * status updates and process call related actions.
+     */
+    override suspend fun registerCall(
+            callId: String,
+            displayName: String,
+            address: Uri,
+            isIncoming: Boolean,
+            isVideo: Boolean,
+            displayOptions: Bundle?,
+    ) {
+        debugLog(
+                TAG,
+                "[repository] registerCall: Starting registration - Name: $displayName, Address: $address, Incoming: $isIncoming"
+        )
+
+        registrationMutex.withLock {
+            // For simplicity we don't support multiple calls
+            if (_currentCall.value is Call.Registered) {
+                Log.w(
+                        TAG,
+                        "[repository] registerCall: Call already registered, ignoring new call request"
+                )
+                return@withLock
+            }
+            debugLog(
+                    TAG,
+                    "[repository] registerCall: No existing call found, proceeding with registration"
+            )
+
+            val attributes = createCallAttributes(displayName, address, isIncoming, isVideo)
+            val actionSource = Channel<CallAction>()
+
+            // Register the call and handle actions in the scope
+            try {
+                callsManager.addCall(
+                        attributes,
+                        onIsCallAnswered, // Watch needs to know if it can answer the call
+                        onIsCallDisconnected,
+                        onIsCallActive,
+                        onIsCallInactive
+                ) {
+                    debugLog(
+                            TAG,
+                            "[repository] registerCall: Inside call scope, setting up call handlers"
+                    )
+
+                    // Consume the actions to interact with the call inside the scope
+                    launch { processCallActions(actionSource.consumeAsFlow()) }
+
+                    // Update the state to registered with default values while waiting for Telecom
+                    // updates
+                    debugLog(
+                            TAG,
+                            "[repository] registerCall: Creating Registered call state with ID: $callId"
+                    )
+                    _currentCall.value =
+                            Call.Registered(
+                                    id = callId,
+                                    isActive = false, // can we just register the call as active?
+                                    isOnHold = false,
+                                    callAttributes = attributes,
+                                    displayOptions = displayOptions,
+                                    isMuted = false,
+                                    errorCode = null,
+                                    currentCallEndpoint = null,
+                                    availableCallEndpoints = emptyList(),
+                                    actionSource = actionSource,
+                            )
+                    debugLog(TAG, "[repository] registerCall: Call state updated to Registered")
+
+                    launch {
+                        currentCallEndpoint.collect {
+                            updateCurrentCall { copy(currentCallEndpoint = it) }
+                        }
+                    }
+                    launch {
+                        availableEndpoints.collect {
+                            updateCurrentCall { copy(availableCallEndpoints = it) }
+                        }
+                    }
+                    launch { isMuted.collect { updateCurrentCall { copy(isMuted = it) } } }
+                }
+                debugLog(
+                        TAG,
+                        "[repository] registerCall: Call successfully registered with Telecom SDK"
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "[repository] registerCall: Error registering call", e)
+                throw e
+            } finally {
+                debugLog(TAG, "[repository] registerCall: Call scope ended, setting state to None")
+                _currentCall.value = Call.None
+            }
+        }
+    }
+
+    override fun updateCall(
+            callId: String,
+            displayName: String,
+            address: Uri,
+            isVideo: Boolean,
+            displayOptions: Bundle?,
+    ) {
+        debugLog(
+                TAG,
+                "[repository] updateCall: Starting update - Name: $displayName, Address: $address, IsVideo: $isVideo"
+        )
+        super.updateCall(callId, displayName, address, isVideo, displayOptions)
+    }
+
+    private fun observeCallState(): Job {
+        return currentCall
+                .scan(Pair<Call?, Call>(null, currentCall.value)) { (_, prev), next ->
+                    Pair(prev, next)
+                }
+                .onEach { (previous, current) ->
+                    when {
+                        previous is Call.None && current is Call.Registered -> {
+                            if (!current.isIncoming()) {
+                                _listener?.onCallRegistered(current.id)
+                            }
+                        }
+                        previous is Call.Registered && current is Call.Registered -> {
+                            if (previous.isMuted != current.isMuted) {
+                                debugLog(
+                                        TAG,
+                                        "[repository] observeCallState: Mute changed: ${current.isMuted}"
+                                )
+                                _listener?.onMuteCallChanged(current.id, current.isMuted)
+                            }
+                            if (previous.currentCallEndpoint != current.currentCallEndpoint) {
+                                current.currentCallEndpoint?.let {
+                                    _listener?.onCallEndpointChanged(current.id, it.name.toString())
+                                }
+                            }
+                        }
+                    }
+                    _listener?.onCallStateChanged(current)
+                }
+                .launchIn(scope)
+    }
+
+    /** Collect the action source to handle client actions inside the call scope */
+    private suspend fun CallControlScope.processCallActions(actionSource: Flow<CallAction>) {
+        actionSource.collect { action ->
+            debugLog(TAG, "[repository] processCallActions: action: ${action::class.simpleName}")
+            when (action) {
+                is CallAction.Answer -> {
+                    doAnswer(action.isAudioCall)
+                }
+                is CallAction.Disconnect -> {
+                    doDisconnect(action)
+                }
+                is CallAction.SwitchAudioEndpoint -> {
+                    doSwitchEndpoint(action)
+                }
+                is CallAction.TransferCall -> {
+                    debugLog(
+                            TAG,
+                            "[repository] processCallActions: Transfer to endpoint: ${action.endpointId}"
+                    )
+                    val call = _currentCall.value as? Call.Registered
+                    val endpoints =
+                            call?.availableCallEndpoints?.firstOrNull {
+                                it.identifier == action.endpointId
+                            }
+                    if (endpoints != null) {
+                        requestEndpointChange(
+                                endpoint = endpoints,
+                        )
+                    } else {
+                        Log.w(
+                                TAG,
+                                "[repository] processCallActions: Endpoint not found for transfer, ignoring"
+                        )
+                    }
+                }
+                CallAction.Hold -> {
+                    when (val result = setInactive()) {
+                        is CallControlResult.Success -> {
+                            onIsCallInactive()
+                        }
+                        is CallControlResult.Error -> {
+                            Log.e(
+                                    TAG,
+                                    "[repository] processCallActions: Hold action failed with error code: ${result.errorCode}"
+                            )
+                            updateCurrentCall { copy(errorCode = result.errorCode) }
+                        }
+                    }
+                }
+                CallAction.Activate -> {
+                    when (val result = setActive()) {
+                        is CallControlResult.Success -> {
+                            onIsCallActive()
+                        }
+                        is CallControlResult.Error -> {
+                            Log.e(
+                                    TAG,
+                                    "[repository] processCallActions: Activate action failed with error code: ${result.errorCode}"
+                            )
+                            updateCurrentCall { copy(errorCode = result.errorCode) }
+                        }
+                    }
+                }
+                is CallAction.ToggleMute -> {
+                    // We cannot programmatically mute the telecom stack. Instead we just update
+                    // the state of the call and this will start/stop audio capturing.
+                    debugLog(TAG, "[repository] processCallActions: Toggling mute: ${action.isMute}")
+                    updateCurrentCall {
+                        val newMutedState = action.isMute
+                        copy(isMuted = newMutedState)
+                    }
+                }
+            }
+        }
+        debugLog(TAG, "[repository] processCallActions: Action collection ended")
+    }
+
+
+    private suspend fun CallControlScope.doSwitchEndpoint(action: CallAction.SwitchAudioEndpoint) {
+        debugLog(TAG, "[repository] doSwitchEndpoint: Switching to endpoint: ${action.endpointId}")
+        if (_currentCall.value !is Call.Registered) {
+            Log.w(TAG, "[repository] doSwitchEndpoint: Call not registered, ignoring")
+            return
+        }
+        // TODO once availableCallEndpoints is a state flow we can just get the value
+        val endpoints = (_currentCall.value as Call.Registered).availableCallEndpoints
+        // Switch to the given endpoint or fallback to the best possible one.
+        val newEndpoint = endpoints.firstOrNull { it.identifier == action.endpointId }
+
+        if (newEndpoint != null) {
+            debugLog(
+                    TAG,
+                    "[repository] doSwitchEndpoint: Found endpoint: ${newEndpoint.name}, requesting change"
+            )
+            requestEndpointChange(newEndpoint).also {
+                debugLog(TAG, "[repository] doSwitchEndpoint: Endpoint change result: $it")
+            }
+        } else {
+            Log.w(TAG, "[repository] doSwitchEndpoint: Endpoint not found in available endpoints")
+        }
+    }
+
+    private suspend fun CallControlScope.doDisconnect(action: CallAction.Disconnect) {
+        isSelfDisconnected = true
+        debugLog(TAG, "[repository] doDisconnect: Disconnecting call with cause: ${action.cause}")
+        disconnect(action.cause)
+        debugLog(TAG, "[repository] doDisconnect: Disconnect called, triggering onIsCallDisconnected")
+        onIsCallDisconnected(action.cause)
+    }
+
+    private suspend fun CallControlScope.doAnswer(isAudioCall: Boolean) {
+        isSelfAnswered = true
+        val callType =
+                if (isAudioCall) CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+                else CallAttributesCompat.CALL_TYPE_VIDEO_CALL
+
+        when (val result = answer(callType)) {
+            is CallControlResult.Success -> {
+                onIsCallAnswered(callType)
+            }
+            is CallControlResult.Error -> {
+                Log.e(
+                        TAG,
+                        "[repository] doAnswer: Answer failed with error code: ${result.errorCode}"
+                )
+                isSelfAnswered = false
+                updateCurrentCall {
+                    Call.Unregistered(
+                            id = id,
+                            callAttributes = callAttributes,
+                            disconnectCause = DisconnectCause(DisconnectCause.BUSY),
+                    )
+                }
+            }
+        }
+    }
+
+    /**
+     * Can the call be successfully answered?? TIP: We would check the connection/call state to see
+     * if we can answer a call Example you may need to wait for another call to hold.
+     */
+    val onIsCallAnswered: suspend (type: Int) -> Unit = {
+        debugLog(
+                TAG,
+                "[repository] onIsCallAnswered: Call answered, type: $it, isSelfAnswered: $isSelfAnswered"
+        )
+        updateCurrentCall { copy(isActive = true, isOnHold = false) }
+
+        val call = _currentCall.value
+        val source =
+                if (isSelfAnswered) EventSource.APP
+                else EventSource.SYS
+        if (call is Call.Registered) {
+            _listener?.onIsCallAnswered(call.id, source)
+        }
+        isSelfAnswered = false
+        debugLog(TAG, "[repository] onIsCallAnswered: Call state updated to active")
+    }
+
+    /** Can the call perform a disconnect */
+    val onIsCallDisconnected: suspend (cause: DisconnectCause) -> Unit = {
+        debugLog(
+                TAG,
+                "[repository] onIsCallDisconnected: Call disconnected, cause: ${it.reason}, description: ${it.description}"
+        )
+        val source =
+                if (isSelfDisconnected) EventSource.APP
+                else EventSource.SYS
+        var callId: String? = null
+        if (_currentCall.value is Call.Registered) {
+            callId = (_currentCall.value as Call.Registered).id
+        }
+
+        updateCurrentCall { Call.Unregistered(id, callAttributes, it) }
+        _listener?.onIsCallDisconnected(callId, it, source)
+        isSelfDisconnected = false
+        debugLog(TAG, "[repository] onIsCallDisconnected: Call state updated to Unregistered")
+    }
+
+    /**
+     * Check is see if we can make the call active. Other calls and state might stop us from
+     * activating the call
+     */
+    val onIsCallActive: suspend () -> Unit = {
+        debugLog(TAG, "[repository] onIsCallActive: Call became active")
+        updateCurrentCall {
+            copy(
+                    errorCode = null,
+                    isActive = true,
+                    isOnHold = false,
+            )
+        }
+
+        val call = _currentCall.value
+        if (call is Call.Registered) {
+            _listener?.onIsCallActive(call.id)
+        }
+        debugLog(TAG, "[repository] onIsCallActive: Call state updated")
+    }
+
+    /** Check to see if we can make the call inactivate */
+    val onIsCallInactive: suspend () -> Unit = {
+        debugLog(TAG, "[repository] onIsCallInactive: Call became inactive (on hold)")
+        updateCurrentCall { copy(errorCode = null, isOnHold = true) }
+
+        val call = _currentCall.value
+        if (call is Call.Registered) {
+            _listener?.onIsCallInactive(call.id)
+        }
+        debugLog(TAG, "[repository] onIsCallInactive: Call state updated to on hold")
+    }
+
+}

package/android/bin/src/main/res/drawable/ic_phone_paused_24.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:autoMirrored="true"
+    android:tint="#000000"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M16,3c-0.55,0 -1,0.45 -1,1v5c0,0.55 0.45,1 1,1s1,-0.45 1,-1L17,4c0,-0.55 -0.45,-1 -1,-1zM19,4v5c0,0.55 0.45,1 1,1s1,-0.45 1,-1L21,4c0,-0.55 -0.45,-1 -1,-1s-1,0.45 -1,1zM19.23,15.26l-2.54,-0.29c-0.61,-0.07 -1.21,0.14 -1.64,0.57l-1.84,1.84c-2.83,-1.44 -5.15,-3.75 -6.59,-6.59l1.85,-1.85c0.43,-0.43 0.64,-1.03 0.57,-1.64l-0.29,-2.52c-0.12,-1.01 -0.97,-1.77 -1.99,-1.77L5.03,3.01c-1.13,0 -2.07,0.94 -2,2.07 0.53,8.54 7.36,15.36 15.89,15.89 1.13,0.07 2.07,-0.87 2.07,-2v-1.73c0.01,-1.01 -0.75,-1.86 -1.76,-1.98z" />
+</vector>

package/android/bin/src/main/res/drawable/ic_round_call_24.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:autoMirrored="true"
+    android:tint="#000000"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M19.23,15.26l-2.54,-0.29c-0.61,-0.07 -1.21,0.14 -1.64,0.57l-1.84,1.84c-2.83,-1.44 -5.15,-3.75 -6.59,-6.59l1.85,-1.85c0.43,-0.43 0.64,-1.03 0.57,-1.64l-0.29,-2.52c-0.12,-1.01 -0.97,-1.77 -1.99,-1.77H5.03c-1.13,0 -2.07,0.94 -2,2.07 0.53,8.54 7.36,15.36 15.89,15.89 1.13,0.07 2.07,-0.87 2.07,-2v-1.73c0.01,-1.01 -0.75,-1.86 -1.76,-1.98z" />
+</vector>

package/android/bin/src/main/res/drawable/ic_user.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+     Copyright (c) 2024 Stream.io Inc. All rights reserved.
+
+     Licensed under the Stream License;
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          https://github.com/GetStream/stream-video-android/blob/main/LICENSE
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#CCC"
+        android:pathData="M480,0a480,480 0 1,0 0,960a480,480 0 1,0 0,-960" />
+    <path
+        android:fillColor="#434343"
+        android:pathData="M480,480q-66,0 -113,-47t-47,-113q0,-66 47,-113t113,-47q66,0 113,47t47,113q0,66 -47,113t-113,47ZM160,720v-32q0,-34 17.5,-62.5T224,582q62,-31 126,-46.5T480,520q66,0 130,15.5T736,582q29,15 46.5,43.5T800,688v32q0,33 -23.5,56.5T720,800L240,800q-33,0 -56.5,-23.5T160,720Z" />
+</vector>

package/android/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/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/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>