someip_sd_client.h

#ifndef SOMEIP_SD_CLIENT
#define SOMEIP_SD_CLIENT
 
#include "../../../core/optional.h"
#include "../../helper/ipv4_address.h"
#include "../../helper/ttl_timer.h"
#include "../../entry/service_entry.h"
#include "./fsm/service_notseen_state.h"
#include "./fsm/service_seen_state.h"
#include "./fsm/client_initial_wait_state.h"
#include "./fsm/client_repetition_state.h"
#include "./fsm/service_ready_state.h"
#include "./fsm/stopped_state.h"
#include "./someip_sd_agent.h"
 
namespace ara
{
    namespace com
    {
        namespace someip
        {
            namespace sd
            {
                class SomeIpSdClient : public SomeIpSdAgent<helper::SdClientState>
                {
                private:
                    helper::TtlTimer mTtlTimer;
                    bool mValidState;
                    std::mutex mOfferingMutex;
                    std::unique_lock<std::mutex> mOfferingLock;
                    std::condition_variable mOfferingConditionVariable;
                    std::mutex mStopOfferingMutex;
                    std::unique_lock<std::mutex> mStopOfferingLock;
                    std::condition_variable mStopOfferingConditionVariable;
                    fsm::ServiceNotseenState mServiceNotseenState;
                    fsm::ServiceSeenState mServiceSeenState;
                    fsm::ClientInitialWaitState mInitialWaitState;
                    fsm::ClientRepetitionState mRepetitionState;
                    fsm::StoppedState mStoppedState;
                    fsm::ServiceReadyState mServiceReadyState;
                    SomeIpSdMessage mFindServieMessage;
                    const uint16_t mServiceId;
                    std::mutex mEndpointMutex;
                    std::unique_lock<std::mutex> mEndpointLock;
                    core::Optional<std::string> mOfferedIpAddress;
                    core::Optional<uint16_t> mOfferedPort;
 
                    void sendFind();
                    bool matchRequestedService(
                        const SomeIpSdMessage &message, uint32_t &ttl) const;
                    bool tryExtractOfferedEndpoint(
                        const SomeIpSdMessage &message,
                        std::string &ipAddress, uint16_t &port) const;
                    void onOfferChanged(uint32_t ttl);
                    void receiveSdMessage(SomeIpSdMessage &&message);
 
                protected:
                    void StartAgent(helper::SdClientState state) override;
                    void StopAgent() override;
 
                public:
                    SomeIpSdClient() = delete;
 
                    SomeIpSdClient(
                        helper::NetworkLayer<SomeIpSdMessage> *networkLayer,
                        uint16_t serviceId,
                        int initialDelayMin,
                        int initialDelayMax,
                        int repetitionBaseDelay = 30,
                        uint32_t repetitionMax = 3);
 
                    bool TryWaitUntiServiceOffered(int duration);
 
                    bool TryWaitUntiServiceOfferStopped(int duration);
 
                    bool TryGetOfferedEndpoint(
                        std::string &ipAddress, uint16_t &port);
 
                    ~SomeIpSdClient() override;
                };
            }
        }
    }
}
 
#endif