[Idea] Move Receive() to it's own Listen() method

[divillysausages]

Current Receive() is called at the end of Connect(). This means that if you ever want to await the Connect() call (so that you move on when it's connected), it won't actually return until the socket is disconnected. Moving it to it's own Listen() method would allow for that.

Something like:

// Websocket.cs
// 1) Remove the "await Receive()" call from the end of Connect()
// 2) Add an empty Listen() method in the WebGL implementation for compatibility
// 3) Add the following method:
public async void Listen()
{
    try
    {
        await Receive();
    }
    catch (Exception ex)
    {
        OnError?.Invoke(ex.Message);
        OnClose?.Invoke(WebSocketCloseCode.Abnormal);
    }
    finally
    {
        if (m_Socket != null)
        {
            m_TokenSource.Cancel();
            m_Socket.Dispose();
        }
    }
}

This lets you handle the websocket connection like so:

// WebsocketConnection.cs
public async Task ConnectAsync( string uri )
{
    if( this.isOpen )
    {
        Debug.LogWarning( "[WebSocketConnection] Trying to connect a websocket, but we're already open" );
        return; // we're already connected
    }

    // start our connection
    this.m_uri = uri;
    this.m_socket = new WebSocket( this.m_uri );

    // add our events
    this.m_socket.OnOpen += this._onWebSocketOpen;
    this.m_socket.OnClose += this._onWebSocketClose;
    this.m_socket.OnError += this._onWebSocketError;
    this.m_socket.OnMessage += this._onWebSocketMessage;

    Trace.Log( $"[WebSocketConnection] Opening a new connection to {this.m_uri}" );
    await this.m_socket.Connect();

    // wait until the socket is actually open
    await new WaitUntil( () => this.isOpen );
}

public void Update()
{
#if !UNITY_WEBGL || UNITY_EDITOR
    if( this.isOpen )
        this.m_socket.DispatchMessageQueue();
#endif
}

// called when our socket is open and ready for business
private void _onWebSocketOpen()
{
    Debug.Log( $"[WebSocketConnection] Connection to {this.m_uri} open!" );

    // start listening on the socket (NOTE: we're not awaiting here)
    this.m_socket.Listen();
}

Then actually using it in a method becomes much simpler. You can connect with something like:

public async void JoinGame()
{
    // check if we need to connect
    if( !this.m_websocketConnection.isConnected )
        await this.m_websocketConnection.ConnectAsync( this.m_websocketServerURI );

    this.m_websocketConnection.JoinGame();
}

As an added benefit, you don't need special handling for WebGL and nothing blocks unless it should

[divillysausages]

You'd also need to remove the finally block from Connect(), otherwise the socket will disconnect immediately

[RealApolo]

@divillysausages and what is the solution for WEBGL? because this works on !UNITY_WEBGL && UNITY_EDITOR only

[divillysausages]

@RealApolo It's been a while since I looked at this, but IIRC, WEBGL either didn't have the problem, or didn't need the fix