# Join multiple channels (/en/realtime-media/rtc/build/join-and-manage-channels/join-multiple-channels/unity)

> For AI agents: see the complete documentation index at [llms.txt](/llms.txt).

Agora RTC SDK enables you to simultaneously join multiple channels. This capability allows you to receive and publish audio and video streams across multiple channels concurrently.

      
  
      
  
      
  
      
  
      
## Understand the tech

RTC SDK's multi-channel functionality is based on two key components:

* `RtcConnection`

  The `RtcConnection` object identifies a connection. It contains the following information:

  * Channel name
  * User ID of the local user

  You create multiple `RtcConnection` objects, each with a different channel name and user ID. Each `RtcConnection` instance can independently publish multiple audio streams and a single video stream.

* `IRtcEngineEx`

  The class contains methods tailored for interacting with a designated `RtcConnection` object.

  To join multiple channels, you call `JoinChannelEx` method in the `IRtcEngineEx` class multiple times, using a different `RtcConnection` instance each time.

When joining multiple channels:

* Ensure that the user ID for each `RtcConnection` object is unique and nonzero.

* Configure publishing and subscribing options for the `RtcConnection` object in `JoinChannelEx`.

* Use the `connection` parameter in each callback to identify the corresponding channel.

## Prerequisites

Ensure that you have implemented the [SDK quickstart](/en/realtime-media/rtc/get-started-sdk) in your project.

## Implementation

This section explains how to join a second channel as a host after you have already joined the first channel.

1. Join the second channel

Call `JoinChannelEx` to join the second channel:

```csharp
ChannelMediaOptions options2 = new ChannelMediaOptions();
// Automatically subscribe to remote audio
options2.autoSubscribeAudio.SetValue(true);
// Automatically subscribe to remote video
options2.autoSubscribeVideo.SetValue(true);
// Publish audio from the microphone
options2.publishMicrophoneTrack.SetValue(true);
// Publish video from the camera
options2.publishCameraTrack.SetValue(true);
// Set the user role to broadcaster
options2.clientRoleType.SetValue(CLIENT_ROLE_TYPE.CLIENT_ROLE_BROADCASTER);
// Join the second channel with a unique user ID
ret = RtcEngine.JoinChannelEx(_token, new RtcConnection(_channelName, UID2), options2);
Debug.Log("JoinChannelEx returns: " + ret);
```

2. Set up remote user video

Listen for the `OnUserJoined` callback and call `SetForUser` to set up video rendering for the remote user:

```csharp
public override void OnUserJoined(RtcConnection connection, uint uid, int elapsed)
{
  Debug.Log(string.Format("OnUserJoined uid: {0}, elapsed: {1}", uid, elapsed));
  // Create a view for the remote user
  var videoSurface = MakeImageSurface(uid.ToString());
  // Set up video rendering
  videoSurface.SetForUser(uid, connection.channelId, VIDEO_SOURCE_TYPE.VIDEO_SOURCE_REMOTE);
  // Callback when the Texture size changes
  videoSurface.OnTextureSizeModify += (int width, int height) =>
  {
    var transform = videoSurface.GetComponent<RectTransform>();
    if (transform)
    {
      // If rendering in a RawImage, set the RawImage size
      transform.sizeDelta = new Vector2(width / 2, height / 2);
      transform.localScale = Vector3.one;
    }
    else
    {
      // If rendering in a MeshRenderer, set the MeshRenderer size
      float scale = (float)height / (float)width;
      videoSurface.transform.localScale = new Vector3(-1, 1, scale);
    }
    Debug.Log("OnTextureSizeModify: " + width + " " + height);
  };
}

private static VideoSurface MakeImageSurface(string goName)
{
  GameObject go = new GameObject { name = goName };
  // Add RawImage for rendering
  go.AddComponent<RawImage>();
  // Make the object draggable
  go.AddComponent<UIElementDrag>();

  var canvas = GameObject.Find("VideoCanvas");
  if (canvas != null)
  {
    go.transform.parent = canvas.transform;
    Debug.Log("Video view added");
  }
  else
  {
    Debug.Log("Canvas is null, video view not added");
  }

  // Set transform properties
  go.transform.Rotate(0f, 0f, 180f);
  go.transform.localPosition = Vector3.zero;
  go.transform.localScale = new Vector3(2f, 3f, 1f);

  // Add VideoSurface component
  var videoSurface = go.AddComponent<VideoSurface>();
  return videoSurface;
}
```

## Reference

This section contains content that completes the information on this page, or points you to documentation that explains other aspects to this product.

### API reference

* [`IRtcEngineEx`](https://api-ref.agora.io/en/video-sdk/unity/4.x/API/class_irtcengineex.html#class_irtcengineex)
* [`RtcConnection`](https://api-ref.agora.io/en/video-sdk/unity/4.x/API/class_rtcconnection.html)
* [`JoinChannelEx`](https://api-ref.agora.io/en/video-sdk/unity/4.x/API/class_irtcengineex.html#api_irtcengineex_joinchannelex)
* [`VideoSurface`](https://api-ref.agora.io/en/video-sdk/unity/4.x/API/class_videosurface.html#class_videosurface)
* [`OnUserJoined`](https://api-ref.agora.io/en/video-sdk/unity/4.x/API/class_irtcengineeventhandler.html#callback_irtcengineeventhandler_onuserjoined)