Session Management

The Android SDK provides moderator-only methods for managing video sessions — recording, hard muting, room locking, participant control, RTMP and HLS streaming, pinning, spotlight, and room mode switching.

Auto Recording

Configure the room with settings.auto_recording: true during room creation to start recording automatically as soon as the session begins. The moderator can stop the recording at any time by calling stopRecord().

Start Recording

EnxRoom.startRecord() starts recording the session. This method is available to the moderator only. Register a recording observer before calling it.

• Class: EnxRoom
• Method: public void startRecord()
• Observer: room.setRecordingObserver(this)
• Moderator only: Yes

room?.setEnxRecordingObserver(myRecordingObserver)

room?.startRecord()

override fun onStartRecordingEvent(jsonObject: JSONObject?) {
    // ACK to the user who started recording
}

override fun onRoomRecordingOn(jsonObject: JSONObject?) {
    // Broadcast to ALL participants — recording has started
}

room.setRecordingObserver(this);
room.startRecord();

@Override
public void onStartRecordingEvent(JSONObject jsonObject) {
    // You started recording
}

@Override
public void onRoomRecordingOn(JSONObject jsonObject) {
    // Recording has started — notified to all
}

Stop Recording

EnxRoom.stopRecord() stops an active recording. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void stopRecord()
• Observer: room.setRecordingObserver(this)
• Moderator only: Yes

room?.stopRecord()

override fun onStopRecordingEvent(jsonObject: JSONObject?) {
    // ACK to the user who stopped recording
}

override fun onRoomRecordingOff(jsonObject: JSONObject?) {
    // Broadcast to ALL — recording stopped
}

room.stopRecord();

@Override
public void onStopRecordingEvent(JSONObject jsonObject) {
    // You stopped recording
}

@Override
public void onRoomRecordingOff(JSONObject jsonObject) {
    // Recording has stopped — notified to all
}

Live Recording creates a transcoded composite file in real time using a custom layout view (the Virtual Agent). Unlike standard recording which transcodes after the session ends, you receive the composite file within minutes of the session concluding. See Virtual Agent for guidance on building a custom streaming view.

Auto Live Recording

Configure the room to start live recording automatically by including the following settings at room creation. The moderator can stop it at any time by calling stopLiveRecording().

{
  "settings": {
    "live_recording": {
      "auto_recording": true,
      "url": "https://your-custom-view-url/?token="
    }
  }
}

Start Live Recording

EnxRoom.startLiveRecording(JSONObject jsonObject) starts live recording using a custom composite view. This method is available to the moderator only. Register a live recording observer before calling it.

• Class: EnxRoom
• Method: public void startLiveRecording(JSONObject jsonObject)
• Observer: enxRoom.setLiveRecordingObserver(this)
• Moderator only: Yes
• Parameter: jsonObject — streaming configuration object:
  • urlDetails.url — Custom view URL (required). EnableX appends a participant token to this URL at runtime.
  • urlDetails.layOut — (Optional) Layout identifier for the custom view.
  • urlDetails.chatOverlay — (Optional) Boolean; overlays chat onto the recording view.

enxRoom.setLiveRecordingObserver(this);

JSONObject jsonObject = new JSONObject();
JSONObject urlDetails = new JSONObject();
urlDetails.put("url", "https://your-domain/streaming-view/?token=");
jsonObject.put("urlDetails", urlDetails);

enxRoom.startLiveRecording(jsonObject);

@Override
public void onACKStartLiveRecording(JSONObject jsonObject) {
    // Moderator: live recording has started
}

@Override
public void onRoomLiveRecordingOn(JSONObject jsonObject) {
    // All participants: live recording started
}

@Override
public void onRoomLiveRecordingUpdate(JSONObject jsonObject) {
    // All participants: live recording progress update
}

@Override
public void onRoomLiveRecordingFailed(JSONObject jsonObject) {
    // All participants: live recording failed
}

Stop Live Recording

Two method signatures are available depending on your SDK version:

• SDK v2.1.2: EnxRoom.stopLiveRecording(JSONObject jsonObject) — pass the same config used to start.
• SDK v2.1.3+: EnxRoom.stopLiveRecording() — no parameters required.

enxRoom.stopLiveRecording();  // v2.1.3+

@Override
public void onACKStopLiveRecording(JSONObject jsonObject) {
    // Moderator: live recording stopped
}

@Override
public void onRoomLiveRecordingOff(JSONObject jsonObject) {
    // All participants: live recording stopped
}

Live Recording Queue Error Codes

The following codes are delivered asynchronously to indicate the status of queued live recording and streaming requests.

Hard Mute a Room

EnxRoom.hardMute() mutes all participants in the room. Users who join after the room is hard-muted are also automatically muted. Only the moderator can unmute the room. Register the mute room observer before calling this method.

• Class: EnxRoom
• Method: public void hardMute()
• Observer: room.setMuteRoomObserver(this)
• Moderator only: Yes

room?.hardMuteRoom()

override fun onHardMuteRoom(jsonObject: JSONObject?) {
    // Received by ALL — room is hard-muted
}

room.setMuteRoomObserver(this);
room.hardMute();

@Override
public void onMutedRoom(JSONObject jsonObject) {
    // You hard-muted the room
}

@Override
public void onReceivedMuteRoom(JSONObject jsonObject) {
    // Room is hard-muted — notified to all
}

Hard Unmute a Room

EnxRoom.hardUnMute() removes the hard mute from the room, restoring audio control to individual participants. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void hardUnMute()
• Moderator only: Yes

room?.hardUnMuteRoom()

override fun onHardUnMuteRoom(jsonObject: JSONObject?) { }

room.hardUnMute();

@Override
public void onUnMutedRoom(JSONObject jsonObject) {
    // You hard-unmuted the room
}

@Override
public void onReceivedUnMuteRoom(JSONObject jsonObject) {
    // Room is hard-unmuted — notified to all
}

Hard Mute a Participant

Use these EnxRoom methods to force-mute a specific participant's audio or video. The affected participant receives a callback, and all other participants are also notified.

• Method (audio): public void hardMuteUserAudio(String clientId)
• Method (video): public void hardMuteUserVideo(String clientId)
• Moderator only: Yes

room?.hardMuteUser(clientId)

override fun onHardMuteUser(jsonObject: JSONObject?) { }

room.hardMuteUserAudio(clientId);
room.hardMuteUserVideo(clientId);

@Override
public void onHardMutedAudio(JSONObject jsonObject) {
    // Your audio is hard-muted
}

@Override
public void onReceivedHardMuteAudio(JSONObject jsonObject) {
    // A participant's audio is hard-muted — notified to all
}

Hard Unmute a Participant

Use these EnxRoom methods (v2.1.3+) to restore audio or video for a specific participant who was previously hard-muted.

• Method (audio): public void hardUnMuteUserAudio(String clientId)
• Method (video): public void hardUnMuteUserVideo(String clientId)
• Moderator only: Yes

room?.hardUnMuteUser(clientId)

override fun onHardUnMuteUser(jsonObject: JSONObject?) { }

room.hardUnMuteUserAudio(clientId);

@Override
public void onHardUnMutedAudio(JSONObject jsonObject) {
    // Your audio is hard-unmuted
}

@Override
public void onReceivedHardUnMuteAudio(JSONObject jsonObject) {
    // A participant's audio is hard-unmuted — notified to all
}

Lock a Room

EnxRoom.lockRoom() prevents any new participants from joining the session. Participants already connected remain unaffected. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void lockRoom()
• Moderator only: Yes

room?.lockRoom()

room.lockRoom();

@Override
public void onAckLockRoom(JSONObject jsonObject) {
    // Room has been locked
}

@Override
public void onLockedRoom(JSONObject jsonObject) {
    // Room locked — notified to all
}

Unlock a Room

EnxRoom.unLockRoom() re-opens the room to new participants. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void unLockRoom()
• Moderator only: Yes

room?.unlockRoom()

room.unLockRoom();

@Override
public void onAckUnLockRoom(JSONObject jsonObject) {
    // Room has been unlocked
}

@Override
public void onUnLockedRoom(JSONObject jsonObject) {
    // Room unlocked — notified to all
}

Knock — Moderate Participant Entry

In a knock-enabled room, participants are held in a waiting state after connecting and must receive explicit moderator approval before being admitted to the session. If the moderator joins late, use room.awaitedParticipants to retrieve the list of users currently waiting for approval.

Approve a User's Entry

EnxRoom.approveAwaitedUser(String clientId) admits a waiting participant into the session.

• Method: public void approveAwaitedUser(String clientId)
• Parameter: clientId — the client ID of the waiting participant.

room?.approveAwaitedUser(clientId)

override fun onUserAwaited(jsonObject: JSONObject?) {
    val clientId = jsonObject?.optString("clientId")
    room?.approveAwaitedUser(clientId!!)
}

override fun onRoomAwaited(enxRoom: EnxRoom?, jsonObject: JSONObject?) {
    // Participant: room is locked, waiting for moderator approval
}

override fun onAckForApproveAwaitedUser(jsonObject: JSONObject?) { }

@Override
public void onUserAwaited(JSONObject jsonObject) {
    // jsonObject: {"id": "String", "name": "String"}
    enxRoom.approveAwaitedUser(jsonObject.getString("id"));
}

@Override
public void onAckForApproveAwaitedUser(JSONObject jsonObject) {
    // User has been allowed entry
}

Decline a User's Entry

EnxRoom.denyAwaitedUser(String clientId) rejects a waiting participant and disconnects them from the waiting state.

• Method: public void denyAwaitedUser(String clientId)
• Parameter: clientId — the client ID of the waiting participant.

room?.denyAwaitedUser(clientId)

override fun onAckForDenyAwaitedUser(jsonObject: JSONObject?) { }

@Override
public void onUserAwaited(JSONObject jsonObject) {
    enxRoom.denyAwaitedUser(jsonObject.getString("id"));
}

@Override
public void onAckForDenyAwaitedUser(JSONObject jsonObject) {
    // User has been denied entry
}

Disconnect a User

EnxRoom.dropUser(List<String> clientIds) force-disconnects one or more participants from the session. The affected users receive a disconnection notification with the reason. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void dropUser(List<String> clientIds)
• Parameter: clientIds — list of client IDs to disconnect.
• Moderator only: Yes

room?.dropUser(JSONArray().put(clientId))

override fun onAckDropUser(jsonObject: JSONObject?) { }

List<String> clientIds = new ArrayList<>();
clientIds.add("clientId1");
room.dropUser(clientIds);

@Override
public void onAckDropUser(JSONObject jsonObject) {
    // User has been dropped
}

Extend Session Duration

Each room has a defined maximum duration. Ten minutes before expiry, all participants receive an onConferenceRemainingDuration notification indicating that an extension window has opened. Any participant can trigger an extension; once triggered the first window closes. If the session has not been extended, a second window opens five minutes before expiry.

• Class: EnxRoom
• Method: public void extendConferenceDuration()

val extOpts = JSONObject().apply { put("duration", 30) }
room?.extendConferenceDuration(extOpts)

override fun onConferenceRemainingDuration(jsonObject: JSONObject?) {
    val seconds = jsonObject?.optInt("remainingDuration")
}
override fun onConferencessExtended(jsonObject: JSONObject?) { }

room.extendConferenceDuration();

@Override
public void onConferenceRemainingDuration(JSONObject jsonObject) {
    // Extension window opened — N minutes remaining
}

@Override
public void onConferencessExtended(JSONObject jsonObject) {
    // Session has been extended
}

Destroy a Session

EnxRoom.destroy() immediately ends the session for all connected participants. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void destroy()
• Moderator only: Yes

room?.destroy()

override fun onAckDestroy(jsonObject: JSONObject?) { }

room.destroy();

@Override
public void onAckDestroy(JSONObject jsonObject) {
    // Session destroyed
}

Switch Participant Role

The moderator can promote any participant to the moderator role. When the role switch is confirmed, the promoted participant gains moderation capabilities and the original moderator becomes a regular participant. All participants are notified of the change.

• Class: EnxRoom
• Method: public void switchUserRole(String clientId)
• Parameter: clientId — the client ID of the participant to promote.
• Moderator only: Yes

room?.setEnxSwitchRoleObserver(mySwitchRoleObserver)

val opts = JSONObject().apply {
    put("clientId", targetClientId)
    put("role", "moderator")
}
room?.switchUserRole(opts)

override fun onAckUserRoleChangeRequest(jsonObject: JSONObject?) { }
override fun onUserRoleChangeRequest(jsonObject: JSONObject?) { }
override fun onUserRoleChangeAccepted(jsonObject: JSONObject?) { }
override fun onUserRoleChangeDenied(jsonObject: JSONObject?) { }
override fun onUserRoleChanged(jsonObject: JSONObject?) {
    val newRole = jsonObject?.optString("role")
}

