jaus++/2.0/include/jaus/core/transport/judp.h

Go to the documentation of this file.

#ifndef __JAUS_CORE_TRANSPORT_UDP__H
#define __JAUS_CORE_TRANSPORT_UDP__H

#include "jaus/core/transport/transport.h"
#include <cxutils/networking/udpclient.h>
#include <cxutils/networking/udpsharedserver.h>

namespace JAUS
{
    class JAUS_CORE_DLL JUDP : public Transport, 
                               public CxUtils::UdpSharedServer::Callback
    {
    public:
        const static unsigned short Port = 3794;         
        const static unsigned int OverheadSizeBytes = 61;
        const static Byte Version = 0x02;                
        JUDP();
        ~JUDP();
        // Sets the delay time in ms for UDP polling loop.
        virtual void SetPacketPollingDelayMs(const unsigned int delayTimeMs = 0);
        // Load settings from a file.
        virtual bool LoadSettings(const std::string& filename);
        // Initializes the transport with a given ID for a component.
        virtual bool Initialize(const Address& componentID);
        // Returns true if transport has been initialized.
        virtual bool IsInitialized() const;
        // Shutsdown the transport service.
        virtual void Shutdown();
        // Gets the list of connections available.
        virtual Address::List GetConnections() const;
        // Returns true if connection is present.
        virtual bool HaveConnection(const Address& id) const;
        // Send a serialized message.
        virtual bool SendPacket(const Packet& packet, 
                                const Header& header,
                                const int broadcastFlags = Service::NoBroadcast) const;
        // Serialize the JAUS message (add transport headers, serialize payload, etc.) 
        virtual bool SerializeMessage(const Message* message, 
                                      Packet::List& stream,
                                      Header::List& streamHeaders,
                                      const UShort startingSequenceNumber,
                                      const int broadcastFlags) const;
        // Get a copy of the transport header.
        virtual Packet GetTransportHeader() const { return mTransportHeader; }
        // Gets a list of all manually created connections.
        virtual Address::List GetManualConnections() const ;
        // Sets the maximum packet size.
        void SetMaxPacketSize(const unsigned int maxSizeBytes = 1500);
        // Sets how long to wait until a connection is considered invalid.
        void SetDisconnectTimeMs(const unsigned int timeMs);
        // Sets the default Time-to-Live (TTL) for multicast.
        void SetTTL(const unsigned char ttl = 16);
        // Sets the mutlicast group IP address.
        void SetMulticastIP(const CxUtils::IP4Address& multicastIP);
        // Use broadcast instead of multicast.
        void EnableBroadcasting(const bool enabled);
        // Gets  the mutlicast group IP address.
        CxUtils::IP4Address GetMulticastIP() const { return mMulticastIP; }
        // Sets the host interface IP address to connect on.
        void SetInterfaceIP(const CxUtils::IP4Address& networkIP = CxUtils::IP4Address());
        // Adds a connection to a specific IP address.
        bool AddConnection(const CxUtils::IP4Address& networkIP,
                           const Address& jausID,
                           const unsigned short port = Port);
        virtual bool CloseConnection(const Address& jausID);
        // Method to listen/discover broadcasting subsystem on the network.
        static bool ListenForSubsystems(Address::Set& discovered,
                                        const unsigned int waitTimeMs = 5000,
                                        const CxUtils::IP4Address& multicastIP = "239.255.0.1");
    private:
        static void ReceiveThread(void* args);
        virtual void CheckServiceStatus(const unsigned int timeSinceLastCheckMs);        
        virtual void ProcessUDP(const Packet& packet, 
                                const CxUtils::IP4Address& ipAddress,
                                const unsigned short sourcePort);
        int UpdateClientConnections(const Address& id,
                                    const CxUtils::IP4Address& ipAddress,
                                    const unsigned short sourcePort);
        Time::Stamp mDisconnectTimeMs;            
        unsigned int mMaxPayloadSize;             
        unsigned char mTimeToLive;                
        CxUtils::IP4Address mHostIP;              
        CxUtils::IP4Address mMulticastIP;         
        unsigned short mInternalDiscoveryPort;    
        bool mUseBroadcastingFlag;                
        Mutex mClientsMutex;                      
        Thread mPrimaryThread;                    
        Thread mSecondaryThread;                  
        unsigned int mDelayTimeMs;                
        CxUtils::UdpServer mInput;                
        CxUtils::UdpClient mMulticast;            
        std::map<Address, Time::Stamp> mUpdateTimes;     
        std::map<Address, CxUtils::UdpClient*> mClients; 
        std::map<Address, bool> mPermanentConnections;   
        Packet mTransportHeader;                         
        volatile bool mPrimaryThreadCreatedFlag;         
    };
}

#endif
/*  End of File */