RemoteInterface.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Communication/Event.h>
#include <Foundation/Communication/RemoteMessage.h>
#include <Foundation/Containers/Deque.h>
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Threading/Thread.h>
#include <Foundation/Time/Time.h>
#include <Foundation/Types/Delegate.h>
 
enum class plRemoteMode
{
  None,   
  Server, 
  Client  
};
 
enum class plRemoteTransmitMode
{
  Reliable,   
  Unreliable, 
};
 
struct PL_FOUNDATION_DLL plRemoteEvent
{
  enum Type
  {
    ConnectedToClient,      
    ConnectedToServer,      
    DisconnectedFromClient, 
    DisconnectedFromServer, 
  };
 
  Type m_Type;
  plUInt32 m_uiOtherAppID;
};
 
using plRemoteMessageHandler = plDelegate<void(plRemoteMessage&)>;
 
struct PL_FOUNDATION_DLL plRemoteMessageQueue
{
  plRemoteMessageHandler m_MessageHandler;
  plDeque<plRemoteMessage> m_MessageQueueIn;
  plDeque<plRemoteMessage> m_MessageQueueOut;
};
 
class PL_FOUNDATION_DLL plRemoteInterface
{
public:
  virtual ~plRemoteInterface();
 
  plMutex& GetMutex() const { return m_Mutex; }
 
 
 
  plResult StartServer(plUInt32 uiConnectionToken, plStringView sAddress, bool bStartUpdateThread = true);
 
  plResult ConnectToServer(plUInt32 uiConnectionToken, plStringView sAddress, bool bStartUpdateThread = true);
 
  plResult WaitForConnectionToServer(plTime timeout = plTime::MakeFromSeconds(10));
 
  void ShutdownConnection();
 
  bool IsConnectedToServer() const { return m_uiConnectedToServerWithID != 0; }
 
  bool IsConnectedToClients() const { return m_iConnectionsToClients > 0; }
 
  bool IsConnectedToOther() const { return IsConnectedToServer() || IsConnectedToClients(); }
 
  plRemoteMode GetRemoteMode() const { return m_RemoteMode; }
 
  const plString& GetServerAddress() const { return m_sServerAddress; }
 
  plUInt32 GetApplicationID() const { return m_uiApplicationID; }
 
  plUInt32 GetConnectionToken() const { return m_uiConnectionToken; }
 
 
 
  // const plString& GetServerInfoName() const { return m_ServerInfoName; }
 
  const plString& GetServerInfoIP() const { return m_sServerInfoIP; }
 
  plUInt32 GetServerID() const { return m_uiConnectedToServerWithID; }
 
  plTime GetPingToServer() const { return m_PingToServer; }
 
 
 
  void UpdateRemoteInterface();
 
  void UpdatePingToServer();
 
 
 
  void Send(plUInt32 uiSystemID, plUInt32 uiMsgID);
 
  void Send(plRemoteTransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, const plArrayPtr<const plUInt8>& data);
 
  void Send(plRemoteTransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, const plContiguousMemoryStreamStorage& data);
 
  void Send(plRemoteTransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, const void* pData = nullptr, plUInt32 uiDataBytes = 0);
 
  void Send(plRemoteTransmitMode tm, plRemoteMessage& ref_msg);
 
 
 
  void SetMessageHandler(plUInt32 uiSystemID, plRemoteMessageHandler messageHandler);
 
  void SetUnhandledMessageHandler(plRemoteMessageHandler messageHandler);
 
  plUInt32 ExecuteMessageHandlers(plUInt32 uiSystem);
 
  plUInt32 ExecuteAllMessageHandlers();
 
 
 
  plEvent<const plRemoteEvent&> m_RemoteEvents;
 
 
protected:
 
  virtual plResult InternalCreateConnection(plRemoteMode mode, plStringView sServerAddress) = 0;
 
  virtual void InternalShutdownConnection() = 0;
 
  virtual void InternalUpdateRemoteInterface() = 0;
 
  virtual plTime InternalGetPingToServer() = 0;
 
  virtual plResult InternalTransmit(plRemoteTransmitMode tm, const plArrayPtr<const plUInt8>& data) = 0;
 
  virtual plResult DetermineTargetAddress(plStringView sConnectTo, plUInt32& out_IP, plUInt16& out_Port);
 
  // plString m_ServerInfoName;
  plString m_sServerInfoIP;
 
  void ReportConnectionToServer(plUInt32 uiServerID);
  void ReportConnectionToClient(plUInt32 uiApplicationID);
  void ReportDisconnectedFromServer();
  void ReportDisconnectedFromClient(plUInt32 uiApplicationID);
  void ReportMessage(plUInt32 uiApplicationID, plUInt32 uiSystemID, plUInt32 uiMsgID, const plArrayPtr<const plUInt8>& data);
 
 
 
private:
  void StartUpdateThread();
  void StopUpdateThread();
  plResult Transmit(plRemoteTransmitMode tm, const plArrayPtr<const plUInt8>& data);
  plResult CreateConnection(plUInt32 uiConnectionToken, plRemoteMode mode, plStringView sServerAddress, bool bStartUpdateThread);
  plUInt32 ExecuteMessageHandlersForQueue(plRemoteMessageQueue& queue);
 
  mutable plMutex m_Mutex;
  class plRemoteThread* m_pUpdateThread = nullptr;
  plRemoteMode m_RemoteMode = plRemoteMode::None;
  plString m_sServerAddress;
  plTime m_PingToServer;
  plUInt32 m_uiApplicationID = 0; // sent when connecting to identify the sending instance
  plUInt32 m_uiConnectionToken = 0;
  plUInt32 m_uiConnectedToServerWithID = 0;
  plInt32 m_iConnectionsToClients = 0;
  plDynamicArray<plUInt8> m_TempSendBuffer;
  plHashTable<plUInt32, plRemoteMessageQueue> m_MessageQueues;
  plRemoteMessageHandler m_UnhandledMessageHandler;
};
 
class PL_FOUNDATION_DLL plRemoteThread : public plThread
{
public:
  plRemoteThread();
 
  plRemoteInterface* m_pRemoteInterface = nullptr;
  volatile bool m_bKeepRunning = true;
 
private:
  virtual plUInt32 Run();
};