DiarkisInterfaceBase.h

[詳解]

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <condition_variable>
#include <functional>
 
#include "DiarkisDirectMessageBase.h"
#include "DiarkisFieldBase.h"
#include "DiarkisGroupBase.h"
#include "DiarkisMatchMakerBase.h"
#include "DiarkisP2PBase.h"
#include "DiarkisRoomBase.h"
#include "DiarkisRpcBase.h"
#include "DiarkisSessionBase.h"
#include "DiarkisTcpBase.h"
#include "DiarkisUdpBase.h"
#include "diarkis/common.h"
 
#include "diarkis/network/profile.h"
#include "diarkis/system/Thread.h"
#include "logging/LoggerFactory.h"
#include "logging/loggerBackends/ConsoleLoggerBackend.h"
 
#define ENABLE_LOGGER 1
 
enum LogOutType
{
    DEBUG_OUT,
    FILE_OUT,
    FILE_OUT_TO_SPECIFIC_PATH,
    CONSOLE_OUT,
    DEBUG_AND_FILE_OUT,
    CUSTOM
};
 
class DIARKIS_API DiarkisInterfaceBase
{
   public:
    enum class AsyncGetEndpointStatus
    {
        NotRunning,
        Running,
        Finish
    };
 
   public:
    DiarkisInterfaceBase(const char* userId, bool bInitBaseClass = true);
 
    DiarkisInterfaceBase(const std::string& userId, bool bInitBaseClass = true);
 
    virtual ~DiarkisInterfaceBase();
 
    static bool DiarkisInit(const char* logDirName, LogOutType out = DEBUG_OUT, bool bLog = true, std::shared_ptr<ILoggerBackend> customLogger = nullptr);
 
    static bool DiarkisInit(const std::string& logDirName,
                            LogOutType out = DEBUG_OUT,
                            bool bLog = true,
                            std::shared_ptr<ILoggerBackend> customLogger = nullptr);
 
    static bool DiarkisDestroy();
 
    void UpdateComponents();
 
    bool ConnectTcp(void);
 
    virtual bool SetupTcp(void);
 
    bool ConnectTcp(const char* tcpEndpoint);
 
    bool ConnectTcp(const std::string& tcpEndpoint);
 
    bool ConnectUdp(void);
 
    bool GetEndpoint(const char* host, const char* clientKey, const char* serverType, char* endpoint, size_t endpointBuf);
 
    bool GetEndpoint(const std::string& host, const std::string& clientKey, const std::string& type, Diarkis::StdString& endpoint);
 
    virtual bool SetupUdp(void);
 
    bool ConnectUdp(const char* udpEndpoint, const char* type, struct AuthInfo* auth);
 
    bool ConnectUdp(const char* udpEndpoint);
 
    bool ConnectUdp(const std::string& udpEndpoint);
 
    bool ConnectUdpAsync(const char* udpEndpoint);
 
    bool ConnectUdpAsync(const std::string& udpEndpoint);
 
    bool ConnectUdpDualModeAsync(const char* udpEndpoint);
 
    bool ConnectUdpDualModeAsync(const std::string& udpEndpoint);
 
    void GetAuthInfo(struct AuthInfo* auth);
 
    virtual void SetupP2P(void);
 
    void CloseP2P(void);
 
    virtual void SetupRoom(bool bRetry = false);
 
    virtual void SetupSession(bool bRetry = false);
 
    virtual void SetupRpc();
 
    virtual void SetupField(void);
 
    virtual void SetupGroup(bool bRetry);
 
    virtual void SetupMatchMaker(void);
 
    virtual void SetupDirectMessage(void);
 
    virtual void SetupProfile(uint32_t interval, uint32_t buffer, bool p2pRandomStart = true);
 
    void SetHost(const char* host);
 
    void SetHost(const std::string& host);
 
    Diarkis::StdString GetHost() const;
 
    const Diarkis::StdString& GetClientKey() const;
 
    void SetClientKey(const char* clientKey);
 
    void SetClientKey(const std::string& clientKey);
 
    const Diarkis::StdString& GetUid() const;
 
    Diarkis::StdString GetSid() const;
 
    void SetSid(const char* sid);
 
