In-Session Communication

This page covers all APIs for communicating inside an EnableX Android video session: text chat (including edit and delete), custom data signalling, file sharing, screen sharing, canvas streaming, annotation, and live transcription.

EnableX supports public (broadcast), private (one-to-one), and group chat messaging. Messaging does not require the sender to have a published stream or the receiver to have a subscribed stream.

Send a Chat Message

EnxRoom.sendMessage() sends a text message to one or more participants in the session.

• Class: EnxRoom
• Method: public void sendMessage(String message, boolean isBroadcast, List<String> recipientIDs)

// Public broadcast — send to all
room.sendMessage("Hello everyone!", true, null);

// Private or group — send to specific recipients
List<String> recipientClientIds = new ArrayList<>();
recipientClientIds.add("clientId1");
room.sendMessage("Hello!", false, recipientClientIds);

// Sender receives acknowledgment
@Override
public void onACKSendMessage(JSONObject jsonObject) {
    // Contains message details including messageId
}

// Recipients receive the message
@Override
public void onMessageReceived(JSONObject jsonObject) {
    String textMessage = jsonObject.getString("msg");
}

Edit a Chat Message

EnxRoom.transactMessage() edits a previously sent chat message. The messageId is received via onACKSendMessage or onMessageReceived when the original message was sent.

• Class: EnxRoom
• Method: public void transactMessage(JSONObject option)

JSONObject option = new JSONObject();
option.put("message", "This is my edited message");
option.put("messageId", "3889493030");
option.put("type", "chat-update");

room.transactMessage(option);

// Sender receives acknowledgment
@Override
public void onACKUpdateMessage(JSONObject data) {
    // Acknowledgment of the edit request
}

// Recipients receive the updated message
@Override
public void onMessageUpdate(JSONObject data) {
    // data contains the updated message
}

Delete a Chat Message

EnxRoom.transactMessage() also handles message deletion. Use "chat-delete" as the type and provide the messageId of the message to remove.

• Class: EnxRoom
• Method: public void transactMessage(JSONObject option)

JSONObject option = new JSONObject();
option.put("messageId", "3889493030");
option.put("type", "chat-delete");

room.transactMessage(option);

// Sender receives acknowledgment
@Override
public void onACKDeleteMessage(JSONObject data) {
    // Acknowledgment that the deletion was processed
}

// Recipients are notified of the deletion
@Override
public void onMessageDelete(JSONObject data) {
    // data contains deleted message information
}

EnxRoom.sendUserData() sends a structured JSON payload to one or more participants without any EnableX message structure constraints. Use this to exchange application-specific instructions, polls, or any custom data during a session.

• Class: EnxRoom
• Method: public void sendUserData(JSONObject data, boolean isBroadcast, List<String> recipientIDs)

// Build your custom payload
JSONObject data = new JSONObject();
data.put("sender", "Alice");
data.put("message", "Custom instruction");
data.put("custom_key", "value");

// Broadcast to all participants
room.sendUserData(data, true, null);

// Send to specific recipients
List<String> recipientClientIds = new ArrayList<>();
recipientClientIds.add("clientId1");
room.sendUserData(data, false, recipientClientIds);

// Recipients receive the signal
@Override
public void onUserDataReceived(JSONObject jsonObject) {
    // Handle the custom JSON payload
}

File sharing allows participants to upload and download files within an RTC session. Available from Android SDK v1.5.3 and later. You must call setFileShareObserver(this) before using any file sharing API.

Upload a File

EnxRoom.sendFiles() initiates a file transfer to the EnableX server. A UI is presented to the user to select the file to upload.

• Class: EnxRoom
• Observer: public void setFileShareObserver(EnxFileShareObserver object)
• Method: public void sendFiles(FrameLayout view, boolean isBroadcast, List<String> clientIdList)

room.setFileShareObserver(this);

// Broadcast the file to all participants
room.sendFiles(frameLayoutView, true, null);

// Callbacks at sender
@Override
public void onInitFileUpload(JSONObject jsonObject) {
    // File upload has started
}

@Override
public void onFileUploaded(JSONObject jsonObject) {
    // File uploaded successfully
}

@Override
public void onFileUploadFailed(JSONObject jsonObject) {
    // File upload failed — handle error
}

// Callbacks at receivers
@Override
public void onFileUploadStarted(JSONObject jsonObject) {
    // A file is being uploaded by another participant
}

@Override
public void onFileAvailable(JSONObject jsonObject) {
    // A file is now available for download
}

Get Available Files

EnxRoom.getAvailableFiles() returns all files currently available for download in the session. Call this after joining the room to retrieve any files shared before you connected.

• Class: EnxRoom
• Method: public JSONArray getAvailableFiles()

