Start Interactive Live Video Streaming

People engage longer when they see, hear, and interact with each other. The Agora SDK enables you to embed real-time voice and video interaction in any app, on any device, anywhere.

This page shows the minimum code you need to add interactive live streaming standard into your app by using the Agora Video SDK.

Understand the tech

The following figure shows the workflow to integrate into your app in order to add Interactive Live Streaming Standard functionality.

As shown in the figure, the workflow for adding Interactive Live Streaming Standard in your project is as follows:

1. Set the client role and latency level
   Each user in an Interactive Live Streaming Standard channel is either a host or an audience member. Hosts publish streams to the channel, and the audience subscribe to the streams. When a user is an audience member, you can control the delay the user receives host streams using ClientRoleOptions.

2. Retrieve a token
   A token is the credential that authenticates a user when your app client joins a channel. In a test or production environment, your app client retrieves tokens from a server in your security infrastructure.

3. Join a channel
   Call joinChannel to create and join a channel. App clients that pass the same channel name join the same channel.

4. Publish and subscribe to audio and video in the channel
   After joining a channel, app clients with the role of the host can publish audio and video. For an auidence memeber to send audio and video, call setClientRole to switch the client role.

For an app client to join a channel, you need the following information:

• The App ID: A randomly generated string provided by Agora for identifying your app. You can get the App ID from Agora Console.
• The user ID: The unique identifier of a user. You need to specify the user ID yourself, and ensure that it is unique in the channel.
• A token: In a test or production environment, your app client retrieves tokens from a server in your security infrastructure. For this page, you use a temporary token with a validity period of 24 hours that you retrieve from Agora Console.
• The channel name: A string that identifies the channel for the live stream.

Prerequisites

• Microsoft Visual Studio 2017 or later
• A Windows device running Windows 7 or later
• A valid Agora account. (Sign up for free)
• An active Agora project with an App ID and a temporary token. For details, see Get Started with Agora.
  A computer with access to the internet. If your network has a firewall, follow the instructions in Firewall Requirements.

Set up the development environment

In this section, we will create a Windows project and integrate the SDK into the project.

Create a Windows project

Now, let's build a Windows project from scratch. Skip to Integrate the SDK if a Windows project already exists.

Integrate the SDK

Choose one of the following ways to add agora_rtc_sdk into the project according to the type of your Windows Forms App.

• .net core

  1. In Visual Studio, create a Windows Forms App .net core application.
  2. In Solution Explorer, right click Dependencies. Click Manage Nuget Packages > Browse, input agora_rtc_sdk, select the Latest stable SDK, and then click Install. The SDK is now added to your project.

• .net framework

  1. In Visual Studio, create a Windows Forms App .net framework application.
  2. In Solution Explorer, right click References. Click Manage Nuget Packages > Browse, input agora_rtc_sdk, select the Latest stable SDK, and then click Install. The SDK is now added to your project.

Implement the interactive live streaming

This section introduces how to use the Agora SDK to start the interactive live streaming. The following figure shows the API call sequence of the live streaming.

1. Create the UI

Create the user interface (UI) for the one-to-one video call in your project. Skip to Import the SDK if you already have a UI in your project.

If you are implementing an interactive video streaming, we recommend adding the following elements into the UI:

• The view of the host
• The exit button

2. Import the SDK

Add the following line to import the Agora SDK:

using agora.rtc;

3. Inherit IAgoraRtcEngineEventHandler

The C# SDK is developed upon C++. In this step, we create an AgoraRtcEventHandler class from IAgoraRtcEngineEventHandler for managing callback events:

class AgoraRtcEventHandler : IAgoraRtcEngineEventHandler
{
      public AgoraRtcEventHandler()
      {

      }
};

4. Initialize IRtcEngine

Create and initialize the IAgoraRtcEngine object before calling any other Agora APIs.

Call the CreateAgoraRtcEngine and Initialize methods, and pass in the App ID to initialize the IAgoraRtcEngine object.

You can also listen for callback events, such as when the local user joins or leaves the channel.

// Declare variables
IAgoraRtcEngine rtc_engine_ = null;
IAgoraRtcEngineEventHandler event_handler_ = null;

if (null == rtc_engine_)
{
    // Create rtc engine
    rtc_engine_ = AgoraRtcEngine.CreateAgoraRtcEngine();
}

RtcEngineContext context = new RtcEngineContext(appId);
// Initialize rtc engine
int ret = rtc_engine_.Initialize(context);
event_handler_ = new AgoraRtcEventHandler();

// Initialize the engine event handler
rtc_engine_.InitEventHandler(event_handler_);

// Enable video
rtc_engine_.EnableVideo();

5. Set the channel profile

After initializing the IAgoraRtcEngine object, call the SetChannelProfile method to set the channel profile as LIVE_BROADCASTING.

One IAgoraRtcEngine object uses one profile only. If you want to switch to another profile, release the current IAgoraRtcEngine object with the release method and create a new one before calling the SetChannelProfile method.

rtc_engine_.SetChannelProfile(CHANNEL_PROFILE_TYPE.CHANNEL_PROFILE_LIVE_BROADCASTING);

6. Set the client role and user level