    void SetSid(const std::string& sid);
 
    std::shared_ptr<LoggerFactory> GetLoggerFactory();
 
    std::shared_ptr<ILoggerBackend> GetConsoleLoggerBackend();
 
    std::shared_ptr<ILoggerBackend> GetDebugLoggerBackend();
 
    std::shared_ptr<DiarkisUdpBase> GetUdpBase();
 
    std::shared_ptr<DiarkisTcpBase> GetTcpBase();
 
    std::shared_ptr<DiarkisP2PBase> GetP2PBase();
 
    std::shared_ptr<DiarkisRoomBase> GetRoomBase();
 
    std::shared_ptr<DiarkisSessionBase> GetSessionBase();
 
    std::shared_ptr<DiarkisGroupBase> GetGroupBase();
 
    std::shared_ptr<DiarkisFieldBase> GetFieldBase();
 
    std::shared_ptr<DiarkisMatchMakerBase> GetMatchMakerBase();
 
    std::shared_ptr<DiarkisRpcBase> GetRpcBase();
 
    std::shared_ptr<DiarkisDirectMessageBase> GetDirectMessageBase();
 
    std::shared_ptr<Diarkis::Network::IDiarkisProfile> GetProfile();
 
    void Stop();
 
    void Disconnect();
 
    // UDP
 
    void SendPing(void);
 
    void SendEcho(void);
 
    bool IsOffline(void);
 
    // P2P
 
    void StartP2P(void);
 
    uint16_t GetP2PConnectedNum(void);
 
    // Room
 
    void CreateRoom(uint16_t maxMembers, bool allowEmpty, bool join, uint16_t ttl, uint32_t interval);
 
    void RandomJoinRoom(uint16_t maxMembers, uint16_t ttl, uint32_t interval, bool allowEmpty);
 
    void JoinRoom();
 
    void JoinRoom(const char* roomID);
 
    void JoinRoom(const std::string& roomID);
 
    void SendMessageToRoom(const char** memberIDs, size_t memberIDsCount, const uint8_t* payload, size_t payloadSize, bool reliable);
 
    void SendMessageToRoom(const std::vector<std::string>& memberIDs, const std::vector<uint8_t>& payload, bool reliable);
 
    void SendLeaveRoom();
 
    void FindByTypeRoom(uint32_t roomType, uint32_t limit);
 
    void RegisterRoom(uint32_t roomType, const char* roomName, const char* roomMetadata);
 
    void RegisterRoom(uint32_t roomType, const std::string& roomName, const std::string& roomMetadata);
 
    void SendMigrateRoom(void);
 
    void SendGetOwnerID(void);
 
    void SendGetMemberIDs(void);
 
    Diarkis::StdString GetRoomID();
 
    // Group
 
    void SendCreateGroup(bool allowEmpty, bool join, uint16_t ttl);
 
    void SendJoinGroup(const char* groupID, const char* message);
 
    void SendJoinGroup(const std::string& groupID, const std::string& message);
 
    void SendRandomJoinGroup(uint16_t ttl, const char* message, uint32_t interval = 200);
 
    void SendRandomJoinGroup(uint16_t ttl, const std::string& message, uint32_t interval = 200);
 
    void SendLeaveGroup(const char* groupID, const char* message);
 
    void SendLeaveGroup(const std::string& groupID, const std::string& message);
 
    Diarkis::StdString GetGroupID();
 
    void ClearUdpBuffer();
 
    bool RequestEndpointAsync(const char* host,
                              const char* clientKey,
                              const char* type,
                              DiarkisThreadPolicy policy,
                              int priority,
                              uint32_t affinityMask,
                              uint32_t stackSize);
 
    bool RequestEndpointAsync(const std::string& host,
                              const std::string& clientKey,
                              const std::string& type,
                              DiarkisThreadPolicy policy,
                              int priority,
                              uint32_t affinityMask,
                              uint32_t stackSize);
 
    AsyncGetEndpointStatus GetEndpointAsyncStatus() const;
 
    bool GetAsyncEndpointResult(Diarkis::StdString& endpoint) const;
 
   protected:
    void InitAndStartup(bool bInitBaseClass);
 
    static void CreateLogFolder();
 
    static Diarkis::System::Result RuntimeLoop(void* owner);
 
    void SchedulerAddNotifyEvent();
 
    static void InitializeLoggerEnvironment();
 
    static bool IsLogOutputTypeFile();
 
    struct RuntimeThreadData
    {
        RuntimeThreadData() : isRunning_(false), runtimeThread_(nullptr), noWait_(false) {}
 
        void Stop();
 
        std::atomic<bool> isRunning_;
 
        std::shared_ptr<Diarkis::System::DiarkisThread> runtimeThread_;
 
        std::mutex sync_mutex_;
 
        std::condition_variable sync_condition_;
 
        bool noWait_;
    };
 
    static RuntimeThreadData runtimeThreadData_;
 
    struct ActiveInstanceList
    {
        void AddInstance(DiarkisInterfaceBase* ptr);
 
        void RemoveInstance(DiarkisInterfaceBase* ptr);
 
        void Update(bool forceUpdate);
 
        std::mutex mutex_;
 
        Diarkis::StdUniquePtr<Diarkis::StdVector<DiarkisInterfaceBase*>> instances_;
    };
 
    static ActiveInstanceList activeInstances_;
 
    static std::shared_ptr<LoggerFactory> globalLoggerFactory_;
 
    void TerminateGetEndpointAsyncThread();
 
    std::shared_ptr<DiarkisTcpBase> tcpBase_;
 
    std::shared_ptr<DiarkisUdpBase> udpBase_;
 
    std::shared_ptr<DiarkisP2PBase> p2pBase_;
 
    std::shared_ptr<DiarkisRoomBase> roomBase_;
 
    std::shared_ptr<DiarkisSessionBase> sessionBase_;
 
    std::shared_ptr<DiarkisGroupBase> groupBase_;
 
    std::shared_ptr<DiarkisFieldBase> fieldBase_;
 
    std::shared_ptr<DiarkisMatchMakerBase> matchMakerBase_;
 
    std::shared_ptr<DiarkisRpcBase> rpcBase_;
 
    std::shared_ptr<DiarkisDirectMessageBase> dmBase_;
 
    std::shared_ptr<Diarkis::Network::IDiarkisProfile> profile_;
 
    Diarkis::StdString host_;
 
    Diarkis::StdString clientKey_;
 
    const Diarkis::StdString uid_;
 
    Diarkis::StdString serverType_;
 
    Diarkis::StdString sid_;
 
    AuthInfo authInfo_;
 
    static std::shared_ptr<Diarkis::StdString> logDir_;
 
    std::shared_ptr<IDiarkisLogger> logger_;
 
    std::shared_ptr<LoggerFactory> loggerFactory_;
 
    static std::shared_ptr<ThreadedLoggerBackend> threadLoggerBackend_;
 
    static std::shared_ptr<ILoggerBackend> consoleLoggerBackend_;
 
    static std::shared_ptr<ILoggerBackend> debugLoggerBackend_;
 
    static std::shared_ptr<ILoggerBackend> fileLoggerBackend_;
 
    static std::shared_ptr<ILoggerBackend> customLoggerBackend_;
 
    static std::shared_ptr<ILoggerBackend> aggregatedLoggerBackend_;
 
    static LogOutType logOutType_;
 
    static bool bOutputLog_;
 
    struct AsyncGetEndpointArgs
    {
        Diarkis::StdString host;
        Diarkis::StdString clientKey;
        Diarkis::StdString serverType;
    };
 
    mutable std::mutex connectioninfoMutex_;
 
    mutable std::mutex asyncGetEndpointMutex_;
 
    AsyncGetEndpointArgs asyncGetEndpointArgs_;
 
    AsyncGetEndpointStatus asyncGetEndpointStatus_;
 
    bool asyncGetEndpointResult_;
 
    Diarkis::StdString asyncEndpointResult_;
 
    AuthInfo asyncAuthResult_;
 
    std::shared_ptr<Diarkis::System::DiarkisThread> getEndpointAsyncThread_;
 
    static Diarkis::System::Result GetEndpointAsync(void* owner);
 
    std::atomic<bool> internalSchedulerUpdated_;
};