Use Relay with UTP#

await UnityServices.InitializeAsync();

public async void OnSignIn()
{
    	await  AuthenticationService.Instance.SignInAnonymouslyAsync();
    	playerId = AuthenticationService.Instance.PlayerId;

    	Debug.Log($"Signed in. Player ID: {playerId}");
}

void UpdateHost()
{
    	// Skip update logic if the Host isn't yet bound.
    	if (!hostDriver.IsCreated || !hostDriver.Bound)
    	{
        	return;
    	}

    	// This keeps the binding to the Relay server alive,
    	// preventing it from timing out due to inactivity.
    	hostDriver.ScheduleUpdate().Complete();

    	// Clean up stale connections.
    	for (int i = 0; i < serverConnections.Length; i++)
    	{
        	if (!serverConnections[i].IsCreated)
        	{
            	Debug.Log("Stale connection removed");
            	serverConnections.RemoveAt(i);
            	--i;
        	}
    	}

    	// Accept incoming client connections.
    	NetworkConnection incomingConnection;
    	while ((incomingConnection = hostDriver.Accept()) != default(NetworkConnection))
    	{
        	// Adds the requesting Player to the serverConnections list.
        	// This also sends a Connect event back the requesting Player,
        	// as a means of acknowledging acceptance.
        	Debug.Log("Accepted an incoming connection.");
        	serverConnections.Add(incomingConnection);
    	}

    	// Process events from all connections.
    	for (int i = 0; i < serverConnections.Length; i++)
    	{
        	Assert.IsTrue(serverConnections[i].IsCreated);

        	// Resolve event queue.
        	NetworkEvent.Type eventType;
        	while ((eventType = hostDriver.PopEventForConnection(serverConnections[i], out var stream)) != NetworkEvent.Type.Empty)
        	{
            	switch (eventType)
            	{
                	// Handle Relay events.
                	case NetworkEvent.Type.Data:
                    	FixedString32Bytes msg = stream.ReadFixedString32();
                    	Debug.Log($"Server received msg: {msg}");
                    	hostLatestMessageReceived = msg.ToString();
                    	break;

                	// Handle Disconnect events.
                	case NetworkEvent.Type.Disconnect:
                    	Debug.Log("Server received disconnect from client");
                    	serverConnections[i] = default(NetworkConnection);
                    	break;
            	}
        	}
    	}
}

public async void OnAllocate()
{
    	Debug.Log("Host - Creating an allocation. Upon success, I have 10 seconds to BIND to the Relay server that I've allocated.");

    	// Determine region to use (user-selected or auto-select/QoS)
    	string region = GetRegionOrQosDefault();
    	Debug.Log($"The chosen region is: {region ?? autoSelectRegionName}");

    	// Set max connections. Can be up to 100, but note the more players connected, the higher the bandwidth/latency impact.
    	int maxConnections = 4;

    	// Important: After the allocation is created, you have ten seconds to BIND, else the allocation times out.
    	hostAllocation = await RelayService.Instance.CreateAllocationAsync(maxConnections, region);
    	Debug.Log($"Host Allocation ID: {hostAllocation.AllocationId}, region: {hostAllocation.Region}");

    	// Initialize NetworkConnection list for the server (Host).
    	// This list object manages the NetworkConnections which represent connected players.
    	serverConnections = new NativeList<NetworkConnection>(maxConnections, Allocator.Persistent);
}

public void OnBindHost()
{
    	Debug.Log("Host - Binding to the Relay server using UTP.");

    	// Extract the Relay server data from the Allocation response.
    	var relayServerData = new RelayServerData(hostAllocation, "udp");

    	// Create NetworkSettings using the Relay server data.
    	var settings = new NetworkSettings();
    	settings.WithRelayParameters(ref relayServerData);

    	// Create the Host's NetworkDriver from the NetworkSettings.
    	hostDriver = NetworkDriver.Create(settings);

    	// Bind to the Relay server.
    	if (hostDriver.Bind(NetworkEndPoint.AnyIpv4) != 0)
    	{
        	Debug.LogError("Host client failed to bind");
    	}
    	else
    	{
        	if (hostDriver.Listen() != 0)
        	{
            	Debug.LogError("Host client failed to listen");
        	}
        	else
        	{
            	Debug.Log("Host client bound to Relay server");
        	}
    	}
}

public async void OnJoinCode()
{
    	Debug.Log("Host - Getting a join code for my allocation. I would share that join code with the other players so they can join my session.");

    	try
    	{
        	joinCode = await RelayService.Instance.GetJoinCodeAsync(hostAllocation.AllocationId);
        	Debug.Log("Host - Got join code: " + joinCode);
    	}
    	catch (RelayServiceException ex)
    	{
        	Debug.LogError(ex.Message + "\n" + ex.StackTrace);
    	}
}

