Stream Management

func room(_ room: EnxRoom?, didConnect roomMetadata: [String: Any]?) {
    let streamInfo: [String: Any] = [
        "audio"      : true,
        "video"      : true,
        "data"       : true,
        "audioMuted" : false,
        "videoMuted" : false,
        "attributes" : ["custom1": "value"]
    ]
    let localStream = room?.getlocalStream(streamInfo)
    room?.publish(localStream)
}

- (void)room:(EnxRoom *)room didConnect:(NSDictionary *)roomMetadata {
    NSDictionary *streamInfo = @{
        @"audio"      : @YES,
        @"video"      : @YES,
        @"data"       : @YES,
        @"audioMuted" : @NO,
        @"videoMuted" : @NO,
        @"attributes" : @{
            @"custom1": @"value"
        }
    };

    EnxStream *localStream = [room getlocalStream:streamInfo];
    [room publish:localStream];
}

// Publish the local stream after room connects
func room(_ room: EnxRoom?, didConnect roomMetadata: [String: Any]?) {
    let streamInfo: [String: Any] = [
        "audio": true,
        "video": true,
        "data" : true
    ]
    let localStream = room?.getlocalStream(streamInfo)
    room?.publish(localStream)
}

// ACK — only you receive this; attach your local preview here
func room(_ room: EnxRoom?, didPublishStream stream: EnxStream?) {
    let playerView = EnxPlayerView(frame: localView.bounds)
    stream?.attachRenderer(playerView)
    localView.addSubview(playerView!)
}

// Broadcast — all participants receive this for every stream
func room(_ room: EnxRoom?, didAddedStream stream: EnxStream?) {
    // If this is not your own stream, subscribe to it
    if stream?.streamId != room?.localStream?.streamId {
        room?.subscribe(stream)
    }
}

// Publish the local stream after room connects
- (void)room:(EnxRoom *)room didConnect:(NSDictionary *)roomMetadata {
    NSDictionary *streamInfo = @{
        @"audio": @YES,
        @"video": @YES,
        @"data" : @YES
    };
    EnxStream *localStream = [room getlocalStream:streamInfo];
    [room publish:localStream];
}

// ACK — only you receive this; attach your local preview here
- (void)room:(EnxRoom *)room didPublishStream:(EnxStream *)stream {
    EnxPlayerView *playerView = [[EnxPlayerView alloc] initWithFrame:self.localView.bounds];
    [stream attachRenderer:playerView];
    [self.localView addSubview:playerView];
}

// Broadcast — all participants receive this for every stream
- (void)room:(EnxRoom *)room didAddedStream:(EnxStream *)stream {
    // If this is not your own stream, subscribe to it
    if (![stream.streamId isEqualToString:room.localStream.streamId]) {
        [room subscribe:stream];
    }
}

// Stop publishing your local stream
localStream.unpublish()

// All participants (including you) receive this when any stream is removed
func room(_ room: EnxRoom?, didRemovedStream stream: EnxStream?) {
    // Remove the corresponding player view from your UI
    print("Stream removed: \(stream?.streamId ?? "")")
}

// Stop publishing your local stream
[localStream unpublish];

// All participants (including you) receive this when any stream is removed
- (void)room:(EnxRoom *)room didRemovedStream:(EnxStream *)stream {
    // Remove the corresponding player view from your UI
    NSLog(@"Stream removed: %@", stream.streamId);
}

// Switch the local camera preview (does not affect published stream)
localStream.switchCameraPreview()

// Switch the local camera preview (does not affect published stream)
[localStream switchCameraPreview];

let exception = localStream.switchCamera()
if let exception = exception {
    print("Camera switch failed: \(exception.reason ?? "")")
}

NSException *exception = [localStream switchCamera];
if (exception) {
    NSLog(@"Camera switch failed: %@", exception.reason);
}

// Switch audio output to the speakerphone
room.switchMediaDevice("Speaker")

// Delegate fires after the switch completes
func didNotifyDeviceUpdate(_ updates: String?) {
    print("Audio device changed to: \(updates ?? "")")
    // Refresh your device selection UI to highlight the new active device
}

// Switch audio output to the speakerphone
[room switchMediaDevice:@"Speaker"];

// Delegate fires after the switch completes
- (void)didNotifyDeviceUpdate:(NSString *)updates {
    NSLog(@"Audio device changed to: %@", updates);
    // Refresh your device selection UI to highlight the new active device
}