room.switchUserRole(clientId);

@Override
public void onSwitchedUserRole(JSONObject jsonObject) {
    // Role switch acknowledged
}

@Override
public void onUserRoleChanged(JSONObject jsonObject) {
    // New moderator notified:
    // { "moderator": true, "clientId": "XXX", "raisedHands": [], "approvedHands": [] }
    // All other participants notified:
    // { "moderator": false, "clientId": "XXX" }
}

RTMP streaming lets the moderator forward the video session as a single live stream to any CDN or platform that accepts an RTMP ingest — YouTube, Facebook, Vimeo, Twitch, and others. See RTMP Live Streaming for the full overview including CDN configuration and layout options.

Start Streaming

EnxRoom.startStreaming(JSONObject streamingDetails) begins forwarding the session to an RTMP endpoint. This method is available to the moderator only.

• Class: EnxRoom
• Method: public void startStreaming(JSONObject streamingDetails)
• Moderator only: Yes

The streamingDetails object accepts the following fields:

JSONObject streamingDetails = new JSONObject();

JSONObject rtmpDetails = new JSONObject();
rtmpDetails.put("rtmpUrl", "RTMP_URL/STREAMING_KEY");
streamingDetails.put("rtmpDetails", rtmpDetails);

// Optional: custom streaming view
JSONObject urlDetails = new JSONObject();
urlDetails.put("url", "https://your-domain/streaming-view/?token=");
streamingDetails.put("urlDetails", urlDetails);

room.startStreaming(streamingDetails);

@Override
public void onAckStartStreaming(JSONObject jsonObject) {
    // Streaming started — you are live
}

@Override
public void onStreamingStarted(JSONObject jsonObject) {
    // All participants notified: streaming has started
}

@Override
public void onStreamingFailed(JSONObject jsonObject) {
    // All participants notified: streaming failed
}

@Override
public void onStreamingUpdated(JSONObject jsonObject) {
    // All participants: streaming process update
}

Stop Streaming

EnxRoom.stopStreaming(JSONObject streamingDetails) stops the active RTMP stream. Pass the same configuration object used to start streaming.

• Class: EnxRoom
• Method: public void stopStreaming(JSONObject streamingDetails)
• Moderator only: Yes

room.stopStreaming(streamingDetails);

@Override
public void onAckStopStreaming(JSONObject jsonObject) {
    // Streaming has stopped
}

@Override
public void onStreamingStopped(JSONObject jsonObject) {
    // All participants notified: streaming stopped
}

HLS Streaming lets you broadcast the session to a large audience in real time. Unlike RTMP which pushes to an external CDN, HLS is managed entirely by EnableX. The HLS stream starts automatically when the first audience member joins and stops when the last audience member disconnects. See HLS Streaming for the full overview including room configuration and audience token generation.

Registering the HLS Observer

Before receiving HLS callbacks, register the HLS observer on the room object:

enxRoom.setEnxHlsObserver(this);

HLS Callbacks

enxRoom.setEnxHlsObserver(this);

@Override
public void onHlsStarted(JSONObject jsonObject) {
    // jsonObject contains "hls_url" — pass to HLS player
    String hlsUrl = jsonObject.getString("hls_url");
}

@Override
public void onHlsStopped(JSONObject jsonObject) {
    // HLS stream stopped
}

@Override
public void onHlsWaiting(JSONObject jsonObject) {
    // HLS stream is being initialized — show a waiting UI
}

@Override
public void onHlsFailed(JSONObject jsonObject) {
    // HLS stream failed
}

Playing the HLS Stream with ExoPlayer

Use ExoPlayer (or any HLS-compatible player) to play the hls_url received via onHlsStarted. Add the ExoPlayer PlayerView to your layout XML:

<!-- In your layout XML -->
<com.google.android.exoplayer2.ui.PlayerView
    android:id="@+id/exoplayer"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:minHeight="100dp"
    app:resize_mode="fixed_width" />

Then initialize and start the player in your Activity or Fragment:

PlayerView ePlayer = findViewById(R.id.exoplayer);

String hlsUrl = "HLS_URL_FROM_onHlsStarted";

DefaultHttpDataSource.Factory dataSourceFactory = new DefaultHttpDataSource.Factory();
HlsMediaSource hlsMediaSource = new HlsMediaSource.Factory(dataSourceFactory)
    .createMediaSource(MediaItem.fromUri(hlsUrl));

