DiarkisUdpBase.h

Go to the documentation of this file.

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <functional>
#include "diarkis/common.h"
#include "diarkis/network/udp.h"
#include "logging/LoggerFactory.h"
#include "protocol.h"
 
class DIARKIS_API DiarkisUdpBase
{
   public:
    DiarkisUdpBase();
 
    virtual ~DiarkisUdpBase();
 
    virtual void Setup(const std::shared_ptr<LoggerFactory>& loggerFactory);
 
    bool Connect(const char* endpoint, const char* clientKey, const struct AuthInfo* auth);
 
    bool Connect(const std::string& endpoint, const std::string& clientKey, const struct AuthInfo* auth);
 
    bool Connect(const char* endpoint,
                 const std::string& clientKey,
                 const std::vector<uint8_t>& sid,
                 const std::vector<uint8_t>& key,
                 const std::vector<uint8_t>& iv,
                 const std::vector<uint8_t>& mackey);
 
    bool ConnectAsync(const char* endpoint, const char* clientKey, const struct AuthInfo* auth);
 
    bool ConnectAsync(const std::string& endpoint, const std::string& clientKey, const struct AuthInfo* auth);
 
    bool ConnectDualModeAsync(const char* endpoint, const char* clientKey, const struct AuthInfo* auth);
 
    bool ConnectDualModeAsync(const std::string& endpoint, const std::string& clientKey, const struct AuthInfo* auth);
 
    bool IsConnected();
 
    bool IsAsyncConnectRunning() const;
 
    bool GetAsyncConnectResult(System::Result& result) const;
 
    void Disconnect();
 
    void Update();
 
    void SetSchedulerAddNotifyEvent(std::function<void()> notifyEventFunc);
 
    bool IsOffline();
 
    std::shared_ptr<IDiarkisUdp> Get();
 
    void GetGlobalAddress(Diarkis::StdString& address);
 
    bool GetLocalAddress(Diarkis::StdVector<Diarkis::StdString>& addressLists);
 
    bool SendPing(void);
 
    bool SendEcho(void);
 
    bool SendMigrate(void);
 
    void ClearUdpBuffer(void);
 
    bool SetSendThreadParam(const DiarkisThreadScheduler& scheduler);
 
    bool SetRecvThreadParam(const DiarkisThreadScheduler& scheduler);
 
    Result SendCheckNATType();
 
   protected:
    virtual void OnConnect(const DiarkisConnectionEventArgs& args);
 
    virtual void OnDisconnect(bool isReconnect);
 
    virtual void OnOffline(void);
 
    virtual void OnResponse(const DiarkisResponseEventArgs& args, DiarkisTransportType tt);
 
    virtual void OnPush(const DiarkisPushEventArgs& args, DiarkisTransportType tt);
 
    virtual void OnEcho(const DiarkisUdpEchoEventArgs& args);
 
    virtual void OnPing(const DiarkisUdpPingEventArgs& args);
 
    virtual void OnNotification(const DiarkisPushEventArgs& args);
 
    virtual void OnCheckNATType(const DiarkisCheckNATTypeEventArgs& args);
 
    bool SetConnectionInfo(const char* clientKey,
                           const uint8_t* sid,
                           size_t sidSize,
                           const uint8_t* key,
                           size_t keySize,
                           const uint8_t* iv,
                           size_t ivSize,
                           const uint8_t* mackey,
                           size_t mackeySize);
 
    bool SetConnectionInfo(const Diarkis::StdString& clientKey, const AuthInfo& auth);
 
    std::shared_ptr<IDiarkisUdp> udp_;
 
    std::shared_ptr<IDiarkisLogger> logger_;
 
    Diarkis::StdVector<std::function<void()>> eventUnsubscriptions_;
 
    std::function<void()> schedulerAddNotifyEventFunc_;
 
    bool bOffline_;
 
    Diarkis::StdString ownGlobalAddress_;
 
};