socket.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/core/types/coretypes.h"
#include "twitchsdk/core/types/errortypes.h"
#include "twitchsdk/core/sockettracker.h"
#include <array>
#include <memory>

#define SOCKET_SUCCEEDED(ec) ( TTV_SUCCEEDED(ec) || (ec == TTV_EC_SOCKET_EWOULDBLOCK) )
#define SOCKET_FAILED(ec) ( TTV_FAILED(ec) && (ec != TTV_EC_SOCKET_EWOULDBLOCK) )

namespace ttv
{
    class ISocket;
    class IWebSocket;
    class ISocketFactory;
    class IWebSocketFactory;
    class BufferedSocket;

    TTV_ErrorCode InitializeSocketLibrary();

    TTV_ErrorCode ShutdownSocketLibrary();
    
    TTV_ErrorCode RegisterSocketFactory(const std::shared_ptr<ISocketFactory>& factory);

    TTV_ErrorCode UnregisterSocketFactory(const std::shared_ptr<ISocketFactory>& factory);

    TTV_ErrorCode RegisterWebSocketFactory(const std::shared_ptr<IWebSocketFactory>& factory);

    TTV_ErrorCode UnregisterWebSocketFactory(const std::shared_ptr<IWebSocketFactory>& factory);

    TTV_ErrorCode IsSocketProtocolSupported(const std::string& protocol);

    TTV_ErrorCode IsWebSocketProtocolSupported(const std::string& protocol);

    TTV_ErrorCode CreateSocket(const std::string& uri, std::shared_ptr<ISocket>& result);

    TTV_ErrorCode CreateWebSocket(const std::string& uri, std::shared_ptr<IWebSocket>& result);
}


class ttv::ISocket
{
public:
    virtual ~ISocket() = default;

    virtual TTV_ErrorCode Connect() = 0;

    virtual TTV_ErrorCode Disconnect() = 0;

    virtual TTV_ErrorCode Send(const uint8_t* buffer, size_t length);

    virtual TTV_ErrorCode Send(const uint8_t* buffer, size_t length, size_t& sent) = 0;

    virtual TTV_ErrorCode Recv(uint8_t* buffer, size_t length, size_t& received) = 0;

    virtual uint64_t TotalSent() = 0;

    virtual uint64_t TotalReceived() = 0;

    virtual bool Connected() = 0;
};


class ttv::IWebSocket
{
public:
    enum class MessageType
    {
        None,
        Binary,
        Text,
        Unknown
    };

public:
    virtual ~IWebSocket() = default;

    virtual TTV_ErrorCode Connect() = 0;

    virtual TTV_ErrorCode Disconnect() = 0;

    virtual TTV_ErrorCode Send(MessageType type, const uint8_t* buffer, size_t length) = 0;
    
    virtual TTV_ErrorCode Recv(MessageType& type, uint8_t* buffer, size_t length, size_t& received) = 0;

    virtual TTV_ErrorCode Peek(MessageType& type, size_t& length) = 0;

    virtual bool Connected() = 0;
};


class ttv::ISocketFactory
{
public:
    virtual ~ISocketFactory() = default;

    virtual bool IsProtocolSupported(const std::string& protocol) = 0;

    virtual TTV_ErrorCode CreateSocket(const std::string& uri, std::shared_ptr<ISocket>& result) = 0;
};


class ttv::IWebSocketFactory
{
public:
    virtual ~IWebSocketFactory() = default;

    virtual bool IsProtocolSupported(const std::string& protocol) = 0;

    virtual TTV_ErrorCode CreateWebSocket(const std::string& uri, std::shared_ptr<IWebSocket>& result) = 0;
};


class ttv::BufferedSocket
{
public:
    BufferedSocket();
    ~BufferedSocket();

    void Bind(const std::shared_ptr<ISocket>& socket);

    TTV_ErrorCode Connect();
    TTV_ErrorCode Disconnect();
    
    TTV_ErrorCode Send(const uint8_t* buffer, size_t length, bool cache);
    TTV_ErrorCode Recv(uint8_t* buffer, size_t length, size_t& received, uint64_t maxWaitForBufferFill);
    TTV_ErrorCode FlushCache();
    TTV_ErrorCode SetBlockingMode(bool blockingMode);

    uint64_t TotalSent();
    uint64_t TotalReceived();

    TTV_ErrorCode GetAverageSendBitRate(uint64_t measurementWindow, uint64_t& bitsPerSecond) const;
    
    TTV_ErrorCode GetCongestionLevel(uint64_t measurementWindow, double& congestionLevel) const;

    bool Connected();

private:
    // Buffer up to 65k, which is the maximum size of a TCP packet.
    static const size_t kMaxBufferSize = 0x10000;

    TTV_ErrorCode DoSend(const uint8_t* buffer, size_t length);

    std::shared_ptr<ISocket> mSocket;
    uint64_t mLastFlushTime;
    size_t mCachePos;
    std::array<uint8_t, kMaxBufferSize> mCache;
    
    SocketTracker mTracker;

    bool mBlocking;
};