Quickstart

using System;
using StreamVideo.Core;
using StreamVideo.Libs.Auth;
using UnityEngine;

public class VideoClient : MonoBehaviour
{
    async void Start()
    {
        _client = StreamVideoClient.CreateDefaultClient();

        try
        {
            var authCredentials = new AuthCredentials("api-key", "user-id", "user-token");
            await _client.ConnectUserAsync(authCredentials);

            // After the await ConnectUserAsync task completes, the client is connected
        }
        catch (Exception e)
        {
            Debug.LogError(e.Message);
        }
    }

    private IStreamVideoClient _client;
}

var callType = StreamCallType.Default; // Call type affects default permissions
var callId = "my-call-id";

// Notice that we pass create argument as true - this will create the call if it doesn't already exist
var streamCall = await _client.JoinCallAsync(callType, callId, create: true, ring: true, notify: false);

var callType = StreamCallType.Default; // Call type affects default permissions
var callId = "my-call-id";

// Notice that we pass create argument as false - if the call doesn't exist the join attempt will fail
var streamCall = await _client.JoinCallAsync(callType, callId, create: false, ring: true, notify: false);

var microphones = _client.AudioDeviceManager.EnumerateDevices();

foreach (var mic in microphones)
{
    Debug.Log(mic.Name);
}

var firstMicrophone = microphones.First();

// Select microphone device to capture audio input. `enable` argument determines whether audio capturing should start
_client.AudioDeviceManager.SelectDevice(firstMicrophone, enable: true);

// Start audio capturing
_client.AudioDeviceManager.Enable();

// Stop audio capturing
_client.AudioDeviceManager.Disable();

var cameras = _client.VideoDeviceManager.EnumerateDevices();

foreach (var cam in cameras)
{
    Debug.Log(cam.Name);
}

var firstCamera = cameras.First();

// Select camera device to capture video input. `enable` argument determines whether video capturing should start
_client.VideoDeviceManager.SelectDevice(firstCamera, enable: true);

// Start video capturing
_client.VideoDeviceManager.Enable();

// Stop video capturing
_client.VideoDeviceManager.Disable();

var callType = StreamCallType.Default; // Call type affects default permissions
var callId = "my-call-id";

var streamCall = await _client.JoinCallAsync(callType, callId, create: false, ring: true, notify: false);

// Subscribe to events to get notified that streamCall.Participants collection changed
streamCall.ParticipantJoined += OnParticipantJoined;
streamCall.ParticipantLeft += OnParticipantLeft;

// Iterate through current participants, participant is an object of type IStreamVideoCallParticipant
foreach (var participant in streamCall.Participants)
{
    // Handle participant logic. For example: create a view for each participant
}

var callType = StreamCallType.Default; // Call type affects default permissions
var callId = "my-call-id";

// JoinCall to get a IStreamCall object. You can also call _client.GetOrCreateCallAsync or _client.GetCallAsync
var streamCall = await _client.JoinCallAsync(callType, callId, create: false, ring: true, notify: false);

// Subscribe for participants change
streamCall.ParticipantJoined += OnParticipantJoined;
streamCall.ParticipantLeft += OnParticipantLeft;

// Process current participant
foreach (var participant in streamCall.Participants)
{
    // Handle currently available tracks
    foreach (var track in participant.GetTracks())
    {
        OnParticipantTrackAdded(participant, track);
    }

    // Subscribe to event in case new tracks are added
    participant.TrackAdded += OnParticipantTrackAdded;
}

private void OnParticipantTrackAdded(IStreamVideoCallParticipant participant, IStreamTrack track)
{
    switch (track)
    {
        case StreamAudioTrack streamAudioTrack:

            // This assumes that this gameObject contains the AudioSource component but it's not a requirement. You can obtain the AudioSource reference in your preferred way
            var audioSource = GetComponent<AudioSource>();

            // This AudioSource will receive audio from the participant
            streamAudioTrack.SetAudioSourceTarget(audioSource);
            break;

        case StreamVideoTrack streamVideoTrack:

            // This assumes that this gameObject contains the RawImage component but it's not a requirement. You can obtain the RawImage reference in your preferred way
            var rawImage = GetComponent<RawImage>();

            // This RawImage will receive video from the participant
            streamVideoTrack.SetRenderTarget(rawImage);
            break;
    }
}

