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

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

@@ -0,0 +1,105 @@
+package io.getstream.rn.callingx.notifications
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import io.getstream.rn.callingx.CallingxModule
+
+object NotificationIntentFactory {
+  // Stable request codes for PendingIntents
+  private const val REQUEST_CODE_LAUNCH_ACTIVITY = 1001
+  private const val REQUEST_CODE_RECEIVER_ACTIVITY = 1002
+  private const val REQUEST_CODE_SERVICE = 1003
+
+  fun getPendingNotificationIntent(
+    context: Context,
+    action: String,
+    callId: String,
+    source: String
+  ): PendingIntent {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      getReceiverActivityIntent(context, action, callId, source)
+    } else {
+      getPendingServiceIntent(context, action, callId, source)
+    }
+  }
+
+  fun getPendingServiceIntent(context: Context, action: String, callId: String, source: String): PendingIntent {
+    val intent =
+      Intent(context, NotificationReceiverService::class.java).apply {
+        this.action = action
+        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModule.EXTRA_SOURCE, source)
+      }
+
+    return PendingIntent.getService(
+      context,
+      REQUEST_CODE_SERVICE,
+      intent,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+    )
+  }
+
+  fun getReceiverActivityIntent(context: Context, action: String, callId: String, source: String): PendingIntent {
+    val receiverIntent =
+      Intent(context, NotificationReceiverActivity::class.java).apply {
+        this.action = action
+        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        putExtra(CallingxModule.EXTRA_SOURCE, source)
+      }
+
+    val launchActivity = context.packageManager.getLaunchIntentForPackage(context.packageName)
+    val launchActivityIntent =
+      Intent(launchActivity).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      }
+
+    return PendingIntent.getActivities(
+      context,
+      REQUEST_CODE_RECEIVER_ACTIVITY,
+      arrayOf(launchActivityIntent, receiverIntent),
+      PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+    )
+  }
+
+  fun getLaunchActivityIntent(context: Context, action: String, callId: String, source: String? = null): PendingIntent {
+    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+    val callIntent =
+      Intent(launchIntent).apply {
+        this.action = action
+        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        source?.let { putExtra(CallingxModule.EXTRA_SOURCE, it) }
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      }
+
+    return PendingIntent.getActivity(
+      context,
+      REQUEST_CODE_LAUNCH_ACTIVITY,
+      callIntent,
+      PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+    )
+  }
+
+  fun getPendingBroadcastIntent(
+    context: Context,
+    action: String,
+    callId: String,
+    addExtras: Intent.() -> Unit = {}
+  ): PendingIntent {
+    val intent =
+      Intent(action).apply {
+        setPackage(context.packageName)
+        putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+        addExtras(this)
+      }
+
+    // Use action hashCode for unique request code per action type
+    return PendingIntent.getBroadcast(
+      context,
+      action.hashCode(),
+      intent,
+      PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+    )
+  }
+}

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

