p2p.h

Go to the documentation of this file.

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include "diarkis/common.h"
#include "diarkis/logging/LoggerFactory.h"
#include "diarkis/network/eventArgs.h"
#include "diarkis/network/udp.h"
#include "diarkis/system/Event.h"
#include "diarkis/system/Thread.h"
#include "diarkis/system/result.h"
 
using namespace Diarkis::Network;
 
enum RudpType : uint8_t
{
    UNRELIABLE_UNORDERED = 0,
    RELIABLE_UNORDERED = 1,
    RELIABLE_ORDERED = 2
};
 
// ADD NAMESPACE NAME TAG
namespace Diarkis
{
namespace Modules
{
class IDiarkisP2P : public IDiarkisComponent
{
   public:
    virtual ~IDiarkisP2P() {}
 
    virtual void SetupP2P(const char* uid) = 0;
 
    virtual void SetLoggerFactory(std::shared_ptr<IDiarkisLoggerFactory> loggerFactory) = 0;
 
    virtual void SetHolePunchThreadParam(const Diarkis::System::DiarkisThreadScheduler& scheduler) = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisReadyEventArgs&>> GetReadyEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisFailEventArgs&>> GetFailEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisP2PDisconnectEventArgs&>> GetDisconnectEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisMessageEventArgs&>> GetMessageEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisExceptionEventArgs&>> GetExceptionEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<void*>> GetSchedulerAddNotifyEvent() = 0;
 
    virtual Diarkis::StdString GetPeerAddress() = 0;
 
    virtual bool IsConnected() = 0;
 
    virtual Diarkis::System::Result Connect(const char* uid,
                                            const char** addressLists,
                                            size_t addressListsSize,
                                            size_t timeoutInMilliseconds = 10000,
                                            bool bBuffering = false) = 0;
 
    virtual Diarkis::System::Result Connect(const Diarkis::StdString& uid,
                                            const Diarkis::StdVector<Diarkis::StdString>& addressLists,
                                            size_t timeoutInMilliseconds = 10000,
                                            bool bBuffering = false) = 0;
 
    virtual Diarkis::System::Result SetEncryptionKeys(bool bEncryption,
                                                      const uint8_t* key,
                                                      size_t keySize,
                                                      const uint8_t* iv,
                                                      size_t ivSize,
                                                      const uint8_t* mackey,
                                                      size_t mackeySize) = 0;
 
    virtual Diarkis::System::Result SetEncryptionKeys(bool bEncryption,
                                                      const Diarkis::StdVector<uint8_t>& key,
                                                      const Diarkis::StdVector<uint8_t>& iv,
                                                      const Diarkis::StdVector<uint8_t>& mackey) = 0;
 
    virtual Diarkis::System::Result Disconnect() = 0;
 
    virtual Diarkis::System::Result Send(const uint8_t* message, size_t messageSize) = 0;
 
    virtual Diarkis::System::Result Send(const Diarkis::StdVector<uint8_t>& message) = 0;
 
    virtual Diarkis::System::Result RSend(const uint8_t* message, size_t messageSize, bool bFixedOrder) = 0;
 
    virtual Diarkis::System::Result RSend(const Diarkis::StdVector<uint8_t>& message, bool bFixedOrder) = 0;
 
    virtual Diarkis::System::Result NotifyP2PConnectCompleted() = 0;
 
    virtual void SetDebugP2PFailMode(bool enable) = 0;
 
    virtual void SetDebugP2PFailUIDs(const char** UIDList, size_t UIDListSize) = 0;
 
    virtual void SetDebugP2PFailUIDs(const Diarkis::StdVector<Diarkis::StdString>& UIDList) = 0;
 
    virtual void ClearDebugP2PFailUIDs() = 0;
};
 
extern "C"
{
    DIARKIS_EXPORT IDiarkisP2P* DiarkisCreateP2P(std::shared_ptr<IDiarkisUdp> udp);
}
 
}  // namespace Modules
}  // namespace Diarkis
   // ADD NAMESPACE } TAG