// Mute your microphone
localStream.muteSelfAudio(true)

// Unmute your microphone
localStream.muteSelfAudio(false)

// ACK for the local user
func didAudioEvent(_ data: [String: Any]?) {
    print("Audio mute state changed: \(data ?? [:])")
}

// Room-wide notifications
func stream(_ stream: EnxStream?, didRemoteStreamAudioMute data: [Any]?) {
    // Update the mute indicator for this participant in your UI
}

func stream(_ stream: EnxStream?, didRemoteStreamAudioUnMute data: [Any]?) {
    // Remove the mute indicator for this participant in your UI
}

// Mute your microphone
[localStream muteSelfAudio:YES];

// Unmute your microphone
[localStream muteSelfAudio:NO];

// ACK for the local user
- (void)didAudioEvent:(NSDictionary *)data {
    NSLog(@"Audio mute state changed: %@", data);
}

// Room-wide notifications
- (void)stream:(EnxStream *)stream didRemoteStreamAudioMute:(NSArray *)data {
    // Update the mute indicator for this participant in your UI
}

- (void)stream:(EnxStream *)stream didRemoteStreamAudioUnMute:(NSArray *)data {
    // Remove the mute indicator for this participant in your UI
}

// Mute your camera video
localStream.muteSelfVideo(true)

// Unmute your camera video
localStream.muteSelfVideo(false)

func didVideoEvent(_ data: [String: Any]?) {
    print("Video mute state changed: \(data ?? [:])")
}

func stream(_ stream: EnxStream?, didRemoteStreamVideoMute data: [Any]?) {
    // Show a camera-off placeholder in the participant tile
}

func stream(_ stream: EnxStream?, didRemoteStreamVideoUnMute data: [Any]?) {
    // Restore the video frame in the participant tile
}

// Mute your camera video
[localStream muteSelfVideo:YES];

// Unmute your camera video
[localStream muteSelfVideo:NO];

- (void)didVideoEvent:(NSDictionary *)data {
    NSLog(@"Video mute state changed: %@", data);
}

- (void)stream:(EnxStream *)stream didRemoteStreamVideoMute:(NSArray *)data {
    // Show a camera-off placeholder in the participant tile
}

- (void)stream:(EnxStream *)stream didRemoteStreamVideoUnMute:(NSArray *)data {
    // Restore the video frame in the participant tile
}

// Subscribe when the room notifies you of a new stream
func room(_ room: EnxRoom?, didAddedStream stream: EnxStream?) {
    room?.subscribe(stream)
}

// Once subscribed, attach a player view and render the stream
func room(_ room: EnxRoom?, didSubscribeStream stream: EnxStream?) {
    let frame = CGRect(x: 0, y: 0, width: 160, height: 120)
    let playerView = EnxPlayerView(frame: frame)
    stream?.attachRenderer(playerView)
    view.addSubview(playerView!)
}

// Subscribe when the room notifies you of a new stream
- (void)room:(EnxRoom *)room didAddedStream:(EnxStream *)stream {
    [room subscribe:stream];
}

// Once subscribed, attach a player view and render the stream
- (void)room:(EnxRoom *)room didSubscribeStream:(EnxStream *)stream {
    CGRect frame = CGRectMake(0, 0, 160, 120);
    EnxPlayerView *playerView = [[EnxPlayerView alloc] initWithFrame:frame];
    [stream attachRenderer:playerView];
    [self.view addSubview:playerView];
}

// activeviews: "list" — you manage the layout
func room(_ room: EnxRoom?, didActiveTalkerList streams: [Any]?) {
    // Clear current video tiles and rebuild from the updated stream list
    rebuildVideoGrid(streams)
}

// activeviews: "view" — add the SDK-managed view once
func room(_ room: EnxRoom?, didActiveTalkerView view: UIView?) {
    view?.frame = videoContainerView.bounds
    videoContainerView.addSubview(view!)
}

// Available participant count changed
func room(_ room: EnxRoom?, didAvailable data: [String: Any]?) {
    print("Participants available: \(data ?? [:])")
}

// activeviews: "list" — you manage the layout
- (void)room:(EnxRoom *)room didActiveTalkerList:(NSArray *)streams {
    // Clear current video tiles and rebuild from the updated stream list
    [self rebuildVideoGrid:streams];
}