In a live-streaming channel, you need to set the role and level of a user:

• The user role determines the permissions that the SDK grants to a user, such as permission to send local streams, receive remote streams, and push streams to a CDN address. A live-streaming channel has two user roles: host and audience. A host can both send and receive streams, but an audience member can only receive stream. The default role is audience.
• The user level determines the level of services that a user can enjoy within the permissions of the user's role. For example, an audience member can choose to receive remote streams with low latency or ultra low latency. Levels affect prices.

You may use the following steps to set the user role and level in your app:

1. Allow the end user to set the role as host or audience.

2. Call the SetClientRole method and set the role and options parameters according to the user's choice:

   • When you set role as BROADCASTER, set options as null. The latency between two hosts is < 400 ms.
   • When you set role as AUDIENCE, set the audienceLatencyLevel parameter in options as AUDIENCE_LATENCY_LEVEL_LOW_LATENCY. The latency from the host's client to the audience's client is 1500 ms - 2000 ms.

A LIVE_BROADCASTING channel has two client roles: BROADCASTER and AUDIENCE, and the default role is AUDIENCE. After setting the channel profile to LIVE_BROADCASTING, your app may use the following steps to set the client role:

• Allow the user to set the role as BROADCASTER or AUDIENCE.
• Call the SetClientRole method and pass in the client role set by the user.

Note that in the interactive live streaming, only the host can be heard and seen. If you want to switch the client role after joining the channel, call the SetClientRole method.

As an audience member:

ClientRoleOptions role_options = new ClientRoleOptions();
role_options.audienceLatencyLevel = AUDIENCE_LATENCY_LEVEL_TYPE.AUDIENCE_LATENCY_LEVEL_LOW_LATENCY;
rtc_engine_.SetClientRole(CLIENT_ROLE_TYPE.CLIENT_ROLE_AUDIENCE, role_options); 

As a host:

rtc_engine_.SetClientRole(CLIENT_ROLE_TYPE.CLIENT_ROLE_BROADCASTER);

7. Set the local video view

After initializing the IAgoraRtcEngine object, set the local video view before joining the channel so that hosts can see themselves.

VideoCanvas vs = new VideoCanvas((ulong)localWindowId.Handle, RENDER_MODE_TYPE.RENDER_MODE_FIT);
rtc_engine_.SetupLocalVideo(vs);

8. Join a channel

After initializing the IAgoraRtcEngine object and setting the local video view, you can call the joinChannel method to join a live streaming channel. In this method, set the following parameters:

• channelName: Specify the channel name that you want to join.

• token: Pass a token that identifies the role and privilege of the user. You can set it as one of the following values:

  • A temporary token generated in Console. A temporary token is valid for 24 hours. For details, see Get a Temporary Token. When joining a channel, ensure that the channel name is the same with the one you use to generate the temporary token.
  • A token generated at the server. This applies to scenarios with high-security requirements. For details, see Generate a token from Your Server. When joining a channel, ensure that the channel name and uid is the same with those you use to generate the token.
  • If your project has enabled the app certificate, ensure that you provide a token.
  • Ensure that you do not set token as "".

• uid: ID of the local user that is an integer and should be unique. If you set uid as 0, the SDK assigns a user ID for the local user and returns it in the OnJoinChannelSuccess callback.

  Once the user joins the channel, the user subscribes to the audio and video streams of all the other users in the channel by default, giving rise to usage and billing calculation. If you do not want to subscribe to a specified stream or all remote streams, call the mute methods accordingly.

rtc_engine_.JoinChannel("", "testChannelId","", 0, new ChannelMediaOptions(true, true, true, true));

9. Set the remote video view

In a video streaming, you should be able to see all the hosts, regardless of your role. This is achieved by calling the SetupRemoteVideo method after joining the channel.

Shortly after a remote host joins the channel, the SDK gets the host's ID in the OnUserJoined callback. Call the SetupRemoteVideo method in the callback, and pass in the uid to set the video view of the remote host.

// Call SetupRemoteVideo to set the remote video view
VideoCanvas  vc = new VideoCanvas((ulong)remoteWindowId, 
RENDER_MODE_TYPE.RENDER_MODE_FIT, "testChannelId", remoteUid);
rtc_engine_.SetupRemoteVideo(vc);

10. Leave the channel

Call the LeaveChannel method to leave the current channel according to your scenario, for example, when the interactive streaming ends, when you need to close the app, or when your app runs in the background.

rtc_engine_.LeaveChannel();

Run the project

After building the app, follow the steps to add the necessary libraries to the execution path:

• For .netcore 64-bit apps, copy all the libraries under netCore/x86_64.
• For .netframework 32-bit apps, copy all the libraries under netFramework/x86.

Run the project on your Windows device. When you set the role as the host and successfully start the interactive video streaming, you can see the video view of yourself in the app. When you set the role as the audience and successfully join the interactive video streaming, you can see the video view of the host in the app.

Reference

Sample project

Agora provides an open-source JoinChannelVideo sample project on GitHub. You can try it out or view the source code.

FAQ

• How can I set the log file?
• How can I solve black screen issues?
• How can I implement call notification in a call application?