@stream-io/react-native-callingx 0.1.0-beta.2 → 0.1.0-beta.3

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

@@ -1,245 +0,0 @@
-package io.getstream.rn.callingx.notifications
-
-import android.app.Notification
-import android.content.Context
-import android.media.Ringtone
-import android.media.RingtoneManager
-import android.net.Uri
-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
-
-    private var lastPostedSnapshot: NotificationSnapshot? = null
-
-    /**
-     * Snapshot of call state used to detect notification changes.
-     * Using a data class ensures immutable comparison and avoids issues
-     * with mutable Call.Registered objects.
-     */
-    private data class NotificationSnapshot(
-        val id: String,
-        val isActive: Boolean,
-        val isIncoming: Boolean,
-        val displayTitle: String?,
-        val displaySubtitle: String?,
-        val displayName: CharSequence,
-        val address: Uri
-    )
-
-    private fun Call.Registered.toSnapshot() = NotificationSnapshot(
-        id = id,
-        isActive = isActive,
-        isIncoming = isIncoming(),
-        displayTitle = displayOptions?.getString(CallService.EXTRA_DISPLAY_TITLE),
-        displaySubtitle = displayOptions?.getString(CallService.EXTRA_DISPLAY_SUBTITLE),
-        displayName = callAttributes.displayName,
-        address = callAttributes.address
-    )
-
-    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)
-                lastPostedSnapshot = null
-                hasBecameActive = false
-            }
-            is Call.Registered -> {
-                val newSnapshot = call.toSnapshot()
-                if (newSnapshot == lastPostedSnapshot) {
-                    debugLog(TAG, "[notifications] updateCallNotification: Skipping - no state change")
-                    return
-                }
-
-                lastPostedSnapshot = newSnapshot
-                val notification = createNotification(call)
-                notificationManager.notify(NOTIFICATION_ID, notification)
-                debugLog(TAG, "[notifications] updateCallNotification: Notification posted successfully")
-            }
-        }
-    }
-
-    fun cancelNotifications() {
-        notificationManager.cancel(NOTIFICATION_ID)
-        hasBecameActive = false
-        lastPostedSnapshot = null
-    }
-
-    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/bin/src/main/java/io/getstream/rn/callingx/repo/CallRepository.kt

@@ -1,163 +0,0 @@
-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, incoming: Boolean)
-    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/bin/src/main/java/io/getstream/rn/callingx/repo/LegacyCallRepository.kt

@@ -1,139 +0,0 @@
-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"
-    }
-
-    private var observeCallStateJob: Job? = null
-
-    override fun getTag(): String = TAG
-
-    override fun setListener(listener: Listener?) {
-        this._listener = listener
-        // Observe call state changes
-        observeCallStateJob?.cancel()
-        observeCallStateJob = 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
-
-        observeCallStateJob?.cancel()
-        observeCallStateJob = null
-        _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, isIncoming)
-
-            // 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 */
-            }
-        }
-    }
-
-}