Basic Functions of iOS SDK describes the necessary tasks to achieve basic Audio/Video communication between participants connected from their End-Point Applications to an EnableX hosted Room. For more advanced use cases, please refer Advance Features & Moderator Controls.

Table of Contents

Get list of Audio Devices

You will need to specify Audio Device ID (Microphone Device ID) or use the default Microphone Device ID of your Mobility Device to initiate a Stream. EnableX provides API support to get a list of Audio Devices (Microphone) available with your Device running the Client End Point application along with their device IDs.

The EnxRoom.getDevices() method is used to return a List containing all the Microphones available with your Device. You can build UI Element with the List to choose a Microphone to use for your Stream.

Class: EnxRoom

Method: -(NSArray*)getDevices;

NSArray *devicesList = [room getDevices];

// Returns [Speaker, EARPIECE, Headphones, Bluetooth] 
// Note: One or many of these devices in array as applicable

Get selected Audio Device by User

EnxRoom.getSelectedDevices() method is used to get the selected or used Audio Device for the Stream.

Class: EnxRoom

Method: -(NSString*)getSelectedDevice;

String selectedDevice =  [room getSelectedDevice]; 
// Returns one of these - Speaker, EARPIECE, Headphones, Bluetooth

Initiate a Room

iOS SDK is used by the Client End Point Application to connect to the Virtual Room hosted at EnableX to establish a session. The process starts with initializing a Room Object using the EnxRoom Class.

Class: EnxRoom

Method: -(instancetype)init;

EnxRoom *room = [[EnxRoom alloc] init];

Connect to Room

After Room’s initialization the Client End Point needs to connect to the EnableX Server to join a session. The EnxRoom.connect() method is used to connect to the virtual Room hosted by EnableX. Unless an End Point is connected to EnableX, no other communication is possible between the two entities, viz. EnableX Server & Client End Point.

The connect method requires a String Parameter with a Token that the Client End Point received from EnableX platform via their Application Server. When connected, a Bi-Directional Communication Channel will be established between the End Point and EnableX Server over a Web Socket. Both entities communicate with each other using Socket Events. Communication would fail if any network issue disconnects the Web Socket.

Note:

  • Client End Point may not get connected to the room due to network problem, invalid or expired Token. If it fails to connect, you will be notified accordingly using delegate method- room:didError: .
  • End Point is notified with delegate method- room:didConnect:  on successful connection to the room with complete run-time  Meta Information of the Room.
  • Auto-Reconnect doesn’t work on:
    • Last Participant disconnected from Adhoc Room
    • User is dropped from Room by Moderator
    • User disconnects explicitly

Class: EnxRoom

Method: - (void)connect:(NSString *)token roomInfo:(NSDictionary *)roomInfo advanceOptions:(NSArray *)advanceOption;

Parameters:

  • token: Token to connect to the Room, as received from Server API Call
  • roomInfo – Optional. NSDictionary Object. Keys explained below:
    • allow_reconnect Boolean. Default: true. Re-connection parameter. Whether to enable Auto-Reconnect feature. If you set to false, Client End Point will not try reconnecting to EnableX
    • number_of_attempts Numeric. Min Value: 1. Max Value: Not specified, use any number. Default: 3. Re-connection parameter. Max number of times Client End Point tries to reconnect to EnableX
    • timeout_interval Numeric. Re-connection parameter. Timeout Interval in Millisecond to wait before attempting reconnect.
    • activeviews – Enumerated Values, list or view. If you set to view, you get a predefined view of all videos in a session. If you set to list, you get individual streams to create your own view with the video streams.
    • forceTurn – Boolean. Default: false. If enabled, Video Streams are forced through a TURN Server.
    • chat_only: Boolean. Default: false. If only text-chat to be enabled disabling audio-video communications.
    • playerConfiguration – JSON Object with Video Player Configurations.
      • audiomute – Boolean. Default: true. Show / Hide Audio Mute/Unmute Button
      • videomute – Boolean. Default: true. Show / Hide Video Mute/Unmute Button
      • bandwidth – Boolean. Default: true. Show / Hide Low Bandwidth Notification Button
      • screenshot – Boolean. Default: true. Show / Hide Screen Shot Button
      • avatar – Boolean. Default: true. Show / Hide Avatar for No-Video Stream
      • iconColor – String. Default #FFFFFF. HEX Color Code for Icons.
      • iconHeight – Number. Default 30. Icon Height in Pixel
      • iconWidth – Number. Default 30. Icon Width in Pixel
      • avatarHeight – Number. Default 200. Avatar Height in Pixel
      • avatarWidth – Number. Default 200. Avatar Width in Pixel
      • pinned – Boolean. Default: false. Show / Hide Pinned User Icon
  • advanceOptions – Optional. Array of Advanced Options. Each Element of Array has id and enable keys. Following IDs are used:
    • battery_updates Boolean. Set to enable key to true to enable Auto-Battery Updates feature, otherwise set it to false
    • notify-video-resolution-change Boolean. Set enable to true to enable Video Resolution Change Notification feature, otherwise set it to false

