websocketclient.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "iwebsocketclientendpoint.h"
#include "websocketinterface.h"
#include "websocketticket.h"
 
// External Includes
#include <nap/resource.h>
#include <nap/resourceptr.h>
 
namespace nap
{
    class NAPAPI IWebSocketClient : public WebSocketInterface
    {
        template<typename config>
        friend class WebSocketClientEndPointSetup;
 
        template<typename config>
        friend class WebSocketClientWrapper;
 
        RTTI_ENABLE(WebSocketInterface)
    public:
        IWebSocketClient(WebSocketService& service);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual void onDestroy() override;
 
        bool isConnected() const;
 
        bool reconnect(utility::ErrorState& error);
 
        const WebSocketConnection& getConnection() const                { return mConnection; }
 
        ResourcePtr<IWebSocketClientEndPoint> mEndPoint;                
        ResourcePtr<WebSocketTicket> mTicket = nullptr;                 
        std::string mURI;                                               
 
    protected:
        WebSocketConnection mConnection;                                
 
        virtual void onConnectionOpened() = 0;
 
        virtual void onConnectionClosed(int code, const std::string& reason) = 0;
 
        virtual void onConnectionFailed(int code, const std::string& reason) = 0;
 
        virtual void onMessageReceived(const WebSocketMessage& msg) = 0;
 
    private:
        // Called by web-socket client endpoint when the connection is opened
        void connectionOpened();
        // Called by web-socket client endpoint when the connection is closed
        void connectionClosed(int code, const std::string& reason);
        // Called by web-socket client endpoint when the connection failed to establish
        void connectionFailed(int code, const std::string& reason);
        // Called by web-socket client endpoint when a new message is received
        void messageReceived(const WebSocketMessage& msg);
 
        std::atomic<bool> mOpen = { false };                
    };
 
 
    // WebSocketClient
 
    class NAPAPI WebSocketClient : public IWebSocketClient
    {
        RTTI_ENABLE(IWebSocketClient)
    public:
        WebSocketClient(WebSocketService& service);
 
        bool send(const std::string& message, EWebSocketOPCode code, nap::utility::ErrorState& error);
 
        bool send(void const* payload, int length, EWebSocketOPCode code, nap::utility::ErrorState& error);
 
        bool send(const WebSocketMessage& message, nap::utility::ErrorState& error);
 
    private:
        virtual void onConnectionOpened() override;
 
        virtual void onConnectionClosed(int code, const std::string& reason) override;
        
        virtual void onConnectionFailed(int code, const std::string& reason) override;
        
        virtual void onMessageReceived(const WebSocketMessage& msg) override;
    };
 
    // Object creator used for constructing the web-socket client
    using WebSocketClientObjectCreator = rtti::ObjectCreator<WebSocketClient, WebSocketService>;
}