> ## Documentation Index
> Fetch the complete documentation index at: https://www.cometchat.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Presenter Mode

> CometChat Calling SDK v4 - Stable Release - Presenter Mode for Android

## Overview

The Presenter Mode feature allows developers to create a calling service experience in which:

1. There are one or more users who are presenting their video, audio and/or screen (Maximum 5)
2. Viewers who are consumers of that presentation. (They cannot send their audio, video or screen streams out).
3. The total number of presenters and viewers can go up to 100.
4. Features such as mute/unmute audio, show/hide camera capture, recording, etc. will be enabled only for the Presenter in this mode.
5. Other call participants will not get these features. Hence they act like passive viewers in the call.

Using this feature developers can create experiences such as:

1. All hands calls
2. Keynote speeches
3. Webinars
4. Talk shows
5. Online classes and many more...

About this guide

This guide demonstrates how to start a presentation into an Android application. Before you begin, we strongly recommend you read the [calling setup guide](/calls/v4/android/setup).

Before starting a call session you have to generate a call token. You need to call this method for the call token.

## Start Presentation Session

The most important class that will be used in the implementation is the `PresentationSettings` class. This class allows you to set the various parameters for the Presentation Mode. In order to set the various parameters of the `PresentationSettings` class, you need to use the `PresentationSettingsBuilder` class. Below are the various options available with the `PresentationSettings` class.

`PresentationSettingsBuilder` class takes the 1 mandatory parameter as a part of the constructor:

1. Context of the application.

You will also need to set the User Type, There are 2 type of users in Presenter Mode, `Presenter` & `Participant` , You can set this `PresentationSettingsBuilder `by using the following method` isPresenter(true/false)`

