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

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

@@ -0,0 +1,164 @@
+package io.getstream.rn.callingx
+
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactInstanceEventListener
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener
+
+class HeadlessTaskManager(private val context: Context) : HeadlessJsTaskEventListener {
+
+  private var activeTaskId: Int? = null
+
+  companion object {
+    private const val TAG = "[Callingx] HeadlessTaskManager"
+  }
+
+  public fun startHeadlessTask(taskName: String, data: Bundle, timeout: Long) {
+    debugLog(TAG, "[headless] startHeadlessTask: Starting headless task: $taskName, $data, $timeout")
+    if (activeTaskId != null) {
+      Log.w(TAG, "[headless] startHeadlessTask: Task already starting or active, ignoring new task request")
+      return
+    }
+
+    if (UiThreadUtil.isOnUiThread()) {
+      startTask(HeadlessJsTaskConfig(taskName, Arguments.fromBundle(data), timeout, true))
+    } else {
+      UiThreadUtil.runOnUiThread(
+              Runnable {
+                startTask(HeadlessJsTaskConfig(taskName, Arguments.fromBundle(data), timeout, true))
+              }
+      )
+    }
+  }
+
+  public fun stopHeadlessTask() {
+    debugLog(TAG, "[headless] stopHeadlessTask: Stopping headless task")
+    activeTaskId?.let { taskId ->
+      if (UiThreadUtil.isOnUiThread()) {
+        stopTask(taskId)
+      } else {
+        UiThreadUtil.runOnUiThread(Runnable { stopTask(taskId) })
+      }
+    }
+  }
+
+  protected fun startTask(taskConfig: HeadlessJsTaskConfig) {
+    UiThreadUtil.assertOnUiThread()
+
+    val context = reactContext
+    if (context == null) {
+      createReactContextAndScheduleTask(taskConfig)
+    } else {
+      invokeStartTask(context, taskConfig)
+    }
+  }
+
+  private fun invokeStartTask(reactContext: ReactContext, taskConfig: HeadlessJsTaskConfig) {
+    debugLog(TAG, "[headless] invokeStartTask: Invoking start task")
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext)
+    headlessJsTaskContext.addTaskEventListener(this)
+
+    UiThreadUtil.runOnUiThread {
+      val taskId = headlessJsTaskContext.startTask(taskConfig)
+      activeTaskId = taskId
+    }
+  }
+
+  private fun stopTask(taskId: Int) {
+    reactContext?.let { context ->
+      val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(context)
+      if (headlessJsTaskContext.isTaskRunning(taskId)) {
+        headlessJsTaskContext.finishTask(taskId)
+        debugLog(TAG, "Stopped task: $taskId")
+      }
+    }
+  }
+
+  fun release() {
+    stopHeadlessTask()
+
+    reactContext?.let { context ->
+      val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(context)
+      headlessJsTaskContext.removeTaskEventListener(this)
+    }
+  }
+
+  override fun onHeadlessJsTaskStart(taskId: Int) {
+    debugLog(TAG, "[headless] onHeadlessJsTaskStart: Task started: $taskId")
+  }
+
+  override fun onHeadlessJsTaskFinish(taskId: Int) {
+    debugLog(TAG, "[headless] onHeadlessJsTaskFinish: Task finished: $taskId")
+    activeTaskId = null
+  }
+
+  /**
+   * Get the [ReactNativeHost] used by this app. By default, assumes [getApplication] is an instance
+   * of [ReactApplication] and calls [ReactApplication.reactNativeHost].
+   *
+   * Override this method if your application class does not implement `ReactApplication` or you
+   * simply have a different mechanism for storing a `ReactNativeHost`, e.g. as a static field
+   * somewhere.
+   */
+  @Suppress("DEPRECATION")
+  protected open val reactNativeHost: ReactNativeHost
+    get() = (context.applicationContext as ReactApplication).reactNativeHost
+
+  /**
+   * Get the [ReactHost] used by this app. By default, assumes [getApplication] is an instance of
+   * [ReactApplication] and calls [ReactApplication.reactHost]. This method assumes it is called in
+   * new architecture and returns null if not.
+   */
+  protected open val reactHost: ReactHost?
+    get() = (context.applicationContext as ReactApplication).reactHost
+
+  protected val reactContext: ReactContext?
+    get() {
+      if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
+        val reactHost =
+                checkNotNull(reactHost) { "ReactHost is not initialized in New Architecture" }
+        return reactHost.currentReactContext
+      } else {
+        val reactInstanceManager = reactNativeHost.reactInstanceManager
+        return reactInstanceManager.currentReactContext
+      }
+    }
+
+  private fun createReactContextAndScheduleTask(taskConfig: HeadlessJsTaskConfig) {
+    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
+      val reactHost = checkNotNull(reactHost)
+      reactHost.addReactInstanceEventListener(
+              object : ReactInstanceEventListener {
+                override fun onReactContextInitialized(context: ReactContext) {
+                  debugLog(TAG, "createReactContextAndScheduleTask: React context initialized")
+                  invokeStartTask(context, taskConfig)
+                  reactHost.removeReactInstanceEventListener(this)
+                }
+              }
+      )
+      reactHost.start()
+    } else {
+      val reactInstanceManager = reactNativeHost.reactInstanceManager
+      reactInstanceManager.addReactInstanceEventListener(
+              object : ReactInstanceEventListener {
+                override fun onReactContextInitialized(context: ReactContext) {
+                  debugLog(TAG, "createReactContextAndScheduleTask: React context initialized")
+                  invokeStartTask(context, taskConfig)
+                  reactInstanceManager.removeReactInstanceEventListener(this)
+                }
+              }
+      )
+      reactInstanceManager.createReactContextInBackground()
+    }
+  }
+}

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

