# Call Lobby

The call lobby displays a local video preview before joining a call. It allows you to control the camera, microphone, and permissions before joining. The call lobby consists of these components:

- **onRenderedContent**: A video renderer, which renders a local video track before joining a call.
- **onDisabledContent**: Content is shown that a local camera is disabled. It displays user avatar by default.
- **lobbyControlsContent**: Content is shown that allows users to trigger different actions to control a preview call.
- **onCallAction**: Handler when the user triggers a Call Control Action.

Here's how to implement a basic call lobby:

```kotlin
val isCameraEnabled by call.camera.isEnabled.collectAsState()
val isMicrophoneEnabled by call.microphone.isEnabled.collectAsState()

CallLobby(
    call = call,
    modifier = Modifier.fillMaxWidth(),
    isCameraEnabled = isCameraEnabled,
    isMicrophoneEnabled = isMicrophoneEnabled,
)
```

After running your project, you'll see the result below:

![Call Lobby](https://getstream.io/docs-assets/images/a2397be452d3.png)

### Control Actions

Similar to `CallContent`, and `CallLobby` supports these main action handlers with the `onCallAction` lambda:

```kotlin
CallLobby(
    call = call,
    modifier = Modifier.fillMaxWidth(),
    isCameraEnabled = isCameraEnabled,
    isMicrophoneEnabled = isMicrophoneEnabled,
    onCallAction = { action ->
        when (action) {
            is ToggleCamera -> call.camera.setEnabled(action.isEnabled)
            is ToggleMicrophone -> call.microphone.setEnabled(action.isEnabled)
            else -> Unit
        }
    }
)
```

You can customize the control actions by implementing your own composable for the `lobbyControlsContent` like the code below:

```kotlin
CallLobby(
    call = call,
    modifier = Modifier.fillMaxWidth(),
    isCameraEnabled = isCameraEnabled,
    isMicrophoneEnabled = isMicrophoneEnabled,
    lobbyControlsContent = {
        ControlActions(
            call = call,
            actions = listOf(
                {
                    ToggleCameraAction(
                        isCameraEnabled = isCameraEnabled,
                        onCallAction = { }
                    )
                },
                {
                    ToggleMicrophoneAction(
                        isMicrophoneEnabled = isMicrophoneEnabled,
                        onCallAction = { }
                    )
                }
            )
        )
    },
  ..
)
```

Then you'll see the result below:

![Call Lobby for control actions](https://getstream.io/docs-assets/images/6c050cc9356b.png)

### Permission Requests

The call lobby needs to get permission to access the camera and microphone. `CallLobby` implements the permission request by default, so you don't need to do anything to request permission from your side. If you implement the `CallLobby` composable, it will ask you to grant camera and microphone permission like the image below:

![Call Lobby with permission](https://getstream.io/docs-assets/images/6f0c7f0368d9.png)

You can also customize what permission you want to ask by passing a list of permission to the `permission` parameter like the example below:

```kotlin
CallLobby(
    permissions: VideoPermissionsState = rememberCallPermissionsState(
        call = call,
        permissions = listOf(
            android.Manifest.permission.CAMERA,
            android.Manifest.permission.RECORD_AUDIO,
            ..
      ),
    ),
    ..
)
```

If you don't want to let `CallLobby` request permissions and want to handle them manually from your side, you can just pass an empty list like the code below:

```kotlin
CallLobby(
    permissions: VideoPermissionsState = rememberCallPermissionsState(
            call = call,
            permissions = listOf()
    ),
    ..
)
```

### Preview For Disabled Camera

The `CallLobby` component displays a user avatar when the camera lacks permission or is disabled.

![Call Lobby Camera Disabled](https://getstream.io/docs-assets/images/c4292cbdac77.png)

You can customize the preview component by implementing your own composable to the `onDisabledContent` composable parameter:

```kotlin
CallLobby(
    call = call,
    modifier = Modifier.fillMaxWidth(),
    onDisabledContent = {
        Box(modifier = Modifier.fillMaxSize()) {
            Text(
                modifier = Modifier.align(Alignment.Center),
                text = "Camera is disabled",
                color = VideoTheme.colors.textHighEmphasis
            )
        }
    },
  ..
)
```

After building the project, you'll see the result below:

![Call Lobby Camera Disabled](https://getstream.io/docs-assets/images/c3d7e0462883.png)

### Customization

The `CallLobby` component has more options when it comes to customization. It exposes the following parameters that let you change its UI:

```kotlin
@Composable
public fun CallLobby(
    modifier: Modifier = Modifier,
    call: Call,
    user: User = StreamVideo.instance().user,
    labelPosition: Alignment = Alignment.BottomStart,
    isCameraEnabled: Boolean,
    isMicrophoneEnabled: Boolean,
    video: ParticipantState.Video,
    permissions: VideoPermissionsState,
    onRenderedContent: @Composable (video: ParticipantState.Video) -> Unit,
    onDisabledContent: @Composable () -> Unit,
    onCallAction: (CallAction) -> Unit,
    lobbyControlsContent: @Composable (call: Call) -> Unit
)
```

- `modifier`: The standard Jetpack Compose modifier used to style things like the component size, background, shape and similar.
- `call` The call includes states and will be rendered with participants.
- `user` A user to display their name and avatar image on the preview.
- `labelPosition` The position of the user audio state label.
- `video` A participant video to render on the preview renderer.
- `permissions` Android permissions that should be required to render a video call properly.
- `onRenderedContent` A video renderer, which renders a local video track before joining a call.
- `onDisabledContent` Content is shown that a local camera is disabled. It displays user avatar by default.
- `onCallAction` Handler when the user triggers a Call Control Action.
- `lobbyControlsContent` Content is shown that allows users to trigger different actions to control a preview call.


---

This page was last updated at 2026-08-10T16:01:01.628Z.

For the most recent version of this documentation, visit [https://getstream.io/video/docs/android/ui-cookbook/call-lobby/](https://getstream.io/video/docs/android/ui-cookbook/call-lobby/).