connection_manager.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 "connection/connection_manager.h"
 
#include <string_view>
 
#include "channel/tcp_channel/doip_tcp_channel.h"
#include "channel/udp_channel/doip_udp_channel.h"
#include "sockets/socket_handler.h"
#include "uds_transport/conversation_handler.h"
 
namespace doip_client {
namespace connection {
namespace {
using namespace std::literals;
 
constexpr std::string_view kDoipTcpConnectionName{"DTcpCntn_"sv};
 
constexpr std::string_view kDoipUdpConnectionName{"DUdpCntn_"sv};
 
}  // namespace
 
class DoipTcpConnection final : public uds_transport::Connection {
 public:
  using InitializationResult = uds_transport::Connection::InitializationResult;
 
  using TcpClient = sockets::TcpSocketHandler::Client;
 
  DoipTcpConnection(uds_transport::ConversionHandler const &conversation_handler,
                    std::string_view tcp_ip_address, std::uint16_t port_num)
      : uds_transport::Connection{kDoipTcpConnectionName, 1u, conversation_handler},
        doip_tcp_channel_{
            sockets::TcpSocketHandler{TcpClient{GetConnectionName(), tcp_ip_address, port_num}},
            *this} {}
 
  ~DoipTcpConnection() final = default;
 
  InitializationResult Initialize() override { return InitializationResult::kInitializeOk; }
 
  void Start() override { doip_tcp_channel_.Start(); }
 
  void Stop() override { doip_tcp_channel_.Stop(); }
 
  bool IsConnectToHost() override { return (doip_tcp_channel_.IsConnectedToHost()); }
 
  uds_transport::UdsTransportProtocolMgr::ConnectionResult ConnectToHost(
      uds_transport::UdsMessageConstPtr message) override {
    return (doip_tcp_channel_.ConnectToHost(std::move(message)));
  }
 
  uds_transport::UdsTransportProtocolMgr::DisconnectionResult DisconnectFromHost() override {
    return (doip_tcp_channel_.DisconnectFromHost());
  }
 
  std::pair<uds_transport::UdsTransportProtocolMgr::IndicationResult, uds_transport::UdsMessagePtr>
  IndicateMessage(uds_transport::UdsMessage::Address source_addr,
                  uds_transport::UdsMessage::Address target_addr,
                  uds_transport::UdsMessage::TargetAddressType type,
                  uds_transport::ChannelID channel_id, std::size_t size,
                  uds_transport::Priority priority, uds_transport::ProtocolKind protocol_kind,
                  core_type::Span<std::uint8_t const> payload_info) override {
    return (conversation_handler_.IndicateMessage(source_addr, target_addr, type, channel_id, size,
                                                  priority, protocol_kind, payload_info));
  }
 
  uds_transport::UdsTransportProtocolMgr::TransmissionResult Transmit(
      uds_transport::UdsMessageConstPtr message) override {
    return doip_tcp_channel_.Transmit(std::move(message));
  }
 
  void HandleMessage(uds_transport::UdsMessagePtr message) override {
    conversation_handler_.HandleMessage(std::move(message));
  }
 
 private:
  channel::tcp_channel::DoipTcpChannel doip_tcp_channel_;
};
 
class DoipUdpConnection final : public uds_transport::Connection {
 public:
  using InitializationResult = uds_transport::Connection::InitializationResult;
 
  using UdpClient = sockets::UdpSocketHandler::Client;
 
  DoipUdpConnection(uds_transport::ConversionHandler const &conversation_handler,
                    std::string_view udp_ip_address, std::uint16_t port_num)
      : uds_transport::Connection{kDoipUdpConnectionName, 1, conversation_handler},
        doip_udp_channel_{sockets::UdpSocketHandler{UdpClient{udp_ip_address, port_num}},
                          sockets::UdpSocketHandler{UdpClient{udp_ip_address, port_num}}, *this} {}
 
  ~DoipUdpConnection() final = default;
 
  InitializationResult Initialize() override { return InitializationResult::kInitializeOk; }
 
  void Start() override { doip_udp_channel_.Start(); }
 
  void Stop() override { doip_udp_channel_.Stop(); }
 
  bool IsConnectToHost() override { return false; }
 
  uds_transport::UdsTransportProtocolMgr::ConnectionResult ConnectToHost(
      uds_transport::UdsMessageConstPtr) override {
    return (uds_transport::UdsTransportProtocolMgr::ConnectionResult::kConnectionFailed);
  }
 
  uds_transport::UdsTransportProtocolMgr::DisconnectionResult DisconnectFromHost() override {
    return (uds_transport::UdsTransportProtocolMgr::DisconnectionResult::kDisconnectionFailed);
  }
 
  std::pair<uds_transport::UdsTransportProtocolMgr::IndicationResult, uds_transport::UdsMessagePtr>
  IndicateMessage(uds_transport::UdsMessage::Address source_addr,
                  uds_transport::UdsMessage::Address target_addr,
                  uds_transport::UdsMessage::TargetAddressType type,
                  uds_transport::ChannelID channel_id, std::size_t size,
                  uds_transport::Priority priority, uds_transport::ProtocolKind protocol_kind,
                  core_type::Span<std::uint8_t const> payload_info) override {
    // Send Indication to conversion
    return (conversation_handler_.IndicateMessage(source_addr, target_addr, type, channel_id, size,
                                                  priority, protocol_kind, payload_info));
  }
 
  uds_transport::UdsTransportProtocolMgr::TransmissionResult Transmit(
      uds_transport::UdsMessageConstPtr message) override {
    return (doip_udp_channel_.Transmit(std::move(message)));
  }
 
  void HandleMessage(uds_transport::UdsMessagePtr message) override {
    // send full message to conversion
    conversation_handler_.HandleMessage(std::move(message));
  }
 
 private:
  channel::udp_channel::DoipUdpChannel doip_udp_channel_;
};
 
ConnectionManager::ConnectionManager() noexcept : io_context_{} {}
 
std::unique_ptr<uds_transport::Connection> ConnectionManager::CreateTcpConnection(
    uds_transport::ConversionHandler const &conversation, std::string_view tcp_ip_address,
    std::uint16_t port_num) {
  return std::make_unique<DoipTcpConnection>(conversation, tcp_ip_address, port_num);
}
 
std::unique_ptr<uds_transport::Connection> ConnectionManager::CreateUdpConnection(
    uds_transport::ConversionHandler const &conversation, std::string_view udp_ip_address,
    std::uint16_t port_num) {
  return std::make_unique<DoipUdpConnection>(conversation, udp_ip_address, port_num);
}
 
}  // namespace connection
}  // namespace doip_client