Delegate Methods:

  • - room:didConnect:  – To the end-point when its connected to Room
  • - room:didError:– To the end-point when it fails to connect to Room
  • - room:userDidJoined: – To notify all connected users that a new user is connected to Room
  • - room:didActiveTalkerList: – To the end-point with list of Talkers after few seconds of receiving - room:didConnect: delegate method. Refer how to handle Active Talkers
NSString *token = "XXX";
NSDictionary *roomInfo = { // Re-Connect Options
 @"allow_reconnect": true,
 @"number_of_attempts": 3,
 @"timeout_interval": 10000,
 @"audio_only": false
}; 

NSDictionary *advanceDict= @{
 @"id":@"battery_updates",
 @"enable":@YES
};

NSMutableArray *advanceOptionArray = [[NSMutableArray alloc] init];

[advanceOptionArray addObject:advanceDict];

advanceDict= @{
 @"id":@"notify-video-resolution-change",
 @"enable":@YES
};

[advanceOptionArray addObject:advanceDict]; 

// Initiates Room 
EnxRoom *room = [[EnxRoom alloc] init];

// Connects with Re-Connection & Advance Options
[room connect:token roomInfo:roomInfo advanceOptions:advanveOptionArray ];
 

//Delegate methods
-(void)room:(EnxRoom *)room didConnect:(NSDictionary *)roomMetadata{
      // Connected. Delegate receives room instance and Room Meta JSON.
}

-(void)room:(EnxRoom *)room didError:(NSString *)reason{
 // Connection failed. Find error
}

-(void)room:(EnxRoom *)room userDidJoined:(NSArray *)Data{
 // A new user connected. user JSON has user information
}

-(void)room:(EnxRoom *)room didActiveTalkerList:(NSArray *)Data{
      // List of talkers in the Room
      // Received after room connected.
}

Initiate Local Stream

A local stream has to be initialized at the Client End Point before you can publish it to the Room. The initialization process includes specifying media tracks, adding custom attributes etc. in a form of a JSON object.

ClassEnxRoom

Method: –(EnxStream *)getlocalStream:(NSDictionary *)publishStreamInfo;

ParameterspublishStreamInfo – A typing JSON definition with Stream Options given below:

{
     "audio": true,          // Whether to add Audio to stream
     "video": true,          // Whether to add Video to stream
     "data": true,           // Whether to add Data to stream
     "videoSize":  {         // Video Frame Size
           "minWidth": number, 
           "minHeight": number,  
           "maxWidth": number,
           "maxHeight": number
       ), 
     "audioMuted": true,     // Audio muted on entry to room  
     "videoMuted": true,     // Video muted on entry to room  
     "attributes": {         // Object to carry custom data  
         "custom1": ""
      },
      "maxVideoBW": number,  // Max Bandwidth 
      "minVideoBW": number   // Min Bandwidth  
 } 

Join a Room with Stream

Connecting and joining a Room is a complex chain of events. You will need to ensure success status of previous event to proceed to the next event. The following basic steps are required to join room successfully

  • Initiate Room & Connect
  • If connected, initiate Stream.
  • Publish Stream

EnxRtc.joinRoom() method comes as a handy tool for developer. It handles all complexities of connecting and joining the room.

Class: EnxRtc

Method: -(EnxStream *)joinRoom:(NSString *)token delegate:(id)delegate PublishStreamInfo: (NSDictionary *)publishStreamInfo;

Parameters:

  • token – JWT Token received through Server API Call
  • delegate: EnxRoomDelegate object is the delegate for the EnxRoom object
  • publishStreamInfoStream Initialization Meta Info. Optional.

Returns: EnxStream – Published Local Stream Object

