udp.h

Go to the documentation of this file.

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <functional>
#include <ostream>
 
#include "diarkis/common.h"
#include "diarkis/logging/LoggerFactory.h"
#include "diarkis/network/eventArgs.h"
#include "diarkis/network/network.h"
#include "diarkis/network/profile.h"
#include "diarkis/network/transport.h"
#include "diarkis/system/Event.h"
#include "diarkis/system/Thread.h"
#include "diarkis/system/result.h"
 
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#endif
 
// ADD NAMESPACE NAME TAG
namespace Diarkis
{
namespace Network
{
enum class DIARKIS_EXPORT DiarkisUdpDisconnectionReason : std::uint8_t;
enum class DiarkisUdpDisconnectionReason : std::uint8_t
{
    Expected = 0,
    NoResponse = 1,
    RetryTimeout = 2,
    ForcedByServer = 3,
    Forced = 4,
    Timeout = 5,
    NormalDisconnect = 6
};
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
 
DIARKIS_EXPORT std::ostream& operator<<(std::ostream&, DiarkisUdpDisconnectionReason);
 
class DIARKIS_EXPORT IDiarkisUdp : public IDiarkisTransport
{
   public:
    virtual ~IDiarkisUdp() {}
 
    virtual Diarkis::System::Result ConnectAsync(const char* unresolvedAddress, uint16_t port, uint16_t timeOut = 3000) = 0;
 
    virtual Diarkis::System::Result ConnectAsync(const Diarkis::StdString& unresolvedAddress, uint16_t port, uint16_t timeOut = 3000) = 0;
 
    virtual Diarkis::System::Result ConnectDualModeAsync(const Diarkis::StdString& unresolvedAddress, uint16_t port, uint16_t timeOut = 3000) = 0;
 
    virtual bool IsAsyncConnectRunning() const = 0;
 
    virtual System::Result GetAsyncConnectResult() const = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisUdpEchoEventArgs&>> GetEchoEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisUdpPingEventArgs&>> GetPingEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRawPayloadEventArgs&>> GetPacketReceivedEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisP2PDisconnectEventArgs&>> GetP2PDisconnectEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisCheckNATTypeEventArgs&>> GetCheckNATTypeEvent() = 0;
 
    virtual Diarkis::StdString& GetGlobalAddress() = 0;
 
    virtual Diarkis::StdVector<StdString>& GetLocalAddressLists() = 0;
 
    virtual Diarkis::System::Result SetEchoTimeout(uint32_t timeoutInMilliseconds) = 0;
 
    virtual Diarkis::System::Result SendTo(const Diarkis::StdVector<uint8_t>& msg, const Diarkis::Network::Types::SockAddrStorage& to) = 0;
 
    virtual Diarkis::System::Result RSendTo(const Diarkis::StdVector<uint8_t>& msg, const Diarkis::Network::Types::SockAddrStorage& to, bool bFixedOrder) = 0;
 
    virtual Diarkis::System::Result RSend(uint8_t version, uint16_t command, const uint8_t* payload, size_t payloadSize) = 0;
 
    virtual Diarkis::System::Result RSend(uint8_t version, uint16_t command, const Diarkis::StdVector<uint8_t>& payload) = 0;
 
    virtual Diarkis::System::Result Send(uint8_t version, uint16_t command, const uint8_t* payload, size_t payloadSize) = 0;
 
    virtual Diarkis::System::Result Send(uint8_t version, uint16_t command, const Diarkis::StdVector<uint8_t>& payload) = 0;
 
    virtual Diarkis::System::Result Echo() = 0;
 
    virtual Diarkis::System::Result Ping() = 0;
 
    virtual Diarkis::System::Result Migrate() = 0;
 
    virtual Diarkis::System::Result Migrate(const Diarkis::StdString& serverType) = 0;
 
    virtual DiarkisUdpDisconnectionReason GetDisconnectionReason() = 0;
 
    virtual Diarkis::System::Result GetSocketErrorReason() = 0;
 
    virtual void SetSendThreadParam(const Diarkis::System::DiarkisThreadScheduler& scheduler) = 0;
 
    virtual void SetRecvThreadParam(const Diarkis::System::DiarkisThreadScheduler& scheduler) = 0;
 
    virtual void ClearRecvSocket(void) = 0;
 
    virtual void ClearSendPendingBuffer(void) = 0;
 
    virtual System::Result SetEncryptionP2PKeys(const Diarkis::StdVector<uint8_t>& key,
                                                const Diarkis::StdVector<uint8_t>& iv,
                                                const Diarkis::StdVector<uint8_t>& mackey) = 0;
    virtual void SetP2PBuffering(bool bSendBuffering) = 0;
    virtual System::Result RegisterPeer(const Types::SockAddrStorage& sockAddr, const StdVector<StdString>& candidateList, const StdString& uid) = 0;
    virtual System::Result UnregisterPeer(StdString peerAddr) = 0;
    virtual std::shared_ptr<IDiarkisProfile> GetProfileInterface() = 0;
    virtual void SetRoomID(const StdString& id) = 0;
 
    virtual void SetSendRetryInterval(uint32_t minMs, uint32_t maxMs) = 0;
 
    virtual void SetSendRetryInterval(uint32_t timeInMs) = 0;
 
    virtual void SetSendRetryMaxCount(uint32_t count) = 0;
 
    virtual void SetSendRetryIntervalP2P(uint32_t minMs, uint32_t maxMs) = 0;
 
    virtual void SetSendRetryIntervalP2P(uint32_t timeInMs) = 0;
 
    virtual void SetSendRetryMaxCountP2P(uint32_t count) = 0;
 
    virtual void SetEnableRecreateSocketOnError(bool enable) = 0;
 
    virtual void SetRecreateSocketRetryInterval(uint32_t timeInMs) = 0;
 
    virtual void SetRecreateSocketRetryMaxCount(uint32_t count) = 0;
 
    virtual System::Result SendCheckNATType() = 0;
};
 
DIARKIS_EXPORT IDiarkisUdp* DiarkisCreateUdp(uint32_t sendInterval = 100, uint32_t echoInterval = 5000);
 
}  // namespace Network
}  // namespace Diarkis
// ADD NAMESPACE } TAG