link_layer_client.hpp

#pragma once
#include <kj/async-io.h>
#include <vanetza/dcc/channel_load.hpp>
#include <vanetza/net/chunk_packet.hpp>
#include <vanetza/net/cohesive_packet.hpp>
#include <vanetza/net/mac_address.hpp>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
 
namespace vanetza
{
 
namespace access { class DataRequest; }
 
namespace rpc
{
 
class Logger;
 
class LinkLayerClient
{
public:
    enum class ErrorCode
    {
        Ok,
        InvalidArgument,
        Unsupported,
        InternalError,
    };
 
    enum class Technology
    {
        Unspecified,
        ITS_G5,
        LTE_V2X,
    };
 
    struct Indication
    {
        Indication(vanetza::ByteBuffer);
 
        vanetza::MacAddress source;
        vanetza::MacAddress destination;
        vanetza::CohesivePacket packet;
        Technology technology = Technology::Unspecified;
    };
 
    struct Identity
    {
        std::uint64_t id = 0;
        std::uint32_t version = 0;
        std::string info;
    };
 
    using IndicationCallback = std::function<void(Indication)>;
    using ChannelLoadReportCallback = std::function<void(dcc::ChannelLoad)>;
 
    LinkLayerClient(kj::Timer&, kj::AsyncIoStream&, Logger* = nullptr);
    ~LinkLayerClient();
 
    kj::Promise<Identity> identify();
    void request(const access::DataRequest&, std::unique_ptr<ChunkPacket>);
    void indicate(IndicationCallback callback);
    void report_channel_load(ChannelLoadReportCallback callback);
    kj::Promise<ErrorCode> set_source_address(const MacAddress&);
 
    void configure(Technology);
    void add_task(kj::Promise<void>&&);
 
private:
    class Context;
 
    void do_indicate(Indication);
    void do_report(dcc::ChannelLoad);
 
    std::unique_ptr<Context> context_;
    std::mutex callback_mutex_;
    IndicationCallback indication_callback_;
    ChannelLoadReportCallback cbr_callback_;
    Technology technology_ = Technology::Unspecified;
};
 
const char* stringify(LinkLayerClient::ErrorCode);
const char* stringify(LinkLayerClient::Technology);
 
} // namespace rpc
} // namespace vanetza