@capgo/capacitor-stream-call 0.0.26 → 0.0.28

package/ios/Sources/StreamCallPlugin/StreamCallPlugin.swift

@@ -24,7 +24,9 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "setCameraEnabled", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "acceptCall", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "isCameraEnabled", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getCallStatus", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "getCallStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setSpeaker", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "switchCamera", returnType: CAPPluginReturnPromise)
     ]
 
     private enum State {
@@ -34,8 +36,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     }
     private var apiKey: String?
     private var state: State = .notInitialized
-    private static let tokenRefreshQueue = DispatchQueue(label: "stream.call.token.refresh")
-    private static let tokenRefreshSemaphore = DispatchSemaphore(value: 1)
     private var currentToken: String?
     private var tokenWaitSemaphore: DispatchSemaphore?
 
@@ -56,9 +56,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     @Injected(\.callKitPushNotificationAdapter) var callKitPushNotificationAdapter
     private var webviewDelegate: WebviewNavigationDelegate?
 
-    // Add class property to store call states
-    private var callStates: [String: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)] = [:]
-
     // Declare as optional and initialize in load() method
     private var callViewModel: CallViewModel?
 
@@ -246,17 +243,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                             // Reset notification flag when call ends
                             self.hasNotifiedCallJoined = false
                             
-                            // Clean up any resources for this call
-                            if let callCid = endingCallId {
-                                // Invalidate and remove the timer
-                                self.callStates[callCid]?.timer?.invalidate()
-                                
-                                // Remove call from callStates
-                                self.callStates.removeValue(forKey: callCid)
-                                
-                                print("Cleaned up resources for ended call: \(callCid)")
-                            }
-                            
                             // Remove the call overlay view when not in a call
                             self.ensureViewRemoved()
                         }
