using System;

using System.Threading.Tasks;

using FM.LiveSwitch;

​

public class Program

{

    public async static Task Main()

    {

        Console.WriteLine("What room would you like to join (or enter 'q' to quit)?");

        var response = Console.ReadLine();

        if (response.Length == 0 || response == "q")

        {

            return;

        }

        // Enable for LiveSwitch Client SDK logging

        // Log.RegisterProvider(new ConsoleLogProvider(LogLevel.Debug));

        var liveSwitchClient = new LiveSwitchClient();

​

        liveSwitchClient.OnRemoteClientJoined += (clientId) =>

        {

            Console.WriteLine($"Client {clientId} joined");

        };

​

        liveSwitchClient.OnRemoteClientMessageReceived += (clientId, message) =>

        {

            Console.WriteLine($"Message received: {message} ({clientId})");

        };

​

        await liveSwitchClient.RegisterAndJoinAsync(response);

        Console.WriteLine("Message to send");

        do

        {

            response = Console.ReadLine();

            if (response.Length == 0 || response == "q")

            {

                break;

            }

            else

            {

                await liveSwitchClient.SendMessage(response);

                Console.WriteLine("Message to send");

            }

        }

        while (true);

    }

}

​

public class LiveSwitchClient

{

    public event Action1<string> OnRemoteClientJoined; // clientId

    public event Action2<string, string> OnRemoteClientMessageReceived; // clientId, message

​

    private const string GatewayURL = "https://demo.liveswitch.fm:8443/sync";

    private const string ApplicationId = "my-app-id";

    private const string SharedSecret = "--replaceThisWithYourOwnSharedSecret--";

​

    private string ChannelId { get; set; }

    private Client Client { get; set; }

    private Channel Channel { get; set; }

    private SfuUpstreamConnection SfuUpstreamConnection { get; set; }

    private DataChannel DataChannel { get; set; }

    public async Task RegisterAndJoinAsync(string channelId)

    {

        ChannelId = channelId;

        Client = new Client(GatewayURL, ApplicationId);

        ChannelClaim[] channelClaims = new[] { new ChannelClaim(ChannelId) };

        string token = Token.GenerateClientRegisterToken(

            ApplicationId,

            Client.UserId,

            Client.DeviceId,

            Client.Id,

            null,

            channelClaims,

            SharedSecret

        );

​

        var channels = await Client.Register(token).AsTask();

        await OnClientRegistered(channels);

        await OpenSfuUpstreamConnection();

    }

    public async Task SendMessage(string message)

    {

        await DataChannel.SendDataString(message).AsTask();

    }

​

    private async Task OnClientRegistered(Channel[] channels)

    {

        Channel = channels[0];

        foreach (var remoteConnectionInfo in Channel.RemoteUpstreamConnectionInfos)

        {

            await OpenSfuDownstreamConnection(remoteConnectionInfo);

        }

        Channel.OnRemoteUpstreamConnectionOpen += async (remoteConnectionInfo) =>

        {

            Console.WriteLine("Remote upstream connection opened");

            await OpenSfuDownstreamConnection(remoteConnectionInfo);

        };

    }

    private async Task OpenSfuUpstreamConnection()

    {

        DataChannel = new DataChannel("data");

        DataStream dataStream = new DataStream(DataChannel);

        SfuUpstreamConnection = Channel.CreateSfuUpstreamConnection(null, null, dataStream);

        await SfuUpstreamConnection.Open().AsTask();

    }

    private async Task OpenSfuDownstreamConnection(ConnectionInfo remoteConnectionInfo)

    {

        Console.WriteLine("Opening sfu downstream connection");

        SfuDownstreamConnection connection;

​

        DataChannel dataChannel = null;

        DataStream dataStream = null;

        if (remoteConnectionInfo.HasData)

        {

            dataChannel = new DataChannel("data")

            {

                OnReceive = (e) =>

                {

                    Console.WriteLine("OnReceive");

                    OnRemoteClientMessageReceived?.Invoke(remoteConnectionInfo.ClientId, e.DataString);

                }

            };

            dataStream = new DataStream(dataChannel);

        }

        connection = Channel.CreateSfuDownstreamConnection(remoteConnectionInfo, null, null, dataStream);

        await connection.Open().AsTask();

        OnRemoteClientJoined?.Invoke(remoteConnectionInfo.ClientId);

    }

}

​