A basic example of how to start a Presentation:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
        RelativeLayout videoContainer;
        Context activityContext = this; //Your activity reference
        String callToken = ""; //Received on generate token onSuccess

        PresentationSettings presenterSettings = new CometChatCalls.PresentationSettingsBuilder(activityContext)
            .setDefaultLayoutEnable(true)
            .setIsPresenter(false)
            .setEventListener(new CometChatCallsEventsListener() {
                @Override
                public void onCallEnded() {
                }

                @Override
                public void onCallEndButtonPressed() {
                }

                @Override
                public void onUserJoined(RTCUser user) {
                }

                @Override
                public void onUserLeft(RTCUser user) {
                }

                @Override
                public void onUserListChanged(ArrayList<RTCUser> users) {
                }

                @Override
                public void onAudioModeChanged(ArrayList<AudioMode> devices) {
                }

                @Override
                public void onCallSwitchedToVideo(CallSwitchRequestInfo callSwitchRequestInfo) {
                }

                @Override
                public void onUserMuted(RTCMutedUser muteObj) {
                }

                @Override
                public void onRecordingToggled(RTCRecordingInfo recordingInfo) {
                }

                @Override
                public void onError(com.cometchat.pro.rtc.exceptions.CometChatException ce) {
                }
            })
            .build();

        CometChatCalls.joinPresentation(callToken, presenterSettings, videoContainer, new CometChatCalls.CallbackListener<String>() {
            @Override
            public void onSuccess(String s) {
                Log.e(TAG, "startSession onSuccess");
            }

            @Override
            public void onError(com.cometchat.pro.rtc.exceptions.CometChatException e) {
                Log.e(TAG, "CallSDKLog >>>: startSession onError: " + e);
            }
        });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
      val videoContainer: RelativeLayout
      val activityContext = this //Your activity reference
      val callToken = "" //Received on generate token onSuccess

      val presenterSettings = CometChatCalls.PresentationSettingsBuilder(activityContext)
          .setDefaultLayoutEnable(true)
          .setIsPresenter(false)
          .setEventListener(object : CometChatCallsEventsListener {
              override fun onCallEnded() {
              }

              override fun onCallEndButtonPressed() {
              }

              override fun onUserJoined(user: RTCUser) {
              }

              override fun onUserLeft(user: RTCUser) {
              }

              override fun onUserListChanged(users: ArrayList<RTCUser>) {
              }

              override fun onAudioModeChanged(devices: ArrayList<AudioMode>) {
              }

              override fun onCallSwitchedToVideo(callSwitchRequestInfo: CallSwitchRequestInfo) {
              }

              override fun onUserMuted(muteObj: RTCMutedUser) {
              }

              override fun onRecordingToggled(recordingInfo: RTCRecordingInfo) {
              }

              override fun onError(ce: com.cometchat.pro.rtc.exceptions.CometChatException) {
              }
          })
          .build()


      CometChatCalls.joinPresentation(callToken, presenterSettings, videoContainer, object : CometChatCalls.CallbackListener<String>() {
          override fun onSuccess(s: String) {
              Log.e(TAG, "startSession onSuccess")
          }

          override fun onError(e: com.cometchat.pro.rtc.exceptions.CometChatException) {
              Log.e(TAG, "CallSDKLog >>>: startSession onError: $e")
          }
      })
    ```
  </Tab>
</Tabs>

| Parameter         | Description                                                                                 |
| ----------------- | ------------------------------------------------------------------------------------------- |
| `activityContext` | The activity in which you want to show the calling view.                                    |
| `videoContainer`  | An object of the `RelativeLayout` class in which CometChatCalls can load the calling views. |

The `CometChatCallsEventsListener` listener provides you with the below callback methods:

| Callback Method                                                       | Description                                                                                                                 |
| --------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `onCallEnded()`                                                       | This method is called when the call is successfully ended. The call details can be obtained from the Call object provided.  |
| `onCallEndButtonPressed()`                                            | This method is called when the user presses the end call button.                                                            |
| `onUserJoined(user: RTCUser)`                                         | This method is called when any other user joins the call. The user details can be obtained from the User object provided.   |
| `onUserLeft(user: RTCUser)`                                           | This method is called when a user leaves the call. The details of the user can be obtained from the provided User object.   |
| `onUserListChanged(users: ArrayList<RTCUser?>)`                       | This method is triggered every time a participant joins or leaves the call, providing the list of users active in the call. |
| `onAudioModeChanged(devices: ArrayList<AudioMode?>)`                  | This callback is triggered if any new audio output source is available or becomes unavailable.                              |
| `onCallSwitchedToVideo(callSwitchRequestInfo: CallSwitchRequestInfo)` | This callback is triggered when an audio call is converted into a video call.                                               |
| `onUserMuted(muteObj: RTCMutedUser)`                                  | This method is triggered when a user is muted in the ongoing call.                                                          |
| `onRecordingToggled(recordingInfo: RTCRecordingInfo)`                 | This method is triggered when a recording starts/stops.                                                                     |
| `onError(e: CometChatException)`                                      | This method is called when there is some error in establishing the call.                                                    |

## Settings

The `PresentationSettings` class is the most important class when it comes to the implementation of the Calling feature. This is the class that allows you to customize the overall calling experience. The properties for the call/conference can be set using the `PresentationSettingsBuilder` class. This will eventually give you and object of the `PresentationSettings` class which you can pass to the joinPresentation() method to start the call.

The **mandatory** parameters that are required to be present for any call/conference to work are:

Context - context of the activity/application RelativeLayout - A RelativeLayout object in which the calling UI is loaded. The options available for customization of calls are:

| Setting                                                | Description                                                                                                                                                                                                                                                                                                                       |
| ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `setIsPresenter(boolean value)`                        | If set to `true`, the user will join the call as a presenter. If set to `false`, the user will join the call as an audience member. Default value = `false`                                                                                                                                                                       |
| `setDefaultLayoutEnable(boolean value)`                | If set to `true` enables the default layout for handling the call operations. If set to `false`, it hides the button layout and just displays the Call View. Default value = `true`                                                                                                                                               |
| `setIsAudioOnly(boolean value)`                        | If set to `true`, the call is supposed to be an audio call. If set to `false`, the call is supposed to be a video call. Default value = `false`                                                                                                                                                                                   |
| `showEndCallButton(boolean value)`                     | If set to `true`, it displays the End Call Button in the Button Layout. If set to `false`, it hides the End Call Button in the Button Layout. Default value = `true`                                                                                                                                                              |
| `showSwitchCameraButton(boolean value)`                | If set to `true`, it displays the Switch Camera Button in the Button Layout. If set to `false`, it hides the Switch Camera Button in the Button Layout. Default value = `true`                                                                                                                                                    |
| `showMuteAudioButton(boolean value)`                   | If set to `true`, it displays the Mute Audio Button in the Button Layout. If set to `false`, it hides the Mute Audio Button in the Button Layout. Default value = `true`                                                                                                                                                          |
| `showPauseVideoButton(boolean value)`                  | If set to `true`, it displays the Pause Video Button in the Button Layout. If set to `false`, it hides the Pause Video Button in the Button Layout. Default value = `true`                                                                                                                                                        |
| `showAudioModeButton(boolean value)`                   | If set to `true`, it displays the Audio Mode Button in the Button Layout. If set to `false`, it hides the Audio Mode Button in the Button Layout. Default value = `true`                                                                                                                                                          |
| `startWithAudioMuted(boolean value)`                   | This ensures the call is started with the audio muted if set to `true`. Default value = `false`                                                                                                                                                                                                                                   |
| `startWithVideoMuted(boolean value)`                   | This ensures the call is started with the video muted if set to `true`. Default value = `false`                                                                                                                                                                                                                                   |
| `setDefaultAudioMode(boolean value)`                   | This method can be used if you wish to start the call with a specific audio mode. The available options are `CometChatCallsConstants.AUDIO_MODE_SPEAKER`, `CometChatCallsConstants.AUDIO_MODE_EARPIECE`, `CometChatCallsConstants.AUDIO_MODE_BLUETOOTH`, `CometChatCallsConstants.AUDIO_MODE_HEADPHONES`. Default value = `false` |
| `showRecordingButton(boolean value)`                   | If set to `true`, it displays the Recording Button. If set to `false`, it hides the Recording Button. Default value = `false`                                                                                                                                                                                                     |
| `setEventListener(new CometChatCallsEventsListener())` | The `CometChatCallsEventsListener` listener provides you callbacks.                                                                                                                                                                                                                                                               |

In case you wish to achieve a completely customised UI for the Calling experience, you can do so by embedding default android buttons to the screen as per your requirement and then use the below methods to achieve different functionalities for the embedded buttons.

For the use case where you wish to align your own custom buttons and not use the default layout provided by CometChat you can embed the buttons in your layout and use the below methods to perform the corresponding operations: