doip_vehicle_discovery_handler.cpp

Go to the documentation of this file.

/* Diagnostic Client library
 * Copyright (C) 2024  Avijit Dey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#include "channel/udp_channel/doip_vehicle_discovery_handler.h"
 
#include "common/logger.h"
#include "utility/state.h"
 
namespace doip_client {
namespace channel {
namespace udp_channel {
namespace {
enum class VehicleDiscoveryState : std::uint8_t { kIdle = 0U, kWaitForVehicleAnnouncement, kDoIPCtrlTimeout };
 
class kIdle final : public utility::state::State<VehicleDiscoveryState> {
 public:
  explicit kIdle(VehicleDiscoveryState state) : State<VehicleDiscoveryState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
class kWaitForVehicleAnnouncement final : public utility::state::State<VehicleDiscoveryState> {
 public:
  explicit kWaitForVehicleAnnouncement(VehicleDiscoveryState state) : State<VehicleDiscoveryState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
class kDoIPCtrlTimeout final : public utility::state::State<VehicleDiscoveryState> {
 public:
  explicit kDoIPCtrlTimeout(VehicleDiscoveryState state) : State<VehicleDiscoveryState>(state) {}
 
  void Start() override {}
 
  void Stop() override {}
};
 
}  // namespace
 
class VehicleDiscoveryHandler::VehicleDiscoveryHandlerImpl final {
 public:
  using VehicleDiscoveryStateContext = utility::state::StateContext<VehicleDiscoveryState>;
 
  explicit VehicleDiscoveryHandlerImpl(sockets::UdpSocketHandler &udp_socket_handler)
      : udp_socket_handler_{udp_socket_handler},
        state_context_{} {
    // create and add state for vehicle discovery
    // kIdle
    state_context_.AddState(VehicleDiscoveryState::kIdle, std::make_unique<kIdle>(VehicleDiscoveryState::kIdle));
    // kWaitForVehicleAnnouncement
    state_context_.AddState(
        VehicleDiscoveryState::kWaitForVehicleAnnouncement,
        std::make_unique<kWaitForVehicleAnnouncement>(VehicleDiscoveryState::kWaitForVehicleAnnouncement));
    // kDoIPCtrlTimeout
    state_context_.AddState(VehicleDiscoveryState::kDoIPCtrlTimeout,
                            std::make_unique<kDoIPCtrlTimeout>(VehicleDiscoveryState::kDoIPCtrlTimeout));
    // Transit to wait for vehicle announcement
    state_context_.TransitionTo(VehicleDiscoveryState::kWaitForVehicleAnnouncement);
  }
 
  auto GetStateContext() noexcept -> VehicleDiscoveryStateContext & { return state_context_; }
 
  auto GetSocketHandler() noexcept -> sockets::UdpSocketHandler & { return udp_socket_handler_; }
 
 private:
  sockets::UdpSocketHandler &udp_socket_handler_;
 
  VehicleDiscoveryStateContext state_context_;
};
 
udp_channel::VehicleDiscoveryHandler::VehicleDiscoveryHandler(sockets::UdpSocketHandler &udp_socket_handler,
                                                              DoipUdpChannel &)
    : handler_impl_{std::make_unique<VehicleDiscoveryHandlerImpl>(udp_socket_handler)} {}
 
VehicleDiscoveryHandler::~VehicleDiscoveryHandler() = default;
 
void VehicleDiscoveryHandler::ProcessVehicleAnnouncementResponse(DoipMessage &) noexcept {
  if (handler_impl_->GetStateContext().GetActiveState().GetState() ==
      VehicleDiscoveryState::kWaitForVehicleAnnouncement) {
    // Deserialize and Add to task executor
    logger::DoipClientLogger::GetDiagClientLogger().GetLogger().LogWarn(
        __FILE__, __LINE__, __func__,
        [](std::stringstream &msg) { msg << "Processing of vehicle announcement is not implemented"; });
  } else {
    // ignore
  }
}
 
}  // namespace udp_channel
}  // namespace channel
}  // namespace doip_client