@@ -0,0 +1,42 @@
+package io.getstream.rn.callingx.notifications
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import io.getstream.rn.callingx.CallingxModule
+
+// For Android 12+
+class NotificationReceiverActivity : Activity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    handleIntent(intent)
+    finish()
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    super.onNewIntent(intent)
+    handleIntent(intent)
+    finish()
+  }
+
+  //re-send intent from notification to the turbo module
+  private fun handleIntent(intent: Intent?) {
+    if (intent == null) {
+      return
+    }
+
+    //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)
+        .apply {
+          setPackage(packageName)
+          putExtra(CallingxModule.EXTRA_CALL_ID, callId)
+          putExtra(CallingxModule.EXTRA_SOURCE, source)
+        }
+        .also { sendBroadcast(it) }
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+package io.getstream.rn.callingx.notifications
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import android.util.Log
+import io.getstream.rn.callingx.CallingxModule
+
+class NotificationReceiverService : Service() {
+
+  companion object {
+    const val TAG = "[Callingx] NotificationReceiverService"
+  }
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    val action = intent?.action
+    if (action == null) {
+      stopSelf(startId)
+      return START_NOT_STICKY
+    }
+
+    when (action) {
+      CallingxModule.CALL_ANSWERED_ACTION -> onCallAnswered(intent)
+    }
+
+    stopSelf(startId)
+    return START_NOT_STICKY
+  }
+
+  private fun onCallAnswered(intent: Intent) {
+    val callId = intent.getStringExtra(CallingxModule.EXTRA_CALL_ID)
+    val source = intent.getStringExtra(CallingxModule.EXTRA_SOURCE)
+    callId?.let {
+      try {
+        NotificationIntentFactory.getPendingBroadcastIntent(
+                        applicationContext,
+                        CallingxModule.CALL_ANSWERED_ACTION,
+                        it
+                ) { putExtra(CallingxModule.EXTRA_SOURCE, source) }
+                .send()
+
+        NotificationIntentFactory.getLaunchActivityIntent(
+                        applicationContext,
+                        CallingxModule.CALL_ANSWERED_ACTION,
+                        it,
+                        source
+                )
+                .send()
+      } catch (e: Exception) {
+        Log.e(TAG, "Error sending call answered intent", e)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,116 @@
+package io.getstream.rn.callingx.notifications
+
+import android.content.Context
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.edit
+import com.facebook.react.bridge.ReadableMap
+import io.getstream.rn.callingx.debugLog
+
+object NotificationsConfig {
+  private const val TAG = "[Callingx] NotificationsConfig"
+  private const val PREFS_NAME = "CallingxPrefs"
+  private const val PREFIX_IN = "incoming_"
+  private const val PREFIX_OUT = "ongoing_"
+  private const val KEY_ID = "id"
+  private const val KEY_NAME = "name"
+  private const val KEY_SOUND = "sound"
+  private const val KEY_VIBRATION = "vibration"
+
+  data class ChannelParams(
+    val id: String,
+    val name: String,
+    val sound: String?,
+    val vibration: Boolean,
+    val importance: Int,
+  )
+
+  data class Channels(
+    val incomingChannel: ChannelParams,
+    val ongoingChannel: ChannelParams,
+  )
+
+  fun saveNotificationsConfig(context: Context, rawConfig: ReadableMap): Channels {
+    debugLog(TAG, "saveNotificationsConfig: Saving notifications config: $rawConfig")
+    val config = extractNotificationsConfig(rawConfig)
+    val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    prefs.edit {
+      // Incoming channel
+      putString(PREFIX_IN + KEY_ID, config.incomingChannel.id)
+      putString(PREFIX_IN + KEY_NAME, config.incomingChannel.name)
+      putString(PREFIX_IN + KEY_SOUND, config.incomingChannel.sound)
+      putBoolean(PREFIX_IN + KEY_VIBRATION, config.incomingChannel.vibration)
+
+      // Outgoing channel
+      putString(PREFIX_OUT + KEY_ID, config.ongoingChannel.id)
+      putString(PREFIX_OUT + KEY_NAME, config.ongoingChannel.name)
+    }
+
+    return config
+  }
+
+  fun loadNotificationsConfig(context: Context): Channels {
+    val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    debugLog(
+      TAG,
+      "loadNotificationsConfig: Loading notifications config ${
+        prefs.getString(
+          PREFIX_IN + KEY_ID,
+          ""
+        )
+      }"
+    )
+    return Channels(
+      incomingChannel =
+        ChannelParams(
+          id = prefs.getString(PREFIX_IN + KEY_ID, "") ?: "",
+          name = prefs.getString(PREFIX_IN + KEY_NAME, "") ?: "",
+          sound = prefs.getString(PREFIX_IN + KEY_SOUND, "") ?: "",
+          vibration = prefs.getBoolean(PREFIX_IN + KEY_VIBRATION, false),
+          importance = NotificationManagerCompat.IMPORTANCE_MAX,
+        ),
+      ongoingChannel =
+        ChannelParams(
+          id = prefs.getString(PREFIX_OUT + KEY_ID, "") ?: "",
+          name = prefs.getString(PREFIX_OUT + KEY_NAME, "") ?: "",
+          importance = NotificationManagerCompat.IMPORTANCE_DEFAULT,
+          vibration = false,
+          sound = null,
+        )
+    )
+  }
+
+  fun extractNotificationsConfig(config: ReadableMap): Channels {
+    return Channels(
+      incomingChannel =
+        extractChannelConfig(
+          config.getMap("incomingChannel"),
+          NotificationManagerCompat.IMPORTANCE_MAX
+        ),
+      ongoingChannel =
+        extractChannelConfig(
+          config.getMap("ongoingChannel"),
+          NotificationManagerCompat.IMPORTANCE_DEFAULT
+        ),
+    )
+  }
+
+  fun extractChannelConfig(channel: ReadableMap?, importance: Int): ChannelParams {
+    if (channel == null) {
+      return ChannelParams(
+        id = "",
+        name = "",
+        sound = "",
+        vibration = false,
+        importance = importance,
+      )
+    }
+
+    return ChannelParams(
+      id = channel.getString("id") ?: "",
+      name = channel.getString("name") ?: "",
+      sound = channel.getString("sound"),
+      vibration = channel.hasKey("vibration") && channel.getBoolean("vibration") ?: false,
+      importance = importance,
+    )
+  }
+}

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

@@ -0,0 +1,163 @@
+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.core.telecom.CallAttributesCompat
+import io.getstream.rn.callingx.model.Call
+import io.getstream.rn.callingx.model.CallAction
+import io.getstream.rn.callingx.CallService
+import io.getstream.rn.callingx.debugLog
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.channels.Channel
+
+abstract class CallRepository(protected val context: Context) {
+
+  enum class EventSource {
+    APP, SYS
+  }
+
+  interface Listener {
+    fun onCallStateChanged(call: Call)
+    fun onIsCallAnswered(callId: String, source: EventSource)
+    fun onIsCallDisconnected(callId: String?, cause: DisconnectCause, source: EventSource)
+    fun onIsCallInactive(callId: String)
+    fun onIsCallActive(callId: String)
+    fun onCallRegistered(callId: String)
+    fun onMuteCallChanged(callId: String, isMuted: Boolean)
+    fun onCallEndpointChanged(callId: String, endpoint: String)
+  }
+
+  protected val _currentCall: MutableStateFlow<Call> = MutableStateFlow(Call.None)
+  val currentCall: StateFlow<Call> = _currentCall.asStateFlow()
+
+  protected var _listener: Listener? = null
+  protected val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  protected val registrationMutex: Mutex = Mutex()
+
+  abstract fun setListener(listener: Listener?)
+  abstract fun release()
+
+  abstract suspend fun registerCall(
+    callId: String,
+    displayName: String,
+    address: Uri,
+    isIncoming: Boolean,
+    isVideo: Boolean,
+    displayOptions: Bundle?,
+  )
+
+  open fun updateCall(
+    callId: String,
+    displayName: String,
+    address: Uri,
+    isVideo: Boolean,
+    displayOptions: Bundle?,
+  ) {
+    updateCurrentCall { copy(displayOptions = displayOptions) }
+  }
+
+  //this call instance is used to display call notification before the call is registered, this is needed to invoke startForeground method on the service
+  public fun getTempCall(callInfo: CallService.CallInfo, incoming: Boolean): Call.Registered {
+    val attributes = createCallAttributes(
+            displayName = callInfo.name,
+            address = callInfo.uri,
+            isIncoming = incoming,
+            isVideo = callInfo.isVideo
+        )
+
+    return Call.Registered(
+        id = callInfo.callId,
+        isActive = false,
+        isOnHold = false,
+        callAttributes = attributes,
+        displayOptions = callInfo.displayOptions,
+        isMuted = false,
+        errorCode = null,
+        currentCallEndpoint = null,
+        availableCallEndpoints = emptyList(),
+        actionSource = Channel<CallAction>() // Temporary channel, will be replaced by actual registration
+    )
+  }
+
+  /**
+   * Update the current state of our call applying the transform lambda only if the call is
+   * registered. Otherwise keep the current state
+   */
+  protected fun updateCurrentCall(transform: Call.Registered.() -> Call) {
+    val currentState = _currentCall.value
+    debugLog(
+      getTag(),
+      "[repository] updateCurrentCall: Current call state: ${currentState::class.simpleName}"
+    )
+
+    _currentCall.update { call ->
+      if (call is Call.Registered) {
+        val updated = call.transform()
+        debugLog(
+          getTag(),
+          "[repository] updateCurrentCall: Call state updated to: ${updated::class.simpleName}"
+        )
+        updated
+      } else {
+        Log.w(
+          getTag(),
+          "[repository] updateCurrentCall: Call is not Registered, skipping update"
+        )
+        call
+      }
+    }
+  }
+
+  protected fun createCallAttributes(
+    displayName: String,
+    address: Uri,
+    isIncoming: Boolean,
+    isVideo: Boolean
+  ): CallAttributesCompat {
+    return CallAttributesCompat(
+      displayName = displayName,
+      address = address,
+      direction =
+        if (isIncoming) {
+          CallAttributesCompat.DIRECTION_INCOMING
+        } else {
+          CallAttributesCompat.DIRECTION_OUTGOING
+        },
+      callType =
+        if (isVideo) {
+          CallAttributesCompat.CALL_TYPE_VIDEO_CALL
+        } else {
+          CallAttributesCompat.CALL_TYPE_AUDIO_CALL
+        },
+      callCapabilities =
+        CallAttributesCompat.SUPPORTS_SET_INACTIVE or
+          CallAttributesCompat.SUPPORTS_STREAM or
+          CallAttributesCompat.SUPPORTS_TRANSFER,
+    )
+  }
+
+  protected abstract fun getTag(): String
+}
+
+object CallRepositoryFactory {
+
+  fun create(context: Context): CallRepository {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      TelecomCallRepository(context) // Your current CallRepository renamed
+    } else {
+      LegacyCallRepository(context) // Fallback implementation
+    }
+  }
+}

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

@@ -0,0 +1,134 @@
+package io.getstream.rn.callingx.repo
+
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.util.Log
+import androidx.core.telecom.CallAttributesCompat
+import io.getstream.rn.callingx.model.Call
+import io.getstream.rn.callingx.model.CallAction
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.withLock
+
+class LegacyCallRepository(context: Context) : CallRepository(context) {
+
+    companion object {
+        private const val TAG = "[Callingx] LegacyCallRepository"
+    }
+
+    override fun getTag(): String = TAG
+
+    override fun setListener(listener: Listener?) {
+        this._listener = listener
+        // Observe call state changes
+        scope.launch { 
+            try {
+                currentCall.collect { _listener?.onCallStateChanged(it) }
+            } catch (e: Exception) {
+                Log.e(TAG, "[repository] setListener: Error collecting call state", e)
+            }
+        }
+    }
+
+    override fun release() {
+        _currentCall.value = Call.None
+
+        _listener = null
+
+        scope.cancel()
+    }
+
+    override suspend fun registerCall(
+            callId: String,
+            displayName: String,
+            address: Uri,
+            isIncoming: Boolean,
+            isVideo: Boolean,
+            displayOptions: Bundle?,
+    ) {
+        registrationMutex.withLock {
+            if (currentCall.value is Call.Registered) {
+                Log.w(
+                        TAG,
+                        "[repository] registerCall: Call already registered, ignoring new call request"
+                )
+                return@withLock
+            }
+
+            val attributes = createCallAttributes(displayName, address, isIncoming, isVideo)
+            val actionSource = Channel<CallAction>()
+
+            _currentCall.value =
+                    Call.Registered(
+                            id = callId,
+                            isActive = false,
+                            isOnHold = false,
+                            callAttributes = attributes,
+                            displayOptions = displayOptions,
+                            isMuted = false,
+                            errorCode = null,
+                            currentCallEndpoint = null,
+                            availableCallEndpoints = emptyList(),
+                            actionSource = actionSource,
+                    )
+
+            _listener?.onCallRegistered(callId)
+
+            // Process actions without telecom SDK
+            scope.launch {
+                try {
+                    actionSource.consumeAsFlow().collect { action -> processActionLegacy(action) }
+                } catch (e: Exception) {
+                    Log.e(TAG, "[repository] registerCall: Error consuming actions", e)
+                }
+            }
+        }
+    }
+
+    override fun updateCall(
+        callId: String,
+        displayName: String,
+        address: Uri,
+        isVideo: Boolean,
+        displayOptions: Bundle?,
+    ) {
+        super.updateCall(callId, displayName, address, isVideo, displayOptions)
+    }
+
+    private fun processActionLegacy(action: CallAction) {
+        when (action) {
+            is CallAction.Answer -> {
+                updateCurrentCall { copy(isActive = true, isOnHold = false) }
+                // In legacy mode, all actions are initiated from the app
+                (currentCall.value as? Call.Registered)?.let {
+                    _listener?.onIsCallAnswered(it.id, EventSource.APP)
+                }
+            }
+            is CallAction.Disconnect -> {
+                val call = currentCall.value as? Call.Registered
+                if (call != null) {
+                    _currentCall.value =
+                            Call.Unregistered(call.id, call.callAttributes, action.cause)
+                    // In legacy mode, all actions are initiated from the app
+                    _listener?.onIsCallDisconnected(
+                            call.id,
+                            action.cause,
+                            EventSource.APP
+                    )
+                }
+            }
+            is CallAction.ToggleMute -> {
+                updateCurrentCall { copy(isMuted = action.isMute) }
+            }
+            // Handle other actions...
+            else -> {
+                /* No-op for unsupported actions */
+            }
+        }
+    }
+
+}