NSDictionary* publishStreamInfo = {
         video: true,
         audio: true,
         data: true,
         attributes: { name: "XX" }
}

NSString* token = "XXX";

EnxRtc *enxRtc = [[EnxRtc alloc] init];
EnxStream *localStream = [enxRtc joinRoom:token delegate:self publishStreamInfo:publishStreamInfo];

//Delegate methods
-(void)room:(EnxRoom *)room didConnect:(NSDictionary *)roomMetadata{
	// Connected. Delegate receives room instance and Room Meta JSON.
}

-(void)room:(EnxRoom *)room didError:(NSString *)reason{
	// Connection failed. Find error
}

Disconnect from a Room

A Client End Point can disconnect itself from the room to close its session. A disconnected End-Point will loose media and signaling socket immediately.

Once disconnected, the SDK will initiate a delegate method –room:didRoomDisconnect: for you to handle UI. Also, all connected users of the session will be notified with an delegate named –room:userDidDisconnected: so that they all can update the status of their UI.

Class: EnxRoom

Method: - (void)disconnect;

Delegate Methods:

  • –room:didRoomDisconnect: – To the user who is disconnected
  • –room:userDidDisconnected: – To all other connected users
[room disconnect];

- (void)room:(EnxRoom *)room didRoomDisconnect:(NSArray * _Nullable)response {
    // You are disconnected
}
-(void)room:(EnxRoom *)room userDidDisconnected:(NSArray *)Data{
     // One user is disconnected
     // Data - User Information of disconnected user
}

Publish / Unpublish Local Stream

The local stream with audio/video needs to be started and published to the Room for other participants to see and hear you. Please use the API methods below to publish, unpublish and close local stream.

Publish Local Stream

EnxRoom.publish() method is used to publish a local stream to the connected Room. After the local stream is published to the Room, all participants are notified with an delegate method  - room:didAddedStream.

Class: EnxRoom

Method: - (void)publish:(EnxStream *)stream;

Parameters:

  • stream– Initiated Stream Object

Delegate Methods:

  • - room:didPublishStream: – to the publisher that the stream has been published
  • - room:didAddedStream: – to all participants announcing new stream in room
[room publish:localStream];

- (void)room:(EnxRoom *)room didPublishStream:(EnxStream *)stream{
	// Your stream is published
}

-(void)room:(EnxRoom *)room didAddedStream:(EnxStream *)stream{
	// To tell others that a New Stream is added to the Room
	// You may subscribe to the Stream
}

Unpublish Local Stream

Unpublishing a published stream will disconnect the local stream from the Room. The process will not release device access so that subsequent re-publishing will not require the user to grant  device access again.

To unpublish, use EnxRoom.unpublish() method. Please use the callback to handle if stream is unpublished successfully. All users connected to the room will be notified that a Published Stream is unpublished or removed from the Room using the delegate method named – room:didRemovedStream:

Class: EnxRoom

Method: - (void)unpublish;

Delegate Method: – room:didRemovedStream: – To all participants that a Stream is taken off the Room.

[room unpublish]; // To unpublish all Local Streams

-(void)room:(EnxRoom *)room didRemovedStream:(EnxStream *)stream{
     // To tell others that stream is taken off the Room
}

Subscribe Remote Streams

To receive media streams of other participants connected to a Room, you must subscribe to the streams individually. Unless you subscribe a stream, you will not receive anything.

When a new stream is added to the Room we receive a Stream Object through delegate method - room:didAddedStream. The receive the stream, you need to subscribe to it using EnxRoom.subscribe() method.

Class: EnxRoom

Method: -(void)subscribe:(EnxStream *)stream;

Parameters: stream– The Stream Object to subscribe

Delegate Method: - room:didSubscribeStream:  – You are notified that the Stream has been subscribed.

// There is a new stream you may subscribe
-(void)room:(EnxRoom *)room didAddedStream:(EnxStream *)stream{
	[room subscribe:stream]; // Subscribe to it.
}

- (void)room:(EnxRoom *)room didSubscribeStream:(EnxStream *)stream {
	// You subscribed to stream.
}

Note! Please do not  subscribe to your local stream. EnableX platform will not return your locat audio/video stream. Details can be found in Active Talkers Section below. However, as a  publisher you will receive your own Screen Share and Canvas Streaming.

Handle Active Talkers