ExoPlayer player = new ExoPlayer.Builder(context).build();
player.setMediaSource(hlsMediaSource);
player.prepare();
ePlayer.setPlayer(player);
player.play();

HLS Error Codes

On HLS Start

On HLS Stop

On HLS Waiting

Generic

Pin a User

The moderator can pin one or more participants to keep their streams in the Active Talker list regardless of audio activity. Pinned streams are always published. The maximum number of simultaneously pinned users is max_active_talkers - 1.

• Class: EnxRoom
• Method: public void pinUsers(List<String> clientIds)
• Parameter: clientIds — list of client IDs to pin.
• Moderator only: Yes

val pinList = JSONArray().put(clientId)
room?.pinUsers(pinList)

override fun onAckPinUsers(jsonObject: JSONObject?) { }
override fun onPinnedUsers(jsonObject: JSONObject?) { }

List<String> clientIds = new ArrayList<>();
clientIds.add("clientId1");
enxRoom.pinUsers(clientIds);

@Override
public void onAckPinUsers(JSONObject jsonObject) {
    // Users pinned
}

@Override
public void onPinnedUsers(JSONObject jsonObject) {
    // All notified with updated pinned list
}

Unpin a User

EnxRoom.unpinUsers(List<String> clientIds) removes the pin from one or more participants. All participants are notified via onPinnedUsers with the updated pinned list.

• Method: public void unpinUsers(List<String> clientIds)
• Moderator only: Yes

room?.unpinUsers(pinList)

override fun onAckUnpinUsers(jsonObject: JSONObject?) { }

enxRoom.unpinUsers(clientIds);

@Override
public void onAckUnpinUsers(JSONObject jsonObject) {
    // Users unpinned
}

Spotlight a User

Spotlighting pushes a participant's stream to the top of the Active Talker list. Multiple users can be spotlighted simultaneously, up to the room's max_active_talkers limit. Spotlighted participants appear in the active talker list with "spotlight": true.

• Class: EnxRoom
• Method: public void addSpotlightUsers(List clientIds)
• Parameter: clientIds — list of client IDs to spotlight.
• Moderator only: Yes

room?.addSpotlightUsers(pinList)

override fun onAckAddSpotlightUsers(jsonObject: JSONObject?) { }
override fun onUpdateSpotlightUsers(jsonObject: JSONObject?) { }

List clientIds = new ArrayList();
clientIds.add("clientId1");
enxRoom.addSpotlightUsers(clientIds);

@Override
public void onAckAddSpotlightUsers(JSONObject jsonObject) {
    // Spotlight applied — { "result": 0, clients: [] }
}

@Override
public void onUpdateSpotlightUsers(JSONObject jsonObject) {
    // All notified with updated spotlight list
}

Remove Spotlight

EnxRoom.removeSpotlightUsers(List clientIds) removes the spotlight from one or more participants. All participants are notified via onUpdateSpotlightUsers.

• Method: public void removeSpotlightUsers(List clientIds)
• Moderator only: Yes

room?.removeSpotlightUsers(pinList)

override fun onAckRemoveSpotlightUsers(jsonObject: JSONObject?) { }

enxRoom.removeSpotlightUsers(clientIds);

@Override
public void onAckRemoveSpotlightUsers(JSONObject jsonObject) {
    // Spotlight removed
}

Switch Room Mode

A room defined with group or lecture mode can be switched to the other mode at runtime by the moderator. The behaviour differs by direction:

• Group to Lecture: All participant streams are dropped. Lecture-mode features (floor control, hand raise) become active. Any active breakout rooms are terminated.
• Lecture to Group: All participants receive notification to re-publish their streams. The SDK does not auto-publish for privacy — each participant must call publish explicitly.

• Observer: EnxSwitchRoomObserver
• Method: public void switchRoomMode(String roomMode)
• Parameter: roomMode — "group" or "lecture"
• Moderator only: Yes

enxRoom.setEnxSwitchRoomObserver(this);
enxRoom.switchRoomMode("lecture");

@Override
public void onAckSwitchedRoom(JSONObject jsonObject) {
    // Moderator acknowledged
    // { "result": 1715, "moderator": "String", "msg": "...", "mode": "lecture" }
}

@Override
public void onRoomModeSwitched(JSONObject jsonObject) {
    // All participants notified of mode change
}