In-Session Communication

room?.sendMessage("Hello everyone!", "public", JSONArray())

val targets = JSONArray().put(targetClientId)
room?.sendMessage("Private note", "private", targets)

override fun onACKSendMessage(jsonObject: JSONObject?) {
    // Your message was sent successfully
}

override fun onMessageReceived(jsonObject: JSONObject?) {
    val message = jsonObject?.optString("message")
    val from = jsonObject?.optString("from")
    val type = jsonObject?.optString("type") // public | private
}

// 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");
}

val option = JSONObject().apply {
    put("message", "This is my edited message")
    put("messageId", "3889493030")
    put("type", "chat-update")
}

room?.transactMessage(option)

override fun onACKUpdateMessage(data: JSONObject?) {
    // Acknowledgment of the edit request
}

override fun onMessageUpdate(data: JSONObject?) {
    // data contains the updated message
}

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
}

val option = JSONObject().apply {
    put("messageId", "3889493030")
    put("type", "chat-delete")
}

room?.transactMessage(option)

override fun onACKDeleteMessage(data: JSONObject?) {
    // Acknowledgment that the deletion was processed
}

override fun onMessageDelete(data: JSONObject?) {
    // data contains deleted message information
}

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
}

val userData = JSONObject().apply { put("handRaised", true) }
room?.sendUserData(userData, "public", JSONArray())

override fun onUserDataReceived(jsonObject: JSONObject?) { }

room?.userStartTyping()
override fun onUserStartTyping(jsonObject: JSONObject?) { }

// 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
}

room?.setEnxFileShareObserver(myFileShareObserver)

val fileOpts = JSONObject().apply {
    put("name", "document.pdf")
    put("type", "public")
}
room?.sendFiles(fileOpts)

room?.cancelFiles(uploadToken)

override fun onInitFileUpload(jsonObject: JSONObject?) { }
override fun onFileUploadStarted(jsonObject: JSONObject?) { }
override fun onFileUploaded(jsonObject: JSONObject?) { }
override fun onFileAvailable(jsonObject: JSONObject?) {
    val fileInfo = jsonObject?.optJSONObject("fileInfo")
    room?.receiveFiles(fileInfo!!)
}
override fun onFileDownloaded(jsonObject: JSONObject?) { }
override fun onFileUploadCancelled(jsonObject: JSONObject?) { }
override fun onFileDownloadCancelled(jsonObject: JSONObject?) { }
override fun onFileUploadFailed(jsonObject: JSONObject?) { }
override fun onFileDownloadFailed(jsonObject: JSONObject?) { }

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
}

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

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

room?.downloadFile(fileInfoJsonObject, true)

override fun onFileDownloaded(jsonObject: JSONObject?) {
    // File downloaded — jsonObject contains path or Base64 data
}

override fun onFileDownloadFailed(jsonObject: JSONObject?) {
    // Download failed — handle error
}

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 specific upload job
enxRoom?.cancelUpload(jobId)

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

// Acknowledgment callback
override fun onFileUploadCancelled(jsonObject: JSONObject?) {
    // Upload has been cancelled
}

// 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 specific download job
enxRoom?.cancelDownload(jobId)

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

// Acknowledgment callback
override fun onFileDownloadCancelled(jsonObject: JSONObject?) {
    // Download has been cancelled
}

// 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
}

room?.setEnxScreenShareObserver(myScreenShareObserver)

room?.startScreenShare()

override fun onStartScreenShareACK(jsonObject: JSONObject?) {
    // ACK to the initiator
}

override fun onScreenSharedStarted(enxStream: EnxStream?) {
    enxStream?.attachRenderer(screenShareView)
}

// 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);
}

room?.stopScreenShare()

override fun onStoppedScreenShareACK(jsonObject: JSONObject?) { }

override fun onScreenSharedStopped(enxStream: EnxStream?) {
    enxStream?.detachRenderer(screenShareView)
}

room.stopScreenShare();

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

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

override fun onStopAllSharingACK(jsonObject: JSONObject?) {
    // All sharing has been stopped — update your UI accordingly
}

// 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
}

room?.setEnxCanvasObserver(myCanvasObserver)

val opts = JSONObject().apply {
    put("url", "https://your-canvas-url.com")
}
room?.startCanvas(opts)

override fun onStartCanvasAck(jsonObject: JSONObject?) { }
override fun onCanvasStarted(enxStream: EnxStream?) {
    enxStream?.attachRenderer(canvasView)
}

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);
}

room?.stopCanvas()

override fun onStoppedCanvasAck(jsonObject: JSONObject?) { }
override fun onCanvasStopped(enxStream: EnxStream?) {
    enxStream?.detachRenderer(canvasView)
}

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();
}

room?.setEnxAnnotationObserver(myAnnotationObserver)

room?.startAnnotation(JSONObject())

override fun onStartAnnotationAck(jsonObject: JSONObject?) { }
override fun onAnnotationStarted(enxStream: EnxStream?) { }

// 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);
}

room?.stopAnnotation()

override fun onStoppedAnnotationAck(jsonObject: JSONObject?) { }
override fun onAnnotationStopped(enxStream: EnxStream?) { }

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);
}

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

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

override fun onACKStartLiveTranscription(jsonObject: JSONObject?) {
    // Start request acknowledged
}

override fun onSelfTranscriptionOn(jsonObject: JSONObject?) {
    // This endpoint is now receiving transcription
}

override fun onRoomTranscriptionOn(jsonObject: JSONObject?) {
    // All subscribed endpoints are receiving transcription
}

override fun onTranscriptionEvents(jsonObject: JSONObject?) {
    val type     = jsonObject?.getString("type")     // "speech_recognising" or "speech_recognised"
    val text     = jsonObject?.getString("text")     // Transcribed text
    val clientId = jsonObject?.getString("clientId") // Speaker's client ID
    // Display or process the transcribed text
}

// 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
}

enxRoom?.stopLiveTranscription()

override fun onACKStopLiveTranscription(jsonObject: JSONObject?) {
    // Stop request acknowledged
}

override fun onSelfTranscriptionOff(jsonObject: JSONObject?) {
    // Hide transcription UI
}

override fun onRoomTranscriptionOff(jsonObject: JSONObject?) {
    // Transcription has ended for all participants
}

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
}