During a multi-party video conference, more server and Client-End-Point resources are consumed. Therefore, EnableX sends only 6 streams of users actively talking (generating sound) in the Room to each end-point. Additionally, it sends 2 streams, viz. Screen Share (Stream# 11) and Canvas Stream (Stream# 21).

On getting connected to Room, your Client End Point will also receive - room:didAddedStream delegate method for all these 6+2 Streams available in the Room. You need to subscribe to each of these Streams.

Subsequently, whenever there is change in Talkers List, EnableX sends out an updated Active Talkers List to each End Point. The list of Active-Talkers is available in JSON format and sent through delegate method –room:didActiveTalkerList:. The list of Active Talkers comprises list will have talkers in ascending order i.e. latest talker will be listed first. Therefore, you may expect to receive the event too frequently in a noisy room.

EnableX v1.8 introduces pinning of user-streams that forces pinned users also in the Active Talkers List irrespective they are talking or not. So, active talkers appear first in the list and then pinned non-talkers. stream.pinned returns true if the stream is pinned.

Active Talkers List JSON

[ EnxStream1, EnxStream2, ....., EnxStreamN ] 

Note: In case of error, <null> is received at 1st Index, and Error Info at 2nd Index

This Active Talkers JSON is used for managing the UI and to play audio/video streams from remote users. To play a specific stream, you need the  Remote Stream object using room.streamsByStreamId[StreamId]. Please remember before you can play any stream from the Active Talkers list, you should have subscribed to all “dummy” streams received through delegate method - room:didAddedStream:.

Class: EnxRooom

Delegate Method:

  • –room:didActiveTalkerList: To receive list of Active Talkers
  • -room:didActiveTalkerView: To receive complete View of Active Talkers
// To get Active Talker List
-(void)room:(EnxRoom *)room didActiveTalkerList:(NSArray *)Data{
 for (EnxStream *stream in Data) {
 if(stream.enxPlayerView != nil) {
 EnxPlayerView *playerView = (EnxPlayerView *)stream.enxPlayerView;
 playerView.frame = CGRect;
 playerView.delefate = self;
 [self.view addSubview: playerView];
 }
 }
}

// To get Acive Talker View
-(void)room:(EnxRoom *_Nullable)room didActiveTalkerView:(UIView *_Nullable)view {
     [self.view addSubview: view]; 
}

Note: The local Stream will not  be included in the Active Talkers JSON list sent to an End-Point even if the End Point is talking. Hence the Active Talker JSON list sent to different End Points varies. In case you need to play own stream, please use the local stream.

Get maximum permissible Talker Count

To know maximum permissible Active Talkers that you may receive and you can set, you may use EnxRoom.getMaxTalkers() method.

Class: EnxRoom

Method: - (void)getMaxTalkers;

Delegate Method: - (void)room:(EnxRoom *)room didGetMaxTalkers:(NSArray *)Data

[room getMaxTalkers];

-(void)room:(EnxRoom *)room didGetMaxTalkers:(NSArray *)Data {
     // Talker info in success response jsonobject:
     // [{"result": 0, "maxTalkers": 4}] 
}

Get Talker Count

It may be necessary to know how many talkers are expected to receive with  –getTalkerCounter: delegate method, i.e. to know either the preset value of talkers or any custom value in effect which is either by the Application Developer or opted by End-Point User.

Class: EnxRoom

Method: -(void) getTalkerCount;

Delegate Method: - (void)room:(EnxRoom *)room didGetTalkerCount:(NSArray *)Data

[room getTalkerCount]; 

-(void)room:(EnxRoom *)room didGetTalkerCount:(NSArray *)Data{
    // Data: [{ "result": 0, "numTalkers": 4 }] 
}

Set Talker Count

EnableX sets a maximum of 6 active talkers in the active talker-list with  –room:didActiveTalkerList: delegate method. However, you may opt to receive less talkers at a Client End Point if you so require. This may either be a predefined value, or this value may be set at run-time in a connected session. If needed, you can create UI for the connected user to opt for number of active-talkers the user wants to receive.

Class: EnxRoom

Method: - (void) setTalkerCount:(NSInteger)number;

Parametersnumber – No. of talkers you want to receive. Range 0-6

  • If you set number to any value from 1 to 6 – you will receive those many talkers in the list.
  • If you set number to 0 (zero), then list doesn’t become empty. Rather, you would start receiving 3 audio streams only. Video Streams will not be carried.

Delegate Method : -(void)room:(EnxRoom *)room didSetTalkerCount:(NSArray *)Data;

[room setTalkerCount:3];


-(void)room:(EnxRoom *)room didSetTalkerCount:(NSArray *)Data{
 // Data: [{ "result": 0, "numTalkers": 3 }]
}

Handle Disconnection & Reconnection

A Client End Point is connected with EnableX over Secured Web Socket. A connected End Point might get disconnected from EnableX due to network issues. The End Point gets notified using delegate method - room:didConnectionLost:.

Delegate Methods:

  • - room:didConnectionLost: – When End Point looses network connection
  • - room:didConnectionInterrupted: – When connection is interrupted e.g Switch from WiFi to 4G and vice versa
- (void)room:(EnxRoom*)room didConnectionLost:(NSArray*)data {
	// Disconnected. Handle UI 
} 

- (void)room:(EnxRoom*)room didConnectionInterrupted:(NSArray*)data{
	// Interrupted. Handle UI 
}

For disconnected end-points, EnableX supports Auto Re-connection to the Session ensuring better user experience. To use Automatic Re-Connection feature, you must initiate the Connection with Room with Re-Connection options. Note that Auto-Re-Connect doesn’t work when:

  • Last Participant disconnected from Adhoc Room
  • User is dropped from Room by Moderator
  • User disconnects explicitly

Delegate Methods:

  • - room:didUserReconnectSuccess:– When End-Point successfully gets reconnected with EnableX
  • - room:didReconnect: – When End-Point trying to reconnect within given time period
NSDictionary *roomInfo = { // Re-Connect Options
	@"allow_reconnect": true,
	@"number_of_attempts": 3,
	@"timeout_interval": 10000,
	@"audio_only": false
}; 

NSDictionary *advanceDict= @{
	@"id":@"battery_updates",
	@"enable":@YES
};

NSMutableArray *advanceOptionArray = [[NSMutableArray alloc] init];

[advanceOptionArray addObject:advanceDict];

advanceDict= @{
	@"id":@"notify-video-resolution-change",
	@"enable":@YES
};

[advanceOptionArray addObject:advanceDict]; 


[room connect:@"token" roomInfo:roomInfo advanceOptions:advanveOptionArray ];

-(void)room:(EnxRoom*)room didUserReconnectSuccess:(NSDictionary*)data{
	// Got reconnected
}

- (void)room:(EnxRoom *)room didReconnect:(NSString *)reason{
	// Reconnecting 
}

Play Stream

You can play a local stream, all subscribed remote streams including screen-share, canvas streams within EnxPlayerView Object. Therefore, you need to create an Object of EnxPlayerView Class and then attach the Stream to Player View.

In case you want to stop playing stream, detach the Stream from PlayerView.

Class:

  • EnxPlayerView – To initiate an Player View Object.
  • EnxStream – To attach the Stream to Player View

Method:

  • - (void)attachRenderer :(EnxPlayerView*)ObjEnxPlayerView; – To play stream
  • - (void)detachRenderer; – To stop playing stream. No parameter needed

Parameters:

  • ObjEnxPlayerView – A Player View Object
// To Initialize Local Stream Player View Object 
EnxPlayerView *playerView = [[EnxPlayerView alloc] initLocalView:(CGRect)];

// To Initialize Remote Stream Player View Object 
// EnxPlayerView *playerView  = [[EnxPlayerView alloc] initRemoteView:(CGRect)];
 
[stream attachRenderer:PlayerView]; // Attach stream to playerview to play
[yourCustomView addSubview:PlayerView]; // Add playerView to your view

[stream detachRenderer]; // Detaching Renderer to stop playing

Adjust Layout

This Method helps to adjust Video Player Layout in case you have received complete Active Talker View using -room:didActiveTalkerView: In case user rotates Screen, this method will help Video layout to re-adjust to fit within its Parent View.

Method:

  • public void adjustLayout(int frameWidth, int frameHeight) – To adjust Video Layout

Parameters:

  • frameWidth: Width of Framed View
  • frameHeight: Height of Framed View
enxRoom.adjusrLayout(width,height)

Know Stream Information

Stream Object Properties can be accessed from directly your Application. However, EnableX provides methods to access more information related to Stream.

Get Stream ID

Every Stream is identified by its Stream ID, be it a local or a remote stream, a canvas stream or a screen share stream. You may obtain the Stream ID of the stream from its property called streamId.

ClassEnxStream

PropertystreamId

Verify availability of Media Tracks in Stream

EnxStream class has number of methods to verify whether the stream has one or more type of media tracks.. The  methods (with no parameters) returning a true/false are listed below:

Class: EnxStream

Methods:

  • - (BOOL)hasAudio – To check if Stream has Audio Track
  • - (BOOL)hasVideo – To check if Stream has Video Track
  • - (BOOL)hasData – To check if Stream has Data Track
if ([stream hasVideo] ) {
     // The Stream has a Video Track in it
}

// Other methods are also used similar way

Know if Stream is Local or Remote

To know if a stream is a Local Stream or Remote Stream user stream property called isLocal – it carries BOOL value, i.e. true for Local Stream, false for Remote Stream.

Class: EnxStream

Property: isLocal – It’s a BOOL

if (stream.isLocal) {
     // Its a Local Stream
 }
 else {
     // Its a  Remote Stream
 }

Know Room Information

Room Object Properties can be accessed from directly your Application. However, EnableX provides methods to access more information related to Room.

Get Room ID

Every Room is assigned with a Unique Room ID while creating the Room. The Room ID of the room to which you are connected can be found from property called roomId

Class: EnxRoom

Property: roomId

NSString* roomID= room.roomId; 

Get Room Meta Information

To know Meta Information of the Room to which you are connected, you may use Objeect Property named roomMetadata. Room Meta information contains complete Room Definition along with many Run-Time parameters with their current values & room stats of connected users and streams. This is received by all end-points after getting connected to Room along with  - room:didConnect: delegate method. Some of the run-time parameters are updated internally by the SDK on various events.

Class: EnxRoom

property: roomMetadata

NSDictionary* roomMeta = room.roomMetadata;

Get connected Client ID

Each connected user to the Room is assigned with a Unique Client ID for the session. To know the Client ID of the connected user from the enc-point, use clientId property.

Class: EnxRoom

Method: clientId

NSString* ClientId = room.clientId; 

Get connected User Name

To know the name of connected user from the end-point, use clientName property.

Class: EnxRoom

Method: clientName

NSString* ClientName = room.clientName; 

Get connected User Role

A User connected to a Room with either role of moderator or participant. Use userRole property to know role of the user

Class: EnxRoom

Method: userRole

NSString* role = room.userRole;

Get connected User Information at an End-Point

To get connected user information at an End-Point, use EnxRoom.Whoami() method. It returns complete user-meta for the connected user.

Class: EnxRoom

Method: - (NSDictionary)Whoami;

NSDictionary* myinfo = [room Whoami]; 

Note: Refer Dictionary structure for User Meta – i.e. for myinfo in above example.

Get connected User List

To get a list of connected users to the Room to which the enc-point is also connected to, use userList property. It returns a NSArray with connected user’s information.

Class: EnxRoom

Property: userList

(NSArray)Users = room.getUserList()

// Return JSON Users
/*
[
      {
          "clientId": "",             // Unique Client ID assigned by EnableX
          "name": "",                 // User's name
          "user_ref": "",             // User's Reference
          "role": "participant",      // Enum: moderator, participant
          "permissions": {            // In-Session Permission of User
          "publish": Boolean,         // Whether user can pubish local stream
          "subscribe": Boolean,       // Whether user can subscribe remote streams
          "record": Boolean,          // Whether user can initiate recording
          "stats": Boolean,           // Whether user can view stream status
          "controlhandlers": Boolean  
          }
      }
  ] 
*/

Get Local Stream ID

Every Stream is identified by its Stream ID, be it a local or a remote stream, a canvas stream or a screen share stream. You may obtain the ID of the published stream using  publishStreamId property.

Class: EnxRoom

Property: publishStreamId

NSString* publishStreamID = room.publishStreamId; 

Get Stream by Stream ID

To get Stream Object for given Stream-ID, use NSDictionary property called streamsByStreamId.

Class: EnxRoom

Method: streamsByStreamId

NSDictionary* streamsDict = room.streamsByStreamId; // Get Dictionary

EnxStream* stream =  streamsDict[@"StreamID"];  // Get specific Stream Object

Get list of Remote Streams

To get all the Remote Streams available in the Room, useremoteStreams property.

Class: EnxRoom

Property: remoteStreams

NSArray* remoteStreams = room.remoteStreams;

Explore iOS SDK