In-Session Communication

The iOS SDK provides methods for chat, custom signalling, file sharing, screen sharing, canvas streaming, annotation, and live transcription within an active video session.

Send a Chat Message

Use sendMessage:isBroadCast:recipientIDs: to send a text message to all participants or to specific recipients. No stream publishing or subscription is required to exchange messages — the method works as soon as the room is connected.

Supports public (broadcast to all), private (one recipient), and group (multiple recipients) messaging.

Parameters

Delegate Methods

NSArray *recipients = @[@"clientId1", @"clientId2"];

// Public message to all
[room sendMessage:@"Hello everyone!" isBroadCast:YES recipientIDs:nil];

// Private message to specific recipients
[room sendMessage:@"Hello!" isBroadCast:NO recipientIDs:recipients];

- (void)room:(EnxRoom *)room didMessageReceived:(NSArray *)data {
    // data contains the incoming message
}

Edit a Chat Message

To update a message that has already been sent, call transactMessage: with a dictionary that includes the original message ID and the corrected text. Set type to "chat-update".

Parameters

Delegate Methods

NSDictionary *editOptions = @{
    @"message":   @"This is my edited message",
    @"messageId": @"MSG_ID",
    @"type":      @"chat-update"
};

[room transactMessage:editOptions];

- (void)didACKUpdateMessage:(NSArray *)data {
    // Edit acknowledged
}

- (void)didMessageUpdate:(NSArray *)data {
    // Recipients notified of edited message
}

Delete a Chat Message

To remove a sent message, call transactMessage: with a dictionary containing the message ID and type: "chat-delete". The server notifies all original recipients so their UIs can remove the message.

Parameters

Delegate Methods

NSDictionary *deleteOptions = @{
    @"messageId": @"MSG_ID",
    @"type":      @"chat-delete"
};

[room transactMessage:deleteOptions];

- (void)didACKDeleteMessage:(NSArray *)data {
    // Delete acknowledged
}

- (void)didMessageDelete:(NSArray *)data {
    // Recipients notified of deletion
}

Send Custom Data

Use custom signalling to send structured business data between participants — polls, instructions, or any application-specific payload that does not fit the standard chat message structure. Pass any NSDictionary payload to one or more participants without wrapping it in a chat message.

Parameters

Delegate: -room:didUserDataReceived — fires on each recipient with the custom dictionary payload.

Error codes: 5127 — data transfer rate exceeds the 100 KB/s limit.

NSDictionary *customData = @{
    @"sender":  @"Sender Name",
    @"message": @"Custom payload",
    @"type":    @"poll"
};

NSArray *recipients = @[@"clientId1"];
[room sendUserData:customData broadCast:NO recipientIDs:recipients];

- (void)room:(EnxRoom *)room didUserDataReceived:(NSArray *)data {
    // Received custom signal
}

Upload a File for Sharing

Call shareFiles:isBroadcast:clientIds: to launch the system file picker and begin an upload. The position parameter controls where the picker sheet appears on screen using the EnxFilePosition enum. Only one file can be in flight per upload request.

Parameters

Sender Delegate Methods

Receiver Delegate Methods

[room shareFiles:Top isBroadcast:YES clientIds:nil];

- (void)room:(EnxRoom *)room didInitFileUpload:(NSArray *)data {
    // Upload started
}

- (void)room:(EnxRoom *)room didFileUploaded:(NSArray *)data {
    // Upload complete
}

- (void)room:(EnxRoom *)room didFileAvailable:(NSArray *)data {
    // Receiver: file ready to download
}

Download a Shared File

First retrieve available files using -(NSArray *)getAvailableFiles, then initiate a download. Set autoSave to YES to let the SDK save images and videos directly to the device, or NO to receive raw Base64 data and handle storage yourself.

Parameters

Callbacks

// Get available files
[room getAvailableFiles];

// Initiate download
[room downloadFile:fileObject autoSave:YES];

- (void)room:(EnxRoom *)room didFileDownloaded:(NSString *)data {
    // File downloaded
}

- (void)room:(EnxRoom *)room didFileDownloadFailed:(NSArray *)data {
    // Download failed
}

Cancel File Upload

Each upload is assigned a numeric job ID. Use that ID to cancel a specific upload, or call cancelAllUploads to stop all in-flight uploads at once.

• -(void)cancelUpload:(int)jobID — cancel a specific upload by job ID.
• -(void)cancelAllUploads — cancel all uploads.

Callback: didFileUploadCancelled

Upload Error Codes

Cancel File Download

• -(void)cancelDownload:(int)jobID — cancel a specific download.
• -(void)cancelAllDownloads — cancel all downloads.

Callback: didFileDownloadCancelled

Download Error Codes

Screen sharing publishes the device's entire screen as a dedicated media stream at 6 fps. Unlike regular streams, the screen share continues even when the user moves the app to the background, making it suitable for walkthroughs, support sessions, and presentations.

Start Screen Sharing

Call startScreenShare on your EnxRoom instance. The SDK coordinates with a Broadcast Extension process that handles screen capture at the OS level. Two separate delegate callbacks reflect the two separate processes involved.