void UpdatePlayer()
{
    	// Skip update logic if the Player isn't yet bound.
    	if (!playerDriver.IsCreated || !playerDriver.Bound)
    	{
        	return;
    	}

    	// This keeps the binding to the Relay server alive,
    	// preventing it from timing out due to inactivity.
    	playerDriver.ScheduleUpdate().Complete();

    	// Resolve event queue.
    	NetworkEvent.Type eventType;
    	while ((eventType = clientConnection.PopEvent(playerDriver, out var stream)) != NetworkEvent.Type.Empty)
    	{
        	switch (eventType)
        	{
            	// Handle Relay events.
            	case NetworkEvent.Type.Data:
                	FixedString32Bytes msg = stream.ReadFixedString32();
                	Debug.Log($"Player received msg: {msg}");
                	playerLatestMessageReceived = msg.ToString();
                	break;

            	// Handle Connect events.
            	case NetworkEvent.Type.Connect:
                	Debug.Log("Player connected to the Host");
                	break;

            	// Handle Disconnect events.
            	case NetworkEvent.Type.Disconnect:
                	Debug.Log("Player got disconnected from the Host");
                	clientConnection = default(NetworkConnection);
                	break;
        	}
    	}
}

public async void OnJoin()
{
    	// Input join code in the respective input field first.
    	if (String.IsNullOrEmpty(JoinCodeInput.text))
    	{
        	Debug.LogError("Please input a join code.");
        	return;
    	}

    	Debug.Log("Player - Joining host allocation using join code. Upon success, I have 10 seconds to BIND to the Relay server that I've allocated.");

    	try
    	{
        	playerAllocation = await RelayService.Instance.JoinAllocationAsync(JoinCodeInput.text);
        	Debug.Log("Player Allocation ID: " + playerAllocation.AllocationId);
    	}
    	catch (RelayServiceException ex)
    	{
        	Debug.LogError(ex.Message + "\n" + ex.StackTrace);
    	}
}

public void OnBindPlayer()
{
    	Debug.Log("Player - Binding to the Relay server using UTP.");

    	// Extract the Relay server data from the Join Allocation response.
    	var relayServerData = new RelayServerData(playerAllocation, "udp");
    	// Create NetworkSettings using the Relay server data.
    	var settings = new NetworkSettings();
    	settings.WithRelayParameters(ref relayServerData);

    	// Create the Player's NetworkDriver from the NetworkSettings object.
    	playerDriver = NetworkDriver.Create(settings);

    	// Bind to the Relay server.
    	if (playerDriver.Bind(NetworkEndPoint.AnyIpv4) != 0)
    	{
        	Debug.LogError("Player client failed to bind");
    	}
    	else
    	{
        	Debug.Log("Player client bound to Relay server");
    	}
}

public void OnConnectPlayer()
{
    	Debug.Log("Player - Connecting to Host's client.");
    	// Sends a connection request to the Host Player.
    	clientConnection = playerDriver.Connect();
}

public void OnHostSendMessage()
{
    	if (serverConnections.Length == 0)
    	{
        	Debug.LogError("No players connected to send messages to.");
        	return;
    	}

    	// Get message from the input field, or default to the placeholder text.
    	var msg = !String.IsNullOrEmpty(HostMessageInput.text) ? HostMessageInput.text : HostMessageInput.placeholder.GetComponent<Text>().text;

    	// In this sample, we will simply broadcast a message to all connected clients.
    	for (int i = 0; i < serverConnections.Length; i++)
    	{
        	if (hostDriver.BeginSend(serverConnections[i], out var writer) == 0)
        	{
            	// Send the message. Aside from FixedString32, many different types can be used.
            	writer.WriteFixedString32(msg);
            	hostDriver.EndSend(writer);
        	}
    	}
}

public void OnPlayerSendMessage()
{
    	if (!clientConnection.IsCreated)
    	{
        	Debug.LogError("Player isn't connected. No Host client to send message to.");
        	return;
    	}

    	// Get message from the input field, or default to the placeholder text.
    	var msg = !String.IsNullOrEmpty(PlayerMessageInput.text) ? PlayerMessageInput.text : PlayerMessageInput.placeholder.GetComponent<Text>().text;
    	if (playerDriver.BeginSend(clientConnection, out var writer) == 0)
    	{
        	// Send the message. Aside from FixedString32, many different types can be used.
        	writer.WriteFixedString32(msg);
        	playerDriver.EndSend(writer);
    	}
}

public void OnDisconnectPlayers()
{
    	if (serverConnections.Length == 0)
    	{
        	Debug.LogError("No players connected to disconnect.");
        	return;
    	}

    	// In this sample, we will simply disconnect all connected clients.
    	for (int i = 0; i < serverConnections.Length; i++)
    	{
        	// This sends a disconnect event to the destination client,
        	// letting them know they're disconnected from the Host.
        	hostDriver.Disconnect(serverConnections[i]);

        	// Here, we set the destination client's NetworkConnection to the default value.
        	// It will be recognized in the Host's Update loop as a stale connection, and be removed.
        	serverConnections[i] = default(NetworkConnection);
    	}
}

public void OnDisconnect()
{
    	// This sends a disconnect event to the Host client,
    	// letting them know they're disconnecting.
    	playerDriver.Disconnect(clientConnection);

    	// We remove the reference to the current connection by overriding it.
    	clientConnection = default(NetworkConnection);
}