public class VideoManager : MonoBehaviour
{
    public async Task JoinCallAsync(string callId, StreamCallType callType, bool create, bool ring, bool notify)
    {
        var streamCall = await _client.JoinCallAsync(callType, callId, create, ring, notify);

        // Subscribe to events to get notified that streamCall.Participants collection changed
        streamCall.ParticipantJoined += OnParticipantJoined;
        streamCall.ParticipantLeft += OnParticipantLeft;

        // Iterate through current participants
        foreach (var participant in streamCall.Participants)
        {
            // Handle participant logic. For example: create a view for each participant
            CreateParticipantView(participant);
        }
    }

    private void OnParticipantLeft(string sessionid, string userid)
    {
        // Try find view for this participant and destroy it because he left the call
        var viewInstance = _participantViews.FirstOrDefault(v => v.SessionId == sessionid);
        if (viewInstance != null)
        {
            // If the participant view was found -> destroy it
            Destroy(viewInstance.gameObject);
        }
    }

    private void OnParticipantJoined(IStreamVideoCallParticipant participant)
    {
        // Create view whenever new participant joins during the call
        CreateParticipantView(participant);
    }

    private void CreateParticipantView(IStreamVideoCallParticipant participant)
    {
        // Create new prefab instance for the view. In this example we'll add it as a child of this gameObject
        var viewInstance = Instantiate(_participantViewPrefab, transform);

        // Add to list so we can easily destroy it when a participant leaves the call
        _participantViews.Add(viewInstance);

        // Call ParticipantView.Init in order to process the participant tracks and subscribe to events
        viewInstance.Init(participant);
    }

    // Start() is called automatically by UnityEngine
    protected async void Start()
    {
        _client = StreamVideoClient.CreateDefaultClient();

        try
        {
            var authCredentials = new AuthCredentials("api-key", "user-id", "user-token");
            await _client.ConnectUserAsync(authCredentials);

            // After we awaited the ConnectUserAsync the client is connected
        }
        catch (Exception e)
        {
            Debug.LogError(e.Message);
        }
    }

    [SerializeField]
    private ParticipantView _participantViewPrefab;

    private IStreamVideoClient _client;
    private readonly List<ParticipantView> _participantViews = new List<ParticipantView>();
}

    public class ParticipantView : MonoBehaviour
    {
        // Call this method to setup view for a participant
        public void Init(IStreamVideoCallParticipant participant)
        {
            if (_participant != null)
            {
                Debug.LogError("Participant view already initialized.");
                return;
            }

            _participant = participant ?? throw new ArgumentNullException(nameof(participant));

            // Handle currently available tracks
            foreach (var track in _participant.GetTracks())
            {
                OnParticipantTrackAdded(_participant, track);
            }

            // Subscribe to event in case new tracks are added
            _participant.TrackAdded += OnParticipantTrackAdded;

            _name.text = _participant.Name;
        }

        public void OnDestroy()
        {
            // It's a good practice to unsubscribe from events when the object is destroyed
            if (_participant != null)
            {
                _participant.TrackAdded -= OnParticipantTrackAdded;
            }
        }

        [SerializeField]
        private Text _name; // This will show participant name

        [SerializeField]
        private RawImage _video; // This will show participant video

        [SerializeField]
        private AudioSource _audioSource; // This will play participant audio

        private IStreamVideoCallParticipant _participant;

        private void OnParticipantTrackAdded(IStreamVideoCallParticipant participant, IStreamTrack track)
        {
            switch (track)
            {
                case StreamAudioTrack streamAudioTrack:

                    // Set AudioSource component to be the target of the audio track
                    streamAudioTrack.SetAudioSourceTarget(_audioSource);
                    break;

                case StreamVideoTrack streamVideoTrack:

                    // Set RawImage component to be the target of the video track
                    streamVideoTrack.SetRenderTarget(_video);
                    break;
            }
        }
    }