Net.Agora.Video 4.6.2.2

Net.Agora

.NET bindings for Agora's native SDKs, with one API across Android and iOS. Join RTC channels, publish and subscribe audio and video, from C# — in .NET MAUI or plain .NET for Android / .NET for iOS.

Built on Net.Agora.iOS and Net.Agora.Android, which bind the native SDKs. This repository binds nothing itself — see How this repository works.

dotnet add package Net.Agora.Video.Maui   # MAUI video apps: adds the video view
dotnet add package Net.Agora.Video        # video, everything else
dotnet add package Net.Agora.Voice.Maui   # MAUI voice-only apps
dotnet add package Net.Agora.Voice        # voice-only, everything else

var client = new AgoraVideoOptions { AppId = "your-app-id" }.CreateClient();

client.SetLocalView(LocalView);          // a <agora:AgoraVideoView /> from your XAML
client.UserJoined += (_, e) => client.SetRemoteView(e.Uid, RemoteView);

await client.JoinAsync("my-channel");    // completes when the server confirms

Both clients carry the call essentials — speakerphone routing, who-is-speaking reports, remote mute state, connection lifecycle events, token renewal — and the video client adds the camera half (preview, flip, remote video mute). Voice-only apps get all of it over native artifacts that carry no video codecs at all:

var client = new AgoraVoiceOptions { AppId = "your-app-id", DefaultToSpeakerphone = true }.CreateClient();

client.VolumeIndication += (_, e) => ShowSpeakers(e.Speakers);   // uid 0 is you
client.EnableVolumeIndication(TimeSpan.FromMilliseconds(200));

await client.JoinAsync("my-room");
client.SetSpeakerphone(false);           // switch the live route mid-call

Pick one product per app: Video already carries the full audio surface, and the two products' native artifacts collide (same Java classes on Android, same AgoraRtcKit framework on iOS).

Status

This repository covers Agora's Video and Voice SDKs, wired end to end: the raw Android/iOS bindings (in the two sibling repositories above), the cross-platform clients, the MAUI packages, package tests, sample apps, CI. See docs/BUILD.md for the exact state.

How this repository works

Three repositories, each independently versioned and released:

• Net.Agora.Android — the raw Android bindings (Agora.Rtc.*, generated from io.agora.rtc:full-rtc-basic / voice-rtc-basic).
• Net.Agora.iOS — the raw iOS bindings (Net.Agora.Video.iOS.* / Net.Agora.Voice.iOS.*, hand-written against AgoraRtcEngineKit).
• Net.Agora (this repository) — the façades. Each façade package depends on its two platform packages at an exact pinned version (NetAgora<Product><Platform>Version in Directory.Build.props) the same way any consumer would, restored from nuget.org. It contains no ApiDefinition.cs, no native artifact, no AndroidLibrary/NativeReference — see docs/BUILD.md.

Without MAUI

Net.Agora.Video.Maui only adds the video view and the platform glue. A plain .NET for Android or .NET for iOS app needs none of that — reference Net.Agora.Video and use the same AgoraVideoClient, with the platform's own view type instead of AgoraVideoView:

dotnet add package Net.Agora.Video

Android — the SDK renders into a plain Android.Views.SurfaceView, and the client needs the Context:

using Net.Agora.Video;
using Android.App;
using Android.OS;
using Android.Views;

[Activity(Label = "Publisher", MainLauncher = true)]
public class MainActivity : Activity
{
    private AgoraVideoClient? _client;
    private SurfaceView? _preview;

    protected override async void OnCreate(Bundle? savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        _preview = new SurfaceView(this);
        SetContentView(_preview);

        var options = new AgoraVideoOptions { AppId = "your-app-id" };

        // The Context is the one thing the Android SDK cannot work out for itself.
        // Net.Agora.Video.Maui is what supplies it in a MAUI app.
        _client = new AgoraVideoClient(options, this);
        _client.SetLocalView(_preview);
        _client.EnableVideo();

        _client.UserJoined += (_, e) => Log.Info("app", $"remote user joined: {e.Uid}");
        _client.Error += (_, e) => Log.Error("app", e.Message);

        await _client.JoinAsync("my-channel");
    }

    protected override void OnDestroy()
    {
        // Releases the camera and the engine; managed collection alone does not.
        _client?.Dispose();
        base.OnDestroy();
    }
}

iOS — a plain UIView, and the client takes no platform handle at all:

using System;
using Net.Agora.Video;
using UIKit;

public class ChannelViewController : UIViewController
{
    private AgoraVideoClient? _client;

    public override async void ViewDidAppear(bool animated)
    {
        base.ViewDidAppear(animated);

        var options = new AgoraVideoOptions { AppId = "your-app-id" };

        _client = new AgoraVideoClient(options);

        // Any UIView will do — the SDK adds its own renderer as a subview.
        _client.SetLocalView(View!);
        _client.EnableVideo();

        _client.UserJoined += (_, e) => Console.WriteLine($"remote user joined: {e.Uid}");
        _client.Error += (_, e) => Console.WriteLine($"error: {e.Message}");

        await _client.JoinAsync("my-channel");
    }

    public override void ViewDidDisappear(bool animated)
    {
        _client?.Dispose();
        _client = null;
        base.ViewDidDisappear(animated);
    }
}

Both snippets create the client once the view exists rather than in a constructor — on Android the Context route (Platform.CurrentActivity) is not reliably usable before OnCreate, and on Apple the view has no window before ViewDidAppear.

Capture permissions are the app's own responsibility either way: CAMERA and RECORD_AUDIO in AndroidManifest.xml, NSCameraUsageDescription and NSMicrophoneUsageDescription in Info.plist.

Packages

Each package pulls in the one below it, so a single reference is enough. Drop to a platform binding directly for anything the cross-platform API does not expose — the full bound surface is under Agora.Rtc.* (Android) and Net.Agora.Video.iOS.* (a hand-written subset — see each repository's own README).

No Mac Catalyst: Agora's iOS SDK ships no maccatalyst slice (ios-arm64 and simulator only).

Why there is a cross-platform layer

Android's RtcEngine is a Java abstract class overridden with a 100+ method event-handler class; iOS's AgoraRtcEngineKit takes an Objective-C delegate. Written against the bindings directly, an app targeting both needs a real per-platform adapter before it can join a channel. Net.Agora.Video is that adapter, so you do not write it.

The sample is the evidence: samples/Net.Agora.Sample joins a channel and renders local/remote video with no per-platform code at all.

Building

See docs/BUILD.md. In short, the platform packages are built in their own repositories:

# In sbokatuk/Net.Agora.Android:
./build/BuildNugets.sh

# In sbokatuk/Net.Agora.iOS:
./build/fetch-video.sh
./build/BuildNugets.sh

Then, in this repository, pointing NuGet.config's local-artifacts source at wherever those two were packed (or once both are published, straight from nuget.org):

./build/BuildNugets.sh video

Licence

MIT — see LICENSE. The bundled Agora SDKs are Agora's own, distributed under their own terms via Maven Central and CocoaPods respectively.