Delegate Methods

[enxRoom startScreenShare];

- (void)didStartBroadCast:(NSArray *)data {
    // Broadcast extension started
}

- (void)room:(EnxRoom *)room didStartScreenShareACK:(NSArray *)data {
    // Screen sharing started
}

Stop Screen Sharing

Delegate Methods

[enxRoom stopScreenShare];

- (void)didStoppedBroadCast:(NSArray *)data {
    // Broadcast extension stopped
}

- (void)room:(EnxRoom *)room didStopScreenShareACK:(NSArray *)data {
    // Screen sharing stopped
}

Exit Screen Sharing

exitScreenShare signals the Broadcast Extension to exit the session entirely. This must be called from the Broadcast Extension target, not the main app.

Delegate Methods

Error code: 5137 — screen sharing is not currently running.

Force Stop Screen Sharing

Moderators can forcibly end any active screen share or canvas stream across the room with a single call. This is useful for regaining control of the session if a participant has left sharing running unintentionally.

[enxRoom stopAllSharing];

- (void)room:(EnxRoom *)room didStopAllSharingACK:(NSArray *)data {
    // All sharing stopped
}

Canvas streaming lets a participant publish any UIView as a dedicated video stream. This is the right tool when you need to share custom content — a presentation slide, a whiteboard, a data visualisation, or any arbitrary view hierarchy — without sharing the entire screen.

Start Canvas Streaming

Pass the view you want to stream to startCanvas:. The SDK captures the view's render output and publishes it as Stream ID 102.

Delegate Methods

[room startCanvas:myUIView];

- (void)room:(EnxRoom *)room didStartCanvasACK:(NSArray *)data {
    // Publisher: canvas streaming started
}

- (void)room:(EnxRoom *)room didCanvasStarted:(EnxStream *)stream {
    // All participants: render the canvas stream
    stream.enxPlayer.frame = yourFrame;
    [yourView addSubview:stream.enxPlayer];
}

Error Codes

Stop Canvas Streaming

Delegate Methods

[room stopCanvas];

- (void)room:(EnxRoom *)room didCanvasStopped:(EnxStream *)stream {
    [stream.enxPlayer removeFromSuperview];
}

Annotation lets a participant draw on top of a remote stream in real time. The EnxToolBar UI component provides drawing tools (pen, shapes, eraser, and more) that the annotating participant can use without additional setup. The annotation layer is composited over the selected stream and is visible to all participants.

Add Annotation Toolbar

Instantiate EnxToolBar and add it to your view hierarchy before starting annotation. Position it so it does not obscure the stream it will annotate.

EnxToolBar *toolBar = [[EnxToolBar alloc] initWithFrame:CGRectMake(x, y, width, height)];

Start Annotation

Pass the remote EnxStream you want to annotate. The SDK validates that the stream is valid and that no other annotation or canvas operation is in progress.

Delegate Methods

Stop Annotation

Delegate Methods

[enxRoom startAnnotation:remoteStream];
[enxRoom stopAnnotation];

- (void)room:(EnxRoom *)room didStartAnnotationACK:(NSArray *)data { }
- (void)room:(EnxRoom *)room didAnnotationStarted:(NSArray *)data { }
- (void)room:(EnxRoom *)room didStoppedAnnotationACK:(NSArray *)data { }
- (void)room:(EnxRoom *)room didAnnotationStopped:(NSArray *)data { }

Annotation Error Codes

Live transcription converts speech from active talkers to text in real time and broadcasts it to subscribers. The transcription process starts with the first subscriber and stops when the last unsubscribes — unless auto_transcribe is enabled, in which case it runs for the full session.

Room Configuration

Include a live_transcription object in the room creation payload to control transcription behaviour at the room level:

Start Live Transcription

Two methods are available depending on the desired scope:

The language parameter is optional; it defaults to "english_us". If room-level transcription is already running when a second participant calls this method, they are subscribed to the existing process rather than starting a new one.

Delegate Methods

[enxRoom startLiveTranscriptionForRoom:@"english_us"];

- (void)room:(EnxRoom *)room didRoomTranscriptionOn:(NSArray *)data {
    // Room-level transcription started
}

- (void)room:(EnxRoom *)room didSelfTranscriptionOn:(NSArray *)data {
    // Self transcription started
}

- (void)room:(EnxRoom *)room didTranscriptionEvents:(NSArray *)data {
    // Receive transcribed text in real time
    // data: [{ "type": "speech_recognised", "text": "...", "clientId": "..." }]
}

Error codes: 3002 — not subscribed or transcription is already in progress.

Stop Live Transcription

Calling stopLiveTranscription unsubscribes the caller from the transcription feed. The underlying transcription process stops when all subscribers have unsubscribed — unless auto_transcribe is enabled, in which case it continues until the session ends.

Delegate Methods

[enxRoom stopLiveTranscription];

- (void)room:(EnxRoom *)room didRoomTranscriptionOff:(NSArray *)data {
    // Room transcription stopped
}

- (void)room:(EnxRoom *)room didSelfTranscriptionOff:(NSArray *)data {
    // Self transcription stopped
}