@@ -0,0 +1,60 @@
+package io.getstream.rn.callingx
+
+import android.content.Context
+import android.media.RingtoneManager
+import android.net.Uri
+import androidx.core.net.toUri
+
+
+object ResourceUtils {
+  private const val TAG = "[Callingx] ResourceUtils"
+
+  private val resourceIdCache = mutableMapOf<String, Int>()
+
+  private fun getResourceIdByName(context: Context, name: String?, type: String): Int {
+    if (name.isNullOrEmpty()) {
+      return 0
+    }
+
+    val normalizedName = name.lowercase().replace("-", "_")
+    val key = "${normalizedName}_$type"
+
+    synchronized(resourceIdCache) {
+      resourceIdCache[key]?.let {
+        return it
+      }
+
+      val packageName = context.packageName
+
+      val id = context.resources.getIdentifier(normalizedName, type, packageName)
+      resourceIdCache[key] = id
+      return id
+    }
+  }
+
+  fun getSoundUri(context: Context, sound: String?): Uri? {
+    debugLog(TAG, "getSoundUri: Getting sound URI for: $sound")
+    return when {
+      sound == null -> null
+      sound.contains("://") -> sound.toUri()
+      sound.equals("default", ignoreCase = true) -> {
+        RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
+      }
+
+      else -> {
+        // The API user is attempting to set a sound by file name, verify it exists
+        var soundResourceId = getResourceIdByName(context, sound, "raw")
+        if (soundResourceId == 0 && sound.contains(".")) {
+          soundResourceId = getResourceIdByName(context, sound.substringBeforeLast('.'), "raw")
+        }
+        if (soundResourceId == 0) {
+          null
+        } else {
+          // Use the actual sound name vs the resource ID, to obtain a stable URI, Issue #341
+          val soundName = context.resources.getResourceEntryName(soundResourceId)
+          "android.resource://${context.packageName}/raw/$soundName".toUri()
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+package io.getstream.rn.callingx
+
+import android.telecom.DisconnectCause
+import android.util.Log
+
+fun getDisconnectCauseString(cause: DisconnectCause): String {
+  return when (cause.code) {
+    DisconnectCause.LOCAL -> "local"
+    DisconnectCause.REMOTE -> "remote"
+    DisconnectCause.REJECTED -> "rejected"
+    DisconnectCause.BUSY -> "busy"
+    DisconnectCause.ANSWERED_ELSEWHERE -> "answeredElsewhere"
+    DisconnectCause.MISSED -> "missed"
+    DisconnectCause.ERROR -> "error"
+    else -> cause.toString()
+  }
+}
+
+fun debugLog(tag: String, message: String) {
+  if (BuildConfig.DEBUG) {
+    Log.d(tag, message)
+  }
+}

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

@@ -0,0 +1,57 @@
+package io.getstream.rn.callingx.model
+
+import android.os.Bundle
+import android.telecom.DisconnectCause
+import androidx.core.telecom.CallAttributesCompat
+import androidx.core.telecom.CallEndpointCompat
+import kotlinx.coroutines.channels.Channel
+
+/**
+ * Custom representation of a call state.
+ */
+sealed class Call {
+
+    /**
+     * There is no current or past calls in the stack
+     */
+    object None : Call()
+
+    /**
+     * Represents a registered call with the telecom stack with the values provided by the
+     * Telecom SDK
+     */
+    data class Registered(
+        val id: String,
+        val callAttributes: CallAttributesCompat,
+        val displayOptions: Bundle?,
+        val isActive: Boolean,
+        val isOnHold: Boolean,
+        val isMuted: Boolean,
+        val errorCode: Int?,
+        val currentCallEndpoint: CallEndpointCompat?,
+        val availableCallEndpoints: List<CallEndpointCompat>,
+        internal val actionSource: Channel<CallAction>,
+    ) : Call() {
+
+        /**
+         * @return true if it's an incoming registered call, false otherwise
+         */
+        fun isIncoming() = callAttributes.direction == CallAttributesCompat.DIRECTION_INCOMING
+
+        /**
+             * Sends an action to the call session. It will be processed if it's still registered.
+         *
+         * @return true if the action was sent, false otherwise
+         */
+        fun processAction(action: CallAction) = actionSource.trySend(action).isSuccess
+    }
+
+    /**
+     * Represent a previously registered call that was disconnected
+     */
+    data class Unregistered(
+        val id: String,
+        val callAttributes: CallAttributesCompat,
+        val disconnectCause: DisconnectCause,
+    ) : Call()
+}

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

@@ -0,0 +1,36 @@
+package io.getstream.rn.callingx.model
+
+import android.os.ParcelUuid
+import android.os.Parcelable
+import android.telecom.DisconnectCause
+import kotlinx.parcelize.Parcelize
+
+/**
+ * Simple interface to represent related call actions to communicate with the registered call scope
+ * in the [TelecomCallRepository.registerCall]
+ *
+ * Note: we are using [Parcelize] to make the actions parcelable so they can be directly used in the
+ * call notification.
+ */
+sealed interface CallAction : Parcelable {
+    @Parcelize
+    data class Answer(val isAudioCall: Boolean) : CallAction
+
+    @Parcelize
+    data class Disconnect(val cause: DisconnectCause) : CallAction
+
+    @Parcelize
+    object Hold : CallAction
+
+    @Parcelize
+    object Activate : CallAction
+
+    @Parcelize
+    data class ToggleMute(val isMute: Boolean) : CallAction
+
+    @Parcelize
+    data class SwitchAudioEndpoint(val endpointId: ParcelUuid) : CallAction
+
+    @Parcelize
+    data class TransferCall(val endpointId: ParcelUuid) : CallAction
+}

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

@@ -0,0 +1,215 @@
+package io.getstream.rn.callingx.notifications
+
+import android.app.Notification
+import android.content.Context
+import android.media.Ringtone
+import android.media.RingtoneManager
+import android.os.Build
+import android.telecom.DisconnectCause
+import android.util.Log
+import androidx.core.app.NotificationCompat
+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.R
+import io.getstream.rn.callingx.ResourceUtils
+import io.getstream.rn.callingx.debugLog
+import io.getstream.rn.callingx.getDisconnectCauseString
+import io.getstream.rn.callingx.model.Call
+import io.getstream.rn.callingx.repo.CallRepository
+
+/**
+ * Handles call status changes and updates the notification accordingly. For more guidance around
+ * notifications check https://developer.android.com/develop/ui/views/notifications
+ *
+ * @see updateCallNotification
+ */
+class CallNotificationManager(
+        private val context: Context,
+        private val notificationManager: NotificationManagerCompat =
+                NotificationManagerCompat.from(context)
+) {
+
+    internal companion object {
+        private const val TAG = "[Callingx] CallNotificationManager"
+
+        const val NOTIFICATION_ID = 200
+    }
+
+    private var notificationsConfig = NotificationsConfig.loadNotificationsConfig(context)
+
+    private var ringtone: Ringtone? = null
+
+    private var hasBecameActive = false
+
+    fun createNotification(call: Call.Registered): Notification {
+        debugLog(
+                TAG,
+                "[notifications] createNotification: Creating notification for call ID: ${call.id}"
+        )
+
+        val contentIntent =
+                NotificationIntentFactory.getLaunchActivityIntent(
+                        context,
+                        CallingxModule.CALL_ANSWERED_ACTION,
+                        call.id
+                )
+        val callStyle = createCallStyle(call)
+        val channelId = getChannelId(call)
+        debugLog(TAG, "[notifications] createNotification: Channel ID: $channelId")
+
+        val builder =
+                NotificationCompat.Builder(context, channelId)
+                        .setContentIntent(contentIntent)
+                        .setFullScreenIntent(contentIntent, true)
+                        .setStyle(callStyle)
+                        .setSmallIcon(R.drawable.ic_round_call_24)
+                        .setCategory(NotificationCompat.CATEGORY_CALL)
+                        .setPriority(NotificationCompat.PRIORITY_MAX)
+                        .setOngoing(true)
+
+        if (!hasBecameActive && call.isActive) {
+            debugLog(TAG, "[notifications] createNotification: Setting when to current time")
+            builder.setWhen(System.currentTimeMillis())
+            builder.setUsesChronometer(true)
+            builder.setShowWhen(true)
+            hasBecameActive = true
+        }
+
+        call.displayOptions?.let {
+            if (it.containsKey(CallService.EXTRA_DISPLAY_SUBTITLE)) {
+                builder.setContentText(it.getString(CallService.EXTRA_DISPLAY_SUBTITLE))
+            }
+        }
+
+        return builder.build()
+    }
+
+    fun updateCallNotification(call: Call) {
+        when (call) {
+            Call.None, is Call.Unregistered -> {
+                debugLog(
+                        TAG,
+                        "[notifications] updateCallNotification: Dismissing notification (call is None or Unregistered)"
+                )
+                notificationManager.cancel(NOTIFICATION_ID)
+            }
+            is Call.Registered -> {
+                val notification = createNotification(call)
+                notificationManager.notify(NOTIFICATION_ID, notification)
+                debugLog(
+                        TAG,
+                        "[notifications] updateCallNotification: Notification posted successfully"
+                )
+            }
+        }
+    }
+
+    fun cancelNotifications() {
+        notificationManager.cancel(NOTIFICATION_ID)
+        hasBecameActive = false
+    }
+
+    fun startRingtone() {
+        if (ringtone?.isPlaying == true) {
+            debugLog(TAG, "[notifications] startRingtone: Ringtone already playing")
+            return
+        }
+
+        try {
+            val soundUri =
+                    ResourceUtils.getSoundUri(context, notificationsConfig.incomingChannel.sound)
+                            ?: RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+
+            ringtone = RingtoneManager.getRingtone(context, soundUri)
+        } catch (e: Exception) {
+            Log.e(TAG, "[notifications] startRingtone: Error starting ringtone: ${e.message}")
+            return
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            ringtone?.isLooping = true
+        }
+
+        ringtone?.play()
+        debugLog(TAG, "[notifications] startRingtone: Ringtone started")
+    }
+
+    fun stopRingtone() {
+        if (ringtone?.isPlaying == true) {
+            ringtone?.stop()
+            debugLog(TAG, "[notifications] stopRingtone: Ringtone stopped")
+        }
+        ringtone = null
+    }
+
+    private fun getChannelId(call: Call.Registered): String {
+        return if (call.isIncoming() && !call.isActive) {
+            notificationsConfig.incomingChannel.id
+        } else {
+            notificationsConfig.ongoingChannel.id
+        }
+    }
+
+    private fun createCallStyle(call: Call.Registered): NotificationCompat.CallStyle {
+        val caller = createPerson(call)
+
+        if (call.isIncoming() && !call.isActive) {
+            return NotificationCompat.CallStyle.forIncomingCall(
+                    caller,
+                    NotificationIntentFactory.getPendingBroadcastIntent(
+                            context,
+                            CallingxModule.CALL_END_ACTION,
+                            call.id
+                    ) {
+                        putExtra(
+                                CallingxModule.EXTRA_DISCONNECT_CAUSE,
+                                getDisconnectCauseString(DisconnectCause(DisconnectCause.REJECTED))
+                        )
+                        putExtra(
+                                CallingxModule.EXTRA_SOURCE,
+                                CallRepository.EventSource.SYS.name.lowercase()
+                        )
+                    },
+                    NotificationIntentFactory.getPendingNotificationIntent(
+                            context,
+                            CallingxModule.CALL_ANSWERED_ACTION,
+                            call.id,
+                            CallRepository.EventSource.SYS.name.lowercase()
+                    )
+            )
+        }
+
+        return NotificationCompat.CallStyle.forOngoingCall(
+                caller,
+                NotificationIntentFactory.getPendingBroadcastIntent(
+                        context,
+                        CallingxModule.CALL_END_ACTION,
+                        call.id
+                ) {
+                    putExtra(
+                            CallingxModule.EXTRA_DISCONNECT_CAUSE,
+                            getDisconnectCauseString(DisconnectCause(DisconnectCause.LOCAL))
+                    )
+                    putExtra(
+                            CallingxModule.EXTRA_SOURCE,
+                            CallRepository.EventSource.SYS.name.lowercase()
+                    )
+                },
+        )
+    }
+
+    private fun createPerson(call: Call.Registered): Person {
+        val displayCallerName = call.displayOptions?.getString(CallService.EXTRA_DISPLAY_TITLE)
+        val address = call.callAttributes.address.toString()
+
+        return Person.Builder()
+                .setName(displayCallerName ?: call.callAttributes.displayName)
+                .setUri(address)
+                .setIcon(IconCompat.createWithResource(context, R.drawable.ic_user))
+                .setImportant(true)
+                .build()
+    }
+}

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

@@ -0,0 +1,113 @@
+package io.getstream.rn.callingx.notifications
+
+import android.Manifest
+import android.content.Context
+import android.os.Build
+import androidx.core.app.NotificationChannelCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.PermissionChecker
+import io.getstream.rn.callingx.debugLog
+
+class NotificationChannelsManager(
+        private val context: Context,
+        private val notificationManager: NotificationManagerCompat =
+                NotificationManagerCompat.from(context)
+) {
+
+  private var notificationsConfig: NotificationsConfig.Channels? = null
+
+  companion object {
+    private const val TAG = "[Callingx] NotificationChannelsManager"
+  }
+
+  data class NotificationStatus(
+          val canPost: Boolean,
+          val hasPermissions: Boolean,
+          val areNotificationsEnabled: Boolean,
+          val isIncomingChannelEnabled: Boolean,
+          val isOngoingChannelEnabled: Boolean,
+  )
+
+  fun setNotificationsConfig(notificationsConfig: NotificationsConfig.Channels) {
+    this.notificationsConfig = notificationsConfig
+  }
+
+  fun createNotificationChannels() {
+    notificationsConfig?.let {
+      val incomingChannel = createNotificationChannel(it.incomingChannel)
+      val ongoingChannel = createNotificationChannel(it.ongoingChannel)
+
+      notificationManager.createNotificationChannelsCompat(
+              listOf(
+                      incomingChannel,
+                      ongoingChannel,
+              ),
+      )
+      debugLog(TAG, "createNotificationChannels: Notification channels registered")
+    }
+  }
+
+  fun getNotificationStatus(): NotificationStatus {
+    val areNotificationsEnabled = areNotificationsEnabled()
+    val hasPermissions = hasNotificationPermissions()
+    val isIncomingChannelEnabled = isChannelEnabled(notificationsConfig?.incomingChannel?.id)
+    val isOngoingChannelEnabled = isChannelEnabled(notificationsConfig?.ongoingChannel?.id)
+
+    val canPost =
+            areNotificationsEnabled &&
+                    hasPermissions &&
+                    isIncomingChannelEnabled &&
+                    isOngoingChannelEnabled
+
+    return NotificationStatus(
+            canPost,
+            hasPermissions,
+            areNotificationsEnabled,
+            isIncomingChannelEnabled,
+            isOngoingChannelEnabled
+    )
+  }
+
+  private fun createNotificationChannel(
+          config: NotificationsConfig.ChannelParams
+  ): NotificationChannelCompat {
+    return NotificationChannelCompat.Builder(config.id, config.importance)
+            .apply {
+              setName(config.name)
+              setVibrationEnabled(config.vibration)
+              setSound(null, null)
+            }
+            .build()
+  }
+
+  private fun areNotificationsEnabled(): Boolean {
+    return notificationManager.areNotificationsEnabled()
+  }
+
+  private fun hasNotificationPermissions(): Boolean {
+    // POST_NOTIFICATIONS permission is only required on Android 13+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+      return true
+    }
+
+    val permission =
+            PermissionChecker.checkSelfPermission(
+                    context,
+                    Manifest.permission.POST_NOTIFICATIONS,
+            )
+    return permission == PermissionChecker.PERMISSION_GRANTED
+  }
+
+  private fun isChannelEnabled(channelId: String?): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return true
+    }
+
+    if (channelId == null) {
+      return false
+    }
+
+    val channel = notificationManager.getNotificationChannel(channelId)
+    return channel != null && channel.importance != NotificationManagerCompat.IMPORTANCE_NONE
+  }
+}