JSONArray myFiles = room.getAvailableFiles();
// Returns an array of file info objects, e.g.:
// [ { "name": "report.pdf", "size": 191002, "index": 0 } ]

Download a Shared File

EnxRoom.downloadFile() downloads a file identified by its file info object (received via onFileAvailable or getAvailableFiles()).

• Class: EnxRoom
• Method: public void downloadFile(JSONObject fileInfo, boolean isAutoSave)

room.downloadFile(fileInfoJsonObject, true);

@Override
public void onFileDownloaded(JSONObject jsonObject) {
    // File downloaded — jsonObject contains path or Base64 data
}

@Override
public void onFileDownloadFailed(JSONObject jsonObject) {
    // Download failed — handle error
}

Cancel a File Upload

Use cancelUpload() to cancel a specific ongoing upload, or cancelAllUploads() to cancel all uploads you initiated.

• Class: EnxRoom

// Cancel a specific upload job
enxRoom.cancelUpload(jobId);

// Cancel all ongoing uploads
enxRoom.cancelAllUploads();

// Acknowledgment callback
@Override
public void onFileUploadCancelled(JSONObject jsonObject) {
    // Upload has been cancelled
}

Cancel a File Download

Use cancelDownload() to cancel a specific ongoing download, or cancelAllDownloads() to cancel all downloads at your endpoint.

• Class: EnxRoom

// Cancel a specific download job
enxRoom.cancelDownload(jobId);

// Cancel all ongoing downloads
enxRoom.cancelAllDownloads();

// Acknowledgment callback
@Override
public void onFileDownloadCancelled(JSONObject jsonObject) {
    // Download has been cancelled
}

Screen sharing publishes the device screen as a video stream (Stream ID 101) at 6 fps. To receive shared screens, subscribe to Stream ID 101. Screen sharing must be enabled when creating the room: { "screen_share": true }.

You must call room.setScreenShareObserver(this) before calling any screen sharing method.

Start Screen Sharing

EnxRoom.startScreenShare() creates and publishes a screen share stream into the room.

• Class: EnxRoom
• Observer: public void setScreenShareObserver(EnxScreenShareObserver object)
• Method: public void startScreenShare()

// Register the observer before starting
room.setScreenShareObserver(this);

// Start screen sharing
room.startScreenShare();

// Received by everyone — screen share stream available (Stream ID 101)
@Override
public void onScreenSharedStarted(EnxStream enxStream) {
    // enxStream is the screen share stream (ID 101)
    // Attach to a player view and add to your layout
    yourView.addView(enxStream.mEnxPlayerView);
}

Stop Screen Sharing

EnxRoom.stopScreenShare() stops the active screen sharing session initiated by the local user.

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

room.stopScreenShare();

@Override
public void onScreenSharedStopped(EnxStream enxStream) {
    // Remove the screen share view from layout
    yourView.removeAllViews();
}

Force Stop Sharing (Moderator Only)

EnxRoom.stopAllSharing() allows a moderator to force stop any ongoing screen sharing or canvas streaming by any participant in the room. This method is restricted to moderators and is not available to regular participants.

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

// Moderator force-stops all screen sharing and canvas streaming
EnxRoom.stopAllSharing();

@Override
public void onStopAllSharingACK(JSONObject jsonObject) {
    // All sharing has been stopped — update your UI accordingly
}

Canvas streaming publishes any Android View as a video stream (Stream ID 102) into the room. Canvas streaming must be enabled when creating the room: { "canvas": true }. To receive a canvas stream, subscribe to Stream ID 102.

Start Canvas Streaming

EnxRoom.startCanvas() starts publishing the specified view as a canvas stream into the room.

• Class: EnxRoom
• Method: public void startCanvas(View view)
• Parameter: view — the Android View to publish as the canvas stream.

room.startCanvas(yourView);

// Publisher receives acknowledgment
@Override
public void onStartCanvasAck(JSONObject jsonObject) {
    // Canvas streaming started successfully
}

// Received by all participants — canvas stream available (Stream ID 102)
@Override
public void onCanvasStarted(EnxStream enxStream) {
    // enxStream is the canvas stream (ID 102)
    // Attach to a player view and display
    EnxPlayerView canvasPlayerView = new EnxPlayerView(
        CurrentClassContext, ScalingType, mediaOverlay);
    enxStream.attachRenderer(canvasPlayerView);
    yourView.addView(canvasPlayerView);
}

Stop Canvas Streaming

EnxRoom.stopCanvas() stops the active canvas streaming session.

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

room.stopCanvas();

// Publisher receives acknowledgment
@Override
public void onStoppedCanvasAck(JSONObject jsonObject) {
    // Canvas streaming stopped
}

