sync_client.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <esphome/api/client.hpp>
#include <esphome/api/client_options.hpp>
#include <esphome/api/connection/connection.hpp>
#include <esphome/api/connection/connection_state.hpp>
#include <esphome/api/model/device_info.hpp>
#include <esphome/api/model/entity_registry.hpp>
#include <esphome/api/model/entity_store.hpp>
 
#include <chrono>
#include <functional>
 
namespace esphome::api {
 
class SyncClient {
public:
    explicit SyncClient(const ClientOptions& options);
 
    void connect() const;
 
    void disconnect() const;
 
    [[nodiscard]] bool is_connected() const {
        return client_.is_connected();
    }
    [[nodiscard]] ConnectionState state() const {
        return client_.state();
    }
    [[nodiscard]] const ServerHello& server_hello() const {
        return client_.server_hello();
    }
 
    DeviceInfo device_info() const;
 
    void list_entities() const;
 
    void subscribe_states() const;
 
    [[nodiscard]] EntityRegistry entities() {
        return client_.entities();
    }
    [[nodiscard]] EntityStore& store() noexcept {
        return client_.store();
    }
    [[nodiscard]] const EntityStore& store() const noexcept {
        return client_.store();
    }
 
    // --- Subsystems (delegated to the async client) --------------------------
    [[nodiscard]] BluetoothProxy& bluetooth() {
        return client_.bluetooth();
    }
    [[nodiscard]] LogStream& logs() {
        return client_.logs();
    }
    [[nodiscard]] HomeAssistantServices& home_assistant() {
        return client_.home_assistant();
    }
    [[nodiscard]] VoiceAssistant& voice() {
        return client_.voice();
    }
    [[nodiscard]] ZWaveProxy& zwave() {
        return client_.zwave();
    }
    [[nodiscard]] SerialProxy& serial() {
        return client_.serial();
    }
    [[nodiscard]] SerialPort serial_proxy(std::uint32_t instance);
 
    [[nodiscard]] SerialPort serial_proxy(const std::string& name);
 
    void set_request_timeout(const std::chrono::milliseconds timeout) {
        request_timeout_ = timeout;
    }
 
    void pump_until(const std::function<bool()>& predicate,
                    std::chrono::milliseconds timeout) const;
 
    [[nodiscard]] Client& async() {
        return client_;
    }
 
private:
    Client client_;
    bool subscribe_on_connect_ = true;
    std::chrono::milliseconds request_timeout_{30000};
    std::chrono::milliseconds connect_pump_timeout_;
};
 
}  // namespace esphome::api