// activeviews: "view" — add the SDK-managed view once
- (void)room:(EnxRoom *)room didActiveTalkerView:(UIView *)view {
    view.frame = self.videoContainerView.bounds;
    [self.videoContainerView addSubview:view];
}

// Available participant count changed
- (void)room:(EnxRoom *)room didAvailable:(NSDictionary *)data {
    NSLog(@"Participants available: %@", data);
}

room.getMaxTalkers()

func room(_ room: EnxRoom?, didGetMaxTalkers data: [String: Any]?) {
    // data = { "result": 0, "maxTalkers": 4 }
    let maxTalkers = data?["maxTalkers"] as? Int ?? 0
    print("Room max talkers: \(maxTalkers)")
}

[room getMaxTalkers];

- (void)room:(EnxRoom *)room didGetMaxTalkers:(NSDictionary *)data {
    // data = { "result": 0, "maxTalkers": 4 }
    NSInteger maxTalkers = [data[@"maxTalkers"] integerValue];
    NSLog(@"Room max talkers: %ld", (long)maxTalkers);
}

room.getTalkerCount()

func room(_ room: EnxRoom?, didGetTalkerCount data: [String: Any]?) {
    // data = { "result": 0, "numTalkers": 4 }
    let numTalkers = data?["numTalkers"] as? Int ?? 0
    print("Current talker count: \(numTalkers)")
}

[room getTalkerCount];

- (void)room:(EnxRoom *)room didGetTalkerCount:(NSDictionary *)data {
    // data = { "result": 0, "numTalkers": 4 }
    NSInteger numTalkers = [data[@"numTalkers"] integerValue];
    NSLog(@"Current talker count: %ld", (long)numTalkers);
}

// Reduce active video streams to 4 (e.g. in response to a bandwidth alert)
room.setTalkerCount(4)

func room(_ room: EnxRoom?, didSetTalkerCount data: [String: Any]?) {
    print("Talker count updated: \(data ?? [:])")
}

// Reduce active video streams to 4 (e.g. in response to a bandwidth alert)
[room setTalkerCount:4];

- (void)room:(EnxRoom *)room didSetTalkerCount:(NSDictionary *)data {
    NSLog(@"Talker count updated: %@", data);
}

let playerView = room.getPlayer("CLIENT_ID")
if let playerView = playerView {
    // Apply custom styling, border, or overlay to this participant's tile
}

EnxPlayerView *playerView = [room getPlayer:@"CLIENT_ID"];
if (playerView) {
    // Apply custom styling, border, or overlay to this participant's tile
}

// Highlight the speaking indicator for specific participants
room.highlightBorderForClient(["CLIENT_ID_1", "CLIENT_ID_2"])

// Highlight the speaking indicator for specific participants
[room highlightBorderForClient:@[@"CLIENT_ID_1", @"CLIENT_ID_2"]];

// Highlight the moderator's tile with a distinct background colour
room.changeBgColorForClients(
    ["MODERATOR_CLIENT_ID"],
    withColor: UIColor(red: 0.2, green: 0.6, blue: 1.0, alpha: 0.4)
)

// Highlight the moderator's tile with a distinct background colour
[room changeBgColorForClients:@[@"MODERATOR_CLIENT_ID"]
                    withColor:[UIColor colorWithRed:0.2 green:0.6 blue:1.0 alpha:0.4]];

// Force a refresh of the active talker grid
room.forceUpdateATList()

// Force a refresh of the active talker grid
[room forceUpdateATList];

// Switch to leader layout (one prominent + smaller tiles)
room.switchATView("leader")

// Switch to gallery layout (equal-size tiles)
room.switchATView("gallery")

// Switch to leader layout (one prominent + smaller tiles)
[room switchATView:@"leader"];

// Switch to gallery layout (equal-size tiles)
[room switchATView:@"gallery"];

// Pin incoming video quality to standard-definition
room.setReceiveVideoQuality("SD")

func room(_ room: EnxRoom?, didSetVideoQuality data: [String: Any]?) {
    print("Receive video quality updated: \(data ?? [:])")
}

// Pin incoming video quality to standard-definition
[room setReceiveVideoQuality:@"SD"];

- (void)room:(EnxRoom *)room didSetVideoQuality:(NSDictionary *)data {
    NSLog(@"Receive video quality updated: %@", data);
}