connection.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <esphome/api/bytes.hpp>
#include <esphome/api/connection/connection_options.hpp>
#include <esphome/api/connection/connection_state.hpp>
#include <esphome/api/frame/frame_helper.hpp>
#include <esphome/api/proto/proto_message.hpp>
#include <esphome/api/transport/executor.hpp>
#include <esphome/api/transport/transport.hpp>
 
#include <cstdint>
#include <exception>
#include <functional>
#include <memory>
#include <string>
#include <system_error>
#include <vector>
 
namespace esphome::api {
 
struct ServerHello {
    int api_version_major = 0;
    int api_version_minor = 0;
    std::string server_info;
    std::string name;
};
 
class Connection {
public:
    using MessageHandler = std::function<void(const ProtoMessage&)>;
    using RawHandler = std::function<void(std::uint32_t msg_type, ByteView payload)>;
    using StateHandler = std::function<void(ConnectionState)>;
    using ErrorHandler = std::function<void(std::error_code, const std::string&)>;
    using ConnectHandler = std::function<void(std::error_code)>;
 
    Connection(Executor& executor,
               std::unique_ptr<Transport> transport,
               std::unique_ptr<FrameHelper> frame_helper,
               ConnectionOptions options);
    ~Connection();
 
    Connection(const Connection&) = delete;
    Connection& operator=(const Connection&) = delete;
 
    void start(const std::string& host, std::uint16_t port, ConnectHandler on_done);
 
    void send(const ProtoMessage& msg) const;
 
    void send_raw(std::uint32_t msg_type, ByteView payload) const;
 
    void on(std::uint32_t msg_type, MessageHandler handler);
 
    void on_any(MessageHandler handler);
 
    void on_raw(RawHandler handler);
 
    void on_state(StateHandler handler);
 
    void on_error(ErrorHandler handler);
 
    void disconnect();
 
    [[nodiscard]] ConnectionState state() const noexcept {
        return state_;
    }
    [[nodiscard]] const ServerHello& server_hello() const noexcept {
        return hello_;
    }
    [[nodiscard]] bool is_connected() const noexcept {
        return state_ == ConnectionState::Connected;
    }
 
    [[nodiscard]] std::exception_ptr last_error() const noexcept {
        return last_error_;
    }
 
private:
    void set_state(ConnectionState state);
    void on_connected_transport(std::error_code ec);
    void on_bytes(std::error_code ec, ByteView data);
    void drain_frames();
    void handle_frame(std::uint32_t msg_type, ByteView payload);
    void handle_internal(std::uint32_t msg_type, const ProtoMessage& msg);
    void send_hello() const;
    void finish_connect(std::error_code ec);
    void fail(std::error_code ec, const std::string& what);
 
    void start_keepalive();
    void stop_keepalive();
    void send_ping();
 
    Executor& executor_;
    std::unique_ptr<Transport> transport_;
    std::unique_ptr<FrameHelper> frame_helper_;
    ConnectionOptions options_;
 
    ConnectionState state_ = ConnectionState::Disconnected;
    ServerHello hello_;
 
    std::vector<MessageHandler> handlers_;  // indexed by message id
    MessageHandler any_handler_;
    RawHandler raw_handler_;
    StateHandler state_handler_;
    ErrorHandler error_handler_;
    ConnectHandler connect_handler_;
    std::exception_ptr last_error_;
 
    TimerId connect_timer_ = invalid_timer;
    TimerId ping_timer_ = invalid_timer;
    TimerId pong_timer_ = invalid_timer;
    bool awaiting_pong_ = false;
};
 
}  // namespace esphome::api