Colocation Discovery

<uses-permission android:name="com.oculus.permission.USE_COLOCATION_DISCOVERY_API" android:required="true" />

public static OVRTask<OVRResult<Guid, Result>> StartAdvertisementAsync(ReadOnlySpan<byte> colocationSessionData)

byte[] advertisementData = new byte[] {8, 12, 22};
var startAdvertisementResult = await OVRColocationSession.StartAdvertisementAsync(advertisementData);
if (startAdvertisementResult.Success)
{
    Debug.Log("StartAdvertisement was Successful!");
    var advertisementUUID = startAdvertisementResult.Value;
    Debug.Log($"Advertisement UUID is {advertisementUUID}");
}
else
{
    Debug.Log($"StartAdvertisement failed with error code {startAdvertisementResult.Status}");
}

public static OVRTask<OVRResult<Result>> StopAdvertisementAsync()

var result = await OVRColocationSession.StopAdvertisementAsync();
Debug.Log($"Finished getting result of StopAdvertisementAsync {result.Status}");

public static OVRTask<OVRResult<Result>> StartDiscoveryAsync()

public static event Action<Data> ColocationSessionDiscovered;

private void OnColocationSessionDiscovered(OVRColocationSession.Data session)
{
    Debug.Log($"The advertisement UUID is: {session.AdvertisementUuid}");
    Debug.Log($"Data for session is {session.Metadata}");
}

OVRColocationSession.ColocationSessionDiscovered += OnColocationSessionDiscovered;

var startDiscoveryResult = await OVRColocationSession.StartDiscoveryAsync();
Debug.Log($"We finished awaiting StartDiscoveryAsync to finish status: {result.Status}");

public static OVRTask<OVRResult<Result>> StopDiscoveryAsync()

var stopDiscoveryResult = await OVRColocationSession.StopDiscoveryAsync();
Debug.Log($"Stopped Discovery Async result is {stopDiscoveryResult.Status}");

[System.Serializable]
public struct ColocationSessionData
{
    public string roomName;
    public string ipAddress;
}

public static class SerializationUtils
{
    public static byte[] SerializeToByteArray<T>(T obj)
        where T : new()
    {
        // NOTE: Using JSON as an intermediate protocol is fairly inefficient at runtime compared to a more direct
        // protocol, but it is safe, and the code is brief for the sake of this example.
        var json = JsonUtility.ToJson(obj, prettyPrint: false) ?? "{}";
        return s_Encoding.GetBytes(json);
    }

    public static T DeserializeFromByteArray<T>(byte[] data)
        where T : new()
    {
        var json = s_Encoding.GetString(data);
        return JsonUtility.FromJson<T>(json);
    }

    // UTF8 is best for serialization, and we want to omit the default BOM:
    static readonly Encoding s_Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
}

public async void Example_Host_Flow()
{
    // Creates the data that will be advertised (Note: ColocationSessionData is a user-defined struct)
    var colocationSessionData = new ColocationSessionData()
    {
        roomName = "Lambo The Rabbit Room",
        ipAddress = "127.0.0.1"
    };

    // Note: SerializationUtils is a user-defined class
    var byteArrayData = SerializationUtils.SerializeToByteArray(colocationSessionData);

    // advertises a newly created session with the room name data
    var startAdvertisementResult = await OVRColocationSession.StartAdvertisementAsync(byteArrayData);
    if (startAdvertisementResult.Success)
    {
        Debug.Log($"Starting the Advertisement was successful with code: {startAdvertisementResult.Status.ToString()}");
    }
    else
    {
        Debug.LogError($"Starting the Advertisement failed with error code: {startAdvertisementResult.Status.ToString()}");
    }
}

public async void Example_Discover_Flow()
{
    // registers a callback function for when we discover a colocation session
    OVRColocationSession.ColocationSessionDiscovered += OnColocationSessionDiscovered;

    // starts discovering session
    var startDiscoveryResult = await OVRColocationSession.StartDiscoveryAsync();
    if (startDiscoveryResult.Success)
    {
        Debug.Log($"Starting discovery was successful with code: {startDiscoveryResult.Status.ToString()}");
    }
    else
    {
        Debug.LogError($"Starting discovery failed with error code: {startDiscoveryResult.Status.ToString()}");
    }
}

// when a colocation session is discovered, OnColocationSessionDiscover will be invoked
private void OnColocationSessionDiscovered(OVRColocationSession.Data data)
{
    // deserializes the byte array into ColocationSessionData
    var colocationSessionData = SerializationUtils.DeserializeFromByteArray<ColocationSessionData>(data.Metadata);
    Debug.Log($"The room name is {colocationSessionData.roomName}");
    Debug.Log($"The IP Address is {colocationSessionData.ipAddress}");

    // at this point, having the ipAddress is enough data for the client to connect to the host's server
    // YourNetcodeUsed.Join(colocationSessionData.ipAddress);
}