voice_assistant.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <esphome/api/bytes.hpp>
#include <esphome/api/model/enums.hpp>
#include <esphome/api/subsystems/subsystem.hpp>
 
#include <cstdint>
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
namespace esphome::api {
 
struct VoiceAudioSettings {
    std::uint32_t noise_suppression_level = 0;
    std::uint32_t auto_gain = 0;
    float volume_multiplier = 0.0F;
};
 
struct VoiceRequest {
    bool start = false;
    std::string conversation_id;
    VoiceAssistantRequestFlag flags = VoiceAssistantRequestFlag::None;
    VoiceAudioSettings audio_settings;
    std::string wake_word_phrase;
};
 
struct VoiceEvent {
    VoiceAssistantEvent event_type = VoiceAssistantEvent::Error;
    std::vector<std::pair<std::string, std::string>> data;
};
 
struct VoiceAudio {
    std::vector<std::uint8_t> data;
    bool end = false;
};
 
struct VoiceTimerEvent {
    VoiceAssistantTimerEvent event_type = VoiceAssistantTimerEvent::Started;
    std::string timer_id;
    std::string name;
    std::uint32_t total_seconds = 0;
    std::uint32_t seconds_left = 0;
    bool is_active = false;
};
 
struct VoiceWakeWord {
    std::string id;
    std::string wake_word;
    std::vector<std::string> trained_languages;
};
 
struct VoiceConfiguration {
    std::vector<VoiceWakeWord> available_wake_words;
    std::vector<std::string> active_wake_words;
    std::uint32_t max_active_wake_words = 0;
};
 
class VoiceAssistant : public Subsystem {
public:
    using RequestHandler = std::function<void(const VoiceRequest&)>;
    using EventHandler = std::function<void(const VoiceEvent&)>;
    using AudioHandler = std::function<void(const VoiceAudio&)>;
    using AnnounceFinishedHandler = std::function<void(bool /*success*/)>;
    using ConfigurationHandler = std::function<void(const VoiceConfiguration&)>;
    using TimerEventHandler = std::function<void(const VoiceTimerEvent&)>;
 
    explicit VoiceAssistant(Client& client) : Subsystem(client) {}
 
    void
    subscribe(VoiceAssistantSubscribeFlag flags, RequestHandler handler, bool subscribe = true);
 
    void on_event(EventHandler handler);
 
    void send_response(std::uint32_t port, bool error = false) const;
 
    void on_audio(AudioHandler handler);
 
    void send_audio(ByteView data, bool end = false) const;
 
    void announce(const std::string& media_id,
                  const std::string& text = {},
                  const std::string& preannounce_media_id = {},
                  bool start_conversation = false) const;
 
    void on_announce_finished(AnnounceFinishedHandler handler);
 
    void request_configuration(ConfigurationHandler handler);
 
    void set_configuration(const std::vector<std::string>& active_wake_words) const;
 
    void on_timer_event(TimerEventHandler handler);
 
private:
    RequestHandler request_handler_;
    EventHandler event_handler_;
    AudioHandler audio_handler_;
    AnnounceFinishedHandler announce_finished_handler_;
    ConfigurationHandler configuration_handler_;
    TimerEventHandler timer_event_handler_;
};
 
}  // namespace esphome::api