Vivox Unity SDK 16.0.0 升级指南#

async void InitializeAsync()
{
    await UnityServices.InitializeAsync();
    await AuthenticationService.Instance.SignInAnonymouslyAsync();
    await VivoxService.Instance.InitializeAsync();
}

async void InitializeAsync()
{
    await UnityServices.InitializeAsync();
    await VivoxService.Instance.InitializeAsync();
}

async void InitializeAsync()
{
    InitializationOptions options = new InitalizationOptions();
    // _key can be excluded from SetVivoxCredentials if an implementation of IVivoxTokenProvider has been provided to the SDK.
    options.SetVivoxCredentials(_server, _domain, _issuer, _key);
    await UnityServices.InitializeAsync(options);
    await VivoxService.Instance.InitializeAsync();
}

async void LoginToVivoxAsync(List<string> blockedList, string displayName)
{
    LoginOptions options = new LoginOptions();
    options.DisplayName = displayName;
    options.BlockedUserList = blockedList;
    await VivoxService.Instance.LoginAsync(options);
}

void Start()
{
    VivoxService.Instance.LoggedIn += OnUserLoggedIn;
    VivoxService.Instance.LoggedOut += OnUserLoggedOut;
}

void OnDestroy()
{
    //Cleanup events if the GameObject is destroyed to prevent unexpected behavior.
    VivoxService.Instance.LoggedIn -= OnUserLoggedIn;
    VivoxService.Instance.LoggedOut -= OnUserLoggedOut;
}

void OnUserLoggedIn()
{
    Debug.Log("The user has successfully logged in");
    // Other logic such as attempting a default channel join or changing the state of voice UIs to indicate the character is logged in can be done here.
}


void OnUserLoggedOut()
{
    Debug.Log("The user has logged out");
    // The LoggedOut event will fire after a VivoxService.Instance.LogoutAsync call has been completed successfully
    // or after an internet disruption has caused Automatic Connection Recovery to declare the attempted recovery a failure.
}

void BindToChannelActions()
{
    //Connecting/Disconnecting channel actions can be done upon VivoxService.Instance.LoggedIn and LoggedOut events being fired, respectively,
    //for basic lifecycle control
    VivoxService.Instance.ChannelJoined += OnChannelJoined;
    VivoxService.Instance.ChannelLeft += OnChannelLeft;
}

void UnbindChannelActions()
{
    VivoxService.Instance.ChannelJoined -= OnChannelJoined;
    VivoxService.Instance.ChannelLeft -= OnChannelLeft;
}

void OnChannelJoined(string channelName)
{
    //The channel with name channelName has been successfully joined, and any UI updates should be done for it
    //Additionally, if multiple channels are being handled, keeping track of the channelName and knowing which channel is for which purpose should be done
    //on the side of the implementation based on this event.
}

void OnChannelLeft(string channelName)
{
    //The channel with name channelName has been successfully left, and any UI updates should be done for it
    //This also means that the channelName can likely be safely lost, although if the channelName is specific and might be rejoined,
    //it should be held on to by the implementation.
}

void BindToParticipantEvents()
{
    //These events can be connected at the same time as the channel events from the previous sections for convenience purposes
    VivoxService.Instance.ParticipantAddedToChannel += OnParticipantAdded;
    VivoxService.Instance.ParticipantRemovedFromChannel += OnParticipantRemoved;
}

void UnbindParticipantEvents()
{
    VivoxService.Instance.ParticipantAddedToChannel -= OnParticipantAdded;
    VivoxService.Instance.ParticipantRemovedFromChannel -=OnParticipantRemoved;
}

void OnParticipantAdded(VivoxParticipant participant)
{
    // Use VivoxParticipant to establish some UI element tied to that specific VivoxParticipant, which can then be used to control things such as muting
    // volume, and blocking, along with UI that can track certain states - such as whether the player is currently muted or is currently speaking.
}


void OnParticipantRemoved(VivoxParticipant participant)
{
    // At this point, any UI created to display information about this VivoxParticipant can be safely disposed of.
}

public class RosterItem : MonoBehaviour
{
    public VivoxParticipant Participant;
    public Text PlayerNameText;


    public void SetupRosterItem(VivoxParticipant participant)
    {
        Participant = participant;
        PlayerNameText.text = Participant.DisplayName;
        Participant.ParticipantMuteStateChanged += OnMuteStateChanged;
        Participant.ParticipantSpeechDetected += OnSpeechDetected;
    }

    void OnMuteStateChanged()
    {
        if(Participant.IsMuted)
        {
            //Participant has been muted
        }
        else
        {
            //Participant has been unmuted
        }
    }

    void OnSpeechDetected()
    {
        //Participant AudioEnergy has exceeded the value required to be considered speech
    }
}

using System.Linq;
using Unity.Services.Vivox;
using UnityEngine;
using UnityEngine.UI;


public class AudioDeviceSettings : MonoBehaviour
{
    public Dropdown InputDeviceDropdown;

    private void Start()
    {
        VivoxService.Instance.AvailableInputDevicesChanged += RefreshInputDeviceList;
        InputDeviceDropdown.onValueChanged.AddListener((i) =>
        {
            InputDeviceValueChanged(i);
        });
    }


    void OnEnable()
    {
        RefreshInputDeviceList();
    }


    void OnDestroy()
    {
        // Unbind all UI actions
        InputDeviceDropdown.onValueChanged.RemoveAllListeners();
        VivoxService.Instance.AvailableInputDevicesChanged -= RefreshInputDeviceList;
    }

    private void RefreshInputDeviceList()
    {
        InputDeviceDropdown.Hide();
        InputDeviceDropdown.ClearOptions();
        InputDeviceDropdown.options.AddRange(VivoxService.Instance.AvailableInputDevices.Select(v => new Dropdown.OptionData() { text = v.DeviceName }));
        InputDeviceDropdown.SetValueWithoutNotify(InputDeviceDropdown.options.FindIndex(option => option.text == VivoxService.Instance.ActiveInputDevice.DeviceName));
        InputDeviceDropdown.RefreshShownValue();
    }

    void InputDeviceValueChanged(int index)
    {
        VivoxService.Instance.SetActiveInputDeviceAsync(VivoxService.Instance.AvailableInputDevices.Where(device => device.DeviceName == InputDeviceDropdown.options[index].text).First());
    }
}