@capgo/capacitor-stream-call 0.0.27 → 0.0.29

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 {
@@ -792,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.27",
+  "version": "0.0.29",
   "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)
-        )
-    }
-}