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 "channel/tcp_channel/doip_tcp_channel.h"
#include "channel/udp_channel/doip_udp_channel.h"
#include "uds_transport/conversation_handler.h"
 
namespace doip_client {
namespace connection {
 
class DoipTcpConnection final : public uds_transport::Connection {
 public:
  using InitializationResult = uds_transport::Connection::InitializationResult;
 
  DoipTcpConnection(uds_transport::ConversionHandler const &conversation_handler, std::string_view tcp_ip_address,
                    std::uint16_t port_num)
      : uds_transport::Connection{1, conversation_handler},
        doip_tcp_channel_{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_.IsConnectToHost()); }
 
  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> payload_info) override {
    // Send Indication to conversation
    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 {
    // send full message to conversion
    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;
 
  DoipUdpConnection(uds_transport::ConversionHandler const &conversation_handler, std::string_view udp_ip_address,
                    std::uint16_t port_num)
      : uds_transport::Connection(1, conversation_handler),
        doip_udp_channel_{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> 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_;
};
 
std::unique_ptr<uds_transport::Connection> DoipConnectionManager::FindOrCreateTcpConnection(
    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> DoipConnectionManager::FindOrCreateUdpConnection(
    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