// Received by all participants
@Override
public void onCanvasStopped(EnxStream enxStream) {
    // Remove the canvas view from layout
    yourView.removeAllViews();
}

Annotation allows users to draw on a remote stream. To enable annotation, canvas streaming must be enabled when creating the room: { "canvas": true }. Available from Android SDK v2.1.2 and later.

You must add the annotation toolbar to your layout XML and set the setAnnotationObserver after connecting to the room.

Add Annotation Toolbar to Layout

<enx_rtc_android.annotations.EnxAnnotationsToolbar
    android:id="@+id/annotations_bar"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"/>

Start Annotation

EnxRoom.startAnnotation() begins annotation on a given stream object.

• Class: EnxRoom
• Observer: public void setAnnotationObserver(AnnotationsObserverInstance)
• Method: public void startAnnotation(EnxStream enxStream)
• Parameter: enxStream — the stream object to annotate.

// Set the annotation observer after connecting to the room
room.setAnnotationObserver(annotationsObserverInstance);

// Start annotation on a stream
room.startAnnotation(enxStream);

// Annotator receives acknowledgment
@Override
public void onStartAnnotationAck(JSONObject jsonObject) {
    // Annotation started — update UI
}

// Notification to all participants
@Override
public void onAnnotationStarted(EnxStream enxStream) {
    // Add the annotation view to your layout
    ((ViewGroup) mAnnotationViewContainer).addView(enxStream.EnxPlayerView);
}

Stop Annotation

EnxRoom.stopAnnotation() stops the current annotation.

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

room.stopAnnotation();

// Annotator receives acknowledgment
@Override
public void onStoppedAnnotationAck(JSONObject jsonObject) {
    // Annotation stopped — update UI
}

// Notification to all participants
@Override
public void onAnnotationStopped(EnxStream enxStream) {
    // Remove the annotation view from your layout
    ((ViewGroup) mAnnotationViewContainer).removeView(enxStream.EnxPlayerView);
}

Live transcription converts the speech of all Active Talkers in a session to text in near real time. All endpoints that request transcription subscribe to the same transcription feed. The process starts when the first user requests it and stops when the last subscriber opts out — unless auto_transcribe is enabled at the room level, in which case it runs for the full session.

Start Live Transcription

Two methods are available to start live transcription:

• startLiveTranscription(language) — starts transcription for the calling endpoint (self-transcription).
• startLiveTranscriptionForRoom(language) — starts or joins room-level transcription, promoting it from self-transcription if it was already running.

When the method is called for the first time in a session, it starts the transcription process and subscribes the endpoint. Subsequent calls from other endpoints only subscribe them to the existing feed.

• Class: EnxRoom
• Methods:
  • public void startLiveTranscription(String language)
  • public void startLiveTranscriptionForRoom(String language)
• Parameter: language — language code string (e.g. "english_us"). Default is "english_us". See the Language Codes reference for all supported values.

Transcription Event Payload

The onTranscriptionEvents callback delivers a JSONObject with the following fields:

// Start self-transcription
enxRoom.startLiveTranscription("english_us");

// Or start room-level transcription
enxRoom.startLiveTranscriptionForRoom("english_us");

// Acknowledgment of start request
@Override
public void onACKStartLiveTranscription(JSONObject jsonObject) {
    // Start request acknowledged
}

// Self-transcription is now active
@Override
public void onSelfTranscriptionOn(JSONObject jsonObject) {
    // This endpoint is now receiving transcription
}

// Room-level transcription is active
@Override
public void onRoomTranscriptionOn(JSONObject jsonObject) {
    // All subscribed endpoints are receiving transcription
}

// Receive transcription events
@Override
public void onTranscriptionEvents(JSONObject jsonObject) {
    String type     = jsonObject.getString("type");     // "speech_recognising" or "speech_recognised"
    String text     = jsonObject.getString("text");     // Transcribed text
    String clientId = jsonObject.getString("clientId"); // Speaker's client ID
    // Display or process the transcribed text
}

Stop Live Transcription

EnxRoom.stopLiveTranscription() unsubscribes the calling endpoint from the live transcription feed. When the last subscribed endpoint calls this method, the transcription process stops in the room — unless auto_transcribe is enabled at the room level, in which case it continues until the session ends.

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

enxRoom.stopLiveTranscription();

// Acknowledgment of stop request
@Override
public void onACKStopLiveTranscription(JSONObject jsonObject) {
    // Stop request acknowledged
}

// This endpoint is no longer receiving transcription
@Override
public void onSelfTranscriptionOff(JSONObject jsonObject) {
    // Hide transcription UI
}

// Room-level transcription has been stopped
@Override
public void onRoomTranscriptionOff(JSONObject jsonObject) {
    // Transcription has ended for all participants
}