Use case: Integrate authentication in your scene

This section explains how to set up your scene to integrate an authentication layer to communicate with Unity Cloud services.

Before you start

• Follow the Installation instructions.
• Follow the Get started instructions.
• Follow the Best practices: dependency injection guide.

How do I...?

Instantiate a CompositeAuthenticator in PlatformServices

To instantiate a CompositeAuthenticator in the PlatformServices class, follow these steps:

1. Use the CompositeAuthenticatorSettingsBuilder to build a prioritized list of supported IAuthenticator.
2. Create an instance of the CompositeAuthenticator using the CompositeAuthenticatorSettings as argument.
3. Add the following references of the created instance of the CompositeAuthenticator:
1. A private read-only reference
2. A public reference as ICompositeAuthenticator, IAuthenticationStateProvider and IAccessTokenProvider
4. Initialize the CompositeAuthenticator and any other services in the InitializeAsync method.
5. Shutdown the CompositeAuthenticator and any other services in the Shutdown method.

public static class PlatformServices
{
    static CompositeAuthenticator s_CompositeAuthenticator;

    public static ICompositeAuthenticator CompositeAuthenticator => s_CompositeAuthenticator;

    public static IServiceAuthorizer serviceAuthorizer => s_CompositeAuthenticator;

    public static async Task InitializeAsync()
    {
        var playerSettings = UnityCloudPlayerSettings.Instance;
        var httpClient = new UnityHttpClient();
        var serviceHostResolver = UnityRuntimeServiceHostResolverFactory.Create();

        var compositeAuthenticatorSettings = new CompositeAuthenticatorSettingsBuilder(httpClient, PlatformSupportFactory.GetAuthenticationPlatformSupport(), serviceHostResolver, playerSettings)
            .AddDefaultBrowserAuthenticatedAccessTokenProvider(playerSettings)
            .AddDefaultPkceAuthenticator(playerSettings)
            .Build();

        s_CompositeAuthenticator = new CompositeAuthenticator(compositeAuthenticatorSettings);

        await s_CompositeAuthenticator.InitializeAsync();
    }

    public static void Shutdown()
    {
        s_CompositeAuthenticator = null;
    }

 }

Tie the CompositeAuthenticator with UI

If your application needs to support the interactive login flow, create a login UI and link it to the IUrlRedirectionAuthenticator methods to achieve interactive login and logout.

Please note that if the CompositeAuthenticatorSettings added automated flow or preauthenticated flow IAuthenticator, it's not guaranteed that the activated flow is interactive. This means some parts of the UI need to be hidden or disabled from code, depending on the situation. Validate this by checking the value of the ICompositeAuthenticator.RequiresGUI property when managing UI element.

1. Create Login and Logout buttons in your scene.



2. Create a LoginManager GameObject and attach a new LoginManager MonoBehaviour to it. This script links your UI with Identity's authentication engine.
3. Update the LoginManager script so it references your buttons and an IAuthenticationStateProvider.
4. Update the Awake method to do the following:
   1. Retrieve the CompositeAuthenticator reference from PlatformServices.
   2. Subscribe to the AuthenticationStateChanged event.
   3. Subscribe to the buttons' onClick events.
   4. Call ApplyAuthenticationState to update the UI when the scene loads.
5. Make sure the subscriptions are cleaned up in OnDestroy.
6. Implement the ApplyAuthenticationState method to update your buttons based on the current authentication state. Make your buttons interactive in specific circumstances, otherwise you risk errors and exceptions. To determine if you should display your buttons, rely on the AuthenticationState and the RequiresGUI property that determines whether the UI is relevant in the selected authentication flow.
7. Define the behaviors for your buttons by calling the appropriate methods.

Note: Only an interactive login flow (like the one exposed by the `IUrlRedirectionAuthenticator` interface) requires these methods. If the flow isn't interactive, calling `LoginAsync` or `LogoutAsync` throws exceptions.

8. Test your scene to see how the buttons update along with the authentication state of the user.

public class LoginManager : MonoBehaviour
{
    [SerializeField]
    Button m_LoginButton;

    [SerializeField]
    Button m_LogoutButton;


    ICompositeAuthenticator m_CompositeAuthenticator;

    void Awake()
    {
        m_CompositeAuthenticator = PlatformServices.CompositeAuthenticator;
        m_CompositeAuthenticator.AuthenticationStateChanged += ApplyAuthenticationState;

        m_LoginButton.onClick.AddListener(new UnityEngine.Events.UnityAction(OnLoginButtonClick));
        m_LogoutButton.onClick.AddListener(new UnityEngine.Events.UnityAction(OnLogoutButtonClick));
    }

    void Start()
    {
        ApplyAuthenticationState(m_CompositeAuthenticator.AuthenticationState);
    }

    void OnDestroy()
    {
        m_CompositeAuthenticator.AuthenticationStateChanged -= ApplyAuthenticationState;

        m_LoginButton.onClick.RemoveAllListeners();
        m_LogoutButton.onClick.RemoveAllListeners();
    }

    void ApplyAuthenticationState(AuthenticationState state)
    {
        switch (state)
        {
            case AuthenticationState.LoggedOut:
                m_LoginButton.interactable = m_CompositeAuthenticator.RequiresGUI;
                m_LogoutButton.interactable = false;
                break;
            case AuthenticationState.LoggedIn:
                m_LoginButton.interactable = false;
                m_LogoutButton.interactable = m_CompositeAuthenticator.RequiresGUI;
                break;
            case AuthenticationState.AwaitingInitialization:
            case AuthenticationState.AwaitingLogin:
            case AuthenticationState.AwaitingLogout:
                m_LoginButton.interactable = false;
                m_LogoutButton.interactable = false;
                break;
        }
    }

    async void OnLoginButtonClick()
    {
        await m_CompositeAuthenticator.LoginAsync();
    }

    async void OnLogoutButtonClick()
    {
        await m_CompositeAuthenticator.LogoutAsync();
    }
}

Leverage the authorization headers to communicate with other Unity Cloud services

After you set up your login flow, communication with other Unity Cloud services is possible. All Unity Cloud services expect an instance of IServiceAuthorizer to apply authorization information to HTTP requests, which the PlatformServices provides.

For an example of a service that expects an IServiceAuthorizer, refer to the Get user information guide.