@@ -295,134 +281,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
-    @objc private func checkCallTimeoutTimer(_ timer: Timer) {
-        guard let callCid = timer.userInfo as? String else { return }
-
-        Task { [weak self] in
-            guard let self = self else { return }
-            await self.checkCallTimeout(callCid: callCid)
-        }
-    }
-
-    private func checkCallTimeout(callCid: String) async {
-        // Get a local copy of the call state from the main thread
-        let callState: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)? = await MainActor.run {
-            return self.callStates[callCid]
-        }
-
-        guard let callState = callState else { return }
-
-        // Calculate time elapsed since call creation
-        let now = Date()
-        let elapsedSeconds = now.timeIntervalSince(callState.createdAt)
-
-        // Check if 30 seconds have passed
-        if elapsedSeconds >= 30.0 {
-
-            // Check if anyone has accepted
-            let hasAccepted = callState.participantResponses.values.contains { $0 == "accepted" }
-
-            if !hasAccepted {
-                print("Call \(callCid) has timed out after \(elapsedSeconds) seconds")
-                print("No one accepted call \(callCid), marking all non-responders as missed")
-
-                // Mark all members who haven't responded as "missed"
-                for member in callState.members {
-                    let memberId = member.userId
-                    let needsToBeMarkedAsMissed = await MainActor.run {
-                        return self.callStates[callCid]?.participantResponses[memberId] == nil
-                    }
-
-                    if needsToBeMarkedAsMissed {
-                        // Update callStates map on main thread
-                        await MainActor.run {
-                            var updatedCallState = self.callStates[callCid]
-                            updatedCallState?.participantResponses[memberId] = "missed"
-                            if let updatedCallState = updatedCallState {
-                                self.callStates[callCid] = updatedCallState
-                            }
-                        }
-
-                        // Notify listeners
-                        await MainActor.run {
-                            self.updateCallStatusAndNotify(callId: callCid, state: "missed", userId: memberId)
-                        }
-                    }
-                }
-
-                // End the call
-                if let call = streamVideo?.state.activeCall, call.cId == callCid {
-                    call.leave()
-                }
-
-                // Clean up timer on main thread
-                await MainActor.run {
-                    self.callStates[callCid]?.timer?.invalidate()
-                    var updatedCallState = self.callStates[callCid]
-                    updatedCallState?.timer = nil
-                    if let updatedCallState = updatedCallState {
-                        self.callStates[callCid] = updatedCallState
-                    }
-
-                    // Remove from callStates
-                    self.callStates.removeValue(forKey: callCid)
-                }
-
-                // Update UI
-                await MainActor.run {
-                    // self.overlayViewModel?.updateCall(nil)
-                    self.overlayView?.isHidden = true
-                    self.webView?.isOpaque = true
-                    self.updateCallStatusAndNotify(callId: callCid, state: "ended", reason: "timeout")
-                }
-            }
-        }
-    }
-
-    private func checkAllParticipantsResponded(callCid: String) async {
-        // Get a local copy of the call state from the main thread
-        let callState: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)? = await MainActor.run {
-            return self.callStates[callCid]
-        }
-
-        guard let callState = callState else {
-            print("Call state not found for cId: \(callCid)")
-            return
-        }
-
-        let totalParticipants = callState.members.count
-        let responseCount = callState.participantResponses.count
-
-        print("Total participants: \(totalParticipants), Responses: \(responseCount)")
-
-        let allResponded = responseCount >= totalParticipants
-        let allRejectedOrMissed = allResponded &&
-            callState.participantResponses.values.allSatisfy { $0 == "rejected" || $0 == "missed" }
-
-        if allResponded && allRejectedOrMissed {
-            print("All participants have rejected or missed the call")
-
-            // End the  call
-            if let call = streamVideo?.state.activeCall, call.cId == callCid {
-                call.leave()
-            }
-
-            // Clean up timer and remove from callStates on main thread
-            await MainActor.run {
-                // Clean up timer
-                self.callStates[callCid]?.timer?.invalidate()
-
-                // Remove from callStates
-                self.callStates.removeValue(forKey: callCid)
-
-                // self.overlayViewModel?.updateCall(nil)
-                self.overlayView?.isHidden = true
-                self.webView?.isOpaque = true
-                self.updateCallStatusAndNotify(callId: callCid, state: "ended", reason: "all_rejected_or_missed")
-            }
-        }
-    }
-
     @objc func login(_ call: CAPPluginCall) {
         guard let token = call.getString("token"),
               let userId = call.getString("userId"),
@@ -551,23 +409,19 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     print("- Should Ring: \(shouldRing)")
                     print("- Team: \(team)")
 
-                    // Create the call object
-                    let streamCall = streamVideo?.call(callType: callType, callId: callId)
-
-                    // Start the call with the members
-                    print("Creating call with members...")
-                    try await streamCall?.create(
-                        memberIds: members,
-                        custom: [:],
-                        team: team, ring: shouldRing
-                    )
 
-                    // Join the call
-                    print("Joining call...")
-                    try await streamCall?.join(create: false)
-                    print("Successfully joined call")
 
                     // Update the CallOverlayView with the active call
+                    // Create the call object
+                    await self.callViewModel?.startCall(
+                        callType: callType,
+                        callId: callId,
+                        members: members.map { Member(userId: $0, role: nil, customData: [:], updatedAt: nil) },
+                        ring: shouldRing
+                    )
+                    
+                    
+                    // Update UI on main thread
                     await MainActor.run {
                         // self.overlayViewModel?.updateCall(streamCall)
                         self.overlayView?.isHidden = false
@@ -576,7 +430,8 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                     call.resolve([
                         "success": true
-                    ])
+                    ])  
+
                 } catch {
                     log.error("Error making call: \(String(describing: error))")
                     call.reject("Failed to make call: \(error.localizedDescription)")
@@ -939,4 +794,66 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             "state": currentCallState
         ])
     }
+
+    @objc func setSpeaker(_ call: CAPPluginCall) {
+        guard let name = call.getString("name") else {
+            call.reject("Missing required parameter: name")
+            return
+        }
+
+        do {
+            try requireInitialized()
+
+            Task {
+                do {
+                    if let activeCall = streamVideo?.state.activeCall {
+                        if name == "speaker" {
+                            try await activeCall.speaker.enableSpeakerPhone()
+                        } else {
+                            try await activeCall.speaker.disableSpeakerPhone()
+                        }
+                    }
+                    call.resolve([
+                        "success": true
+                    ])
+                } catch {
+                    log.error("Error setting speaker: \(String(describing: error))")
+                    call.reject("Failed to set speaker: \(error.localizedDescription)")
+                }
+            }
+        } catch {
+            call.reject("StreamVideo not initialized")
+        }
+    }
+
+    @objc func switchCamera(_ call: CAPPluginCall) {
+        guard let camera = call.getString("camera") else {
+            call.reject("Missing required parameter: camera")
+            return
+        }
+
+        do {
+            try requireInitialized()
+
+            Task {
+                do {
+                    if let activeCall = streamVideo?.state.activeCall {
+                        if (camera == "front" && activeCall.camera.direction != .front) ||
+                           (camera == "back" && activeCall.camera.direction != .back) {
+                            try await activeCall.camera.flip()
+                        }
+                    }
+                    call.resolve([
+                        "success": true
+                    ])
+                } catch {
+                    log.error("Error switching camera: \(String(describing: error))")
+                    call.reject("Failed to switch camera: \(error.localizedDescription)")
+                }
+            }
+        } catch {
+            call.reject("StreamVideo not initialized")
+        }
+    }
+            
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-stream-call",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Uses the https://getstream.io/ SDK to implement calling in Capacitor",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",

package/android/src/main/java/ee/forgr/capacitor/streamcall/CallOverlayView.kt

@@ -1,217 +0,0 @@
-package ee.forgr.capacitor.streamcall
-
-import android.content.Context
-import android.widget.Toast
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.safeDrawing
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.layout.onSizeChanged
-import androidx.compose.ui.platform.LocalConfiguration
-import androidx.compose.ui.platform.LocalInspectionMode
-import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.IntSize
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import io.getstream.video.android.compose.permission.LaunchCallPermissions
-import io.getstream.video.android.compose.theme.VideoTheme
-import io.getstream.video.android.compose.ui.components.call.renderer.FloatingParticipantVideo
-import io.getstream.video.android.compose.ui.components.call.renderer.ParticipantVideo
-import io.getstream.video.android.compose.ui.components.call.renderer.ParticipantsLayout
-import io.getstream.video.android.compose.ui.components.call.renderer.RegularVideoRendererStyle
-import io.getstream.video.android.compose.ui.components.call.renderer.VideoRendererStyle
-import io.getstream.video.android.core.ParticipantState
-import io.getstream.video.android.core.RealtimeConnection
-import io.getstream.video.android.core.StreamVideo
-import io.getstream.video.android.core.Call
-import io.getstream.video.android.compose.ui.components.video.VideoScalingType
-import androidx.compose.ui.graphics.Color
-
-@Composable
-fun CallOverlayView(
-    context: Context,
-    streamVideo: StreamVideo?,
-    call: Call?
-) {
-    if (streamVideo == null) {
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .background(Color.Red)
-        )
-        return
-    }
-
-    // Collect the active call state
-    //val activeCall by internalInstance.state.activeCall.collectAsState()
-    // val call = activeCall
-    if (call == null) {
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .background(Color.LightGray)
-        )
-        return
-    }
-
-    // Handle permissions in the Composable context
-    LaunchCallPermissions(
-        call = call,
-        onAllPermissionsGranted = {
-            try {
-                // Check session using reflection before joining
-                val callClass = call.javaClass
-                val sessionField = callClass.getDeclaredField("session")
-                sessionField.isAccessible = true
-                val sessionValue = sessionField.get(call)
-                
-                if (sessionValue != null) {
-                    android.util.Log.d("CallOverlayView", "Session already exists, skipping join")
-                } else {
-                    android.util.Log.d("CallOverlayView", "No existing session, attempting to join call")
-                    val result = call.join(create = true)
-                    result.onError {
-                        android.util.Log.d("CallOverlayView", "Error joining call")
-                        Toast.makeText(context, it.message, Toast.LENGTH_LONG).show()
-                    }
-                }
-            } catch (e: Exception) {
-                android.util.Log.e("CallOverlayView", "Error checking session or joining call", e)
-                Toast.makeText(context, "Failed to join call: ${e.message}", Toast.LENGTH_LONG).show()
-            }
-        }
-    )
-
-    // Apply VideoTheme
-    VideoTheme {
-        // Define required properties.
-        val allParticipants by call.state.participants.collectAsState()
-        val remoteParticipants = allParticipants.filter { !it.isLocal }
-        val remoteParticipantsCount by call.state.participantCounts.collectAsState()
-        val connection by call.state.connection.collectAsState()
-        val sessionId by call.state.session.collectAsState()
-        var parentSize: IntSize by remember { mutableStateOf(IntSize(0, 0)) }
-
-        // Add logging for debugging
-        LaunchedEffect(allParticipants, remoteParticipants, remoteParticipantsCount, connection, sessionId) {
-            android.util.Log.d("CallOverlayView", "Detailed State Update:")
-            android.util.Log.d("CallOverlayView", "- Call ID: ${call.id}")
-            android.util.Log.d("CallOverlayView", "- Session ID: ${sessionId?.id}")
-            android.util.Log.d("CallOverlayView", "- All Participants: $allParticipants")
-            android.util.Log.d("CallOverlayView", "- Remote Participants: $remoteParticipants")
-            android.util.Log.d("CallOverlayView", "- Remote Participant Count: $remoteParticipantsCount")
-            android.util.Log.d("CallOverlayView", "- Connection State: $connection")
-            
-            // Log each participant's details
-            allParticipants.forEach { participant ->
-                android.util.Log.d("CallOverlayView", "Participant Details:")
-                android.util.Log.d("CallOverlayView", "- ID: ${participant.userId}")
-                android.util.Log.d("CallOverlayView", "- Is Local: ${participant.isLocal}")
-                android.util.Log.d("CallOverlayView", "- Has Video: ${participant.videoEnabled}")
-                android.util.Log.d("CallOverlayView", "- Has Audio: ${participant.audioEnabled}")
-            }
-        }
-
-        Box(
-            contentAlignment = Alignment.Center,
-            modifier = Modifier
-                .fillMaxSize()
-                .background(VideoTheme.colors.baseSenary)
-                .padding(WindowInsets.safeDrawing.asPaddingValues())
-                .onSizeChanged { parentSize = it }
-        ) {
-            val videoRenderer: @Composable (
-                modifier: Modifier,
-                call: Call,
-                participant: ParticipantState,
-                style: VideoRendererStyle,
-            ) -> Unit = { videoModifier, videoCall, videoParticipant, videoStyle ->
-                ParticipantVideo(
-                    modifier = videoModifier,
-                    call = videoCall,
-                    participant = videoParticipant,
-                    style = videoStyle,
-                    scalingType = VideoScalingType.SCALE_ASPECT_FIT,
-                    actionsContent = { _, _, _ -> }
-                )
-            }
-            val videoRendererNoAction: @Composable (ParticipantState) -> Unit =
-                { participant ->
-                    ParticipantVideo(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .clip(VideoTheme.shapes.dialog),
-                        call = call,
-                        participant = participant,
-                        style = RegularVideoRendererStyle(),
-                        scalingType = VideoScalingType.SCALE_ASPECT_FIT,
-                        actionsContent = { _, _, _ -> }
-                    )
-                }
-            val floatingVideoRender: @Composable BoxScope.(
-                call: Call,
-                parentSize: IntSize
-            ) -> Unit = { call, _ ->
-                val participants by call.state.participants.collectAsState()
-                val me = participants.firstOrNull { it.isLocal }
-                me?.let { localParticipant ->
-                    val configuration = LocalConfiguration.current
-                    val layoutDirection = LocalLayoutDirection.current
-                    val density = LocalDensity.current
-                    val safeDrawingPadding = WindowInsets.safeDrawing.asPaddingValues()
-                    val adjustedSize = with(density) {
-                        IntSize(
-                            width = (configuration.screenWidthDp.dp.toPx() - safeDrawingPadding.calculateLeftPadding(layoutDirection).toPx() - safeDrawingPadding.calculateRightPadding(layoutDirection).toPx()).toInt(),
-                            height = (configuration.screenHeightDp.dp.toPx() - safeDrawingPadding.calculateTopPadding().toPx() - safeDrawingPadding.calculateBottomPadding().toPx()).toInt()
-                        )
-                    }
-                    FloatingParticipantVideo(
-                        call = call,
-                        videoRenderer = videoRendererNoAction,
-                        participant = if (LocalInspectionMode.current) {
-                            participants.first()
-                        } else {
-                            localParticipant
-                        },
-                        style = RegularVideoRendererStyle(),
-                        parentBounds = adjustedSize,
-                    )
-                }
-            }
-
-            if (remoteParticipants.isNotEmpty()) {
-                android.util.Log.d("CallOverlayView", "Showing ParticipantsLayout with ${remoteParticipants.size} remote participants")
-                ParticipantsLayout(
-                    modifier = Modifier
-                        .fillMaxSize(),
-                    call = call,
-                    videoRenderer = videoRenderer,
-                    floatingVideoRenderer = floatingVideoRender
-                )
-            } else {
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .background(VideoTheme.colors.baseSenary)
-                )
-            }
-        }
-    }
-}

package/android/src/main/java/ee/forgr/capacitor/streamcall/IncomingCallView.kt

@@ -1,163 +0,0 @@
-package ee.forgr.capacitor.streamcall
-
-import android.util.Log
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.calculateEndPadding
-import androidx.compose.foundation.layout.calculateStartPadding
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.navigationBars
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.safeDrawing
-import androidx.compose.foundation.layout.statusBars
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalLayoutDirection
-import io.getstream.video.android.compose.theme.VideoTheme
-import io.getstream.video.android.compose.ui.components.background.CallBackground
-import io.getstream.video.android.compose.ui.components.call.ringing.incomingcall.IncomingCallControls
-import io.getstream.video.android.compose.ui.components.call.ringing.incomingcall.IncomingCallDetails
-import io.getstream.video.android.core.Call
-import io.getstream.video.android.core.MemberState
-import io.getstream.video.android.core.RingingState
-import io.getstream.video.android.core.StreamVideo
-import io.getstream.video.android.core.call.state.AcceptCall
-import io.getstream.video.android.core.call.state.DeclineCall
-import io.getstream.video.android.core.call.state.ToggleCamera
-import io.getstream.video.android.model.User
-
-@Composable
-fun IncomingCallView(
-    streamVideo: StreamVideo?,
-    call: Call? = null,
-    onDeclineCall: ((Call) -> Unit)? = null,
-    onAcceptCall: ((Call) -> Unit)? = null,
-    onHideIncomingCall: (() -> Unit)? = null
-) {
-    val ringingState = call?.state?.ringingState?.collectAsState(initial = RingingState.Idle)
-
-    LaunchedEffect(ringingState?.value) {
-        Log.d("IncomingCallView", "Changing ringingState to ${ringingState?.value}")
-        when (ringingState?.value) {
-            RingingState.TimeoutNoAnswer, RingingState.RejectedByAll -> {
-                Log.d("IncomingCallView", "Call ended (${ringingState.value}), hiding incoming call view")
-                onHideIncomingCall?.invoke()
-            }
-            RingingState.Active -> {
-                Log.d("IncomingCallView", "Call accepted, hiding incoming call view")
-                onHideIncomingCall?.invoke()
-            }
-            else -> {
-                // Keep the view visible for other states
-            }
-        }
-    }
-
-    if (ringingState != null) {
-        Log.d("IncomingCallView", "Ringing state changed to: ${ringingState.value}")
-    }
-
-    val backgroundColor = when {
-        streamVideo == null -> Color.Cyan
-        call == null -> Color.Red
-        else -> Color.Green
-    }
-
-    if (call !== null) {
-//        val participants by call.state.participants.collectAsState()
-//        val members by call.state.members.collectAsState()
-//        call.state.session
-        val session by call.state.session.collectAsState()
-        val isCameraEnabled by call.camera.isEnabled.collectAsState()
-        val isVideoType = true
-
-        val statusBarPadding = WindowInsets.statusBars.asPaddingValues()
-        val navigationBarPadding = WindowInsets.navigationBars.asPaddingValues()
-        val safeDrawingPadding = WindowInsets.safeDrawing.asPaddingValues()
-        val layoutDirection = LocalLayoutDirection.current
-
-        // println("participants: ${participants.map { it.name.value }} Members: ${members}")
-
-        VideoTheme {
-            CallBackground(
-                modifier = Modifier.fillMaxSize(),
-            ) {
-                Column(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .padding(
-                            top = statusBarPadding.calculateTopPadding(),
-                            bottom = navigationBarPadding.calculateBottomPadding()
-                        ),
-                    horizontalAlignment = Alignment.CenterHorizontally,
-                    verticalArrangement = Arrangement.SpaceBetween
-                ) {
-                    IncomingCallDetails(
-                        modifier = Modifier
-                            .padding(
-                                top = VideoTheme.dimens.spacingXl,
-                                start = safeDrawingPadding.calculateStartPadding(layoutDirection),
-                                end = safeDrawingPadding.calculateEndPadding(layoutDirection)
-                            ),
-                        isVideoType = isVideoType,
-                        participants = (session?.participants?.map { MemberState(
-                            user = User(
-                                id = it.user.id,
-                                name = it.user.id,
-                                image = it.user.image
-                            ),
-                            custom = mapOf(),
-                            role = it.role,
-                            createdAt = org.threeten.bp.OffsetDateTime.now(),
-                            updatedAt = org.threeten.bp.OffsetDateTime.now(),
-                            deletedAt = org.threeten.bp.OffsetDateTime.now(),
-                            acceptedAt = org.threeten.bp.OffsetDateTime.now(),
-                            rejectedAt = org.threeten.bp.OffsetDateTime.now()
-                        ) }?.filter { it.user.id != streamVideo?.userId }) ?: listOf()
-                    )
-
-                    IncomingCallControls(
-                        modifier = Modifier
-                            .padding(
-                                bottom = VideoTheme.dimens.spacingL,
-                                start = safeDrawingPadding.calculateStartPadding(layoutDirection),
-                                end = safeDrawingPadding.calculateEndPadding(layoutDirection)
-                            ),
-                        isVideoCall = isVideoType,
-                        isCameraEnabled = isCameraEnabled,
-                        onCallAction = { action ->
-                            when (action) {
-                                DeclineCall -> {
-                                    onDeclineCall?.invoke(call)
-                                }
-                                AcceptCall -> {
-                                    call.camera.setEnabled(isCameraEnabled)
-                                    onAcceptCall?.invoke(call)
-                                }
-                                is ToggleCamera -> {
-                                    call.camera.setEnabled(action.isEnabled)
-                                }
-                                else -> { /* ignore other actions */ }
-                            }
-                        }
-                    )
-                }
-            }
-        }
-    } else {
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .background(backgroundColor)
-        )
-    }
-}