sendspin_hub.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
 
#ifdef USE_ESP32
 
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/helpers.h"
#include "esphome/core/preferences.h"
 
#include <sendspin/client.h>
#include <sendspin/config.h>
#include <sendspin/types.h>
 
#ifdef USE_SENDSPIN_ARTWORK
#include <sendspin/artwork_role.h>
#endif
#ifdef USE_SENDSPIN_CONTROLLER
#include <sendspin/controller_role.h>
#endif
#ifdef USE_SENDSPIN_METADATA
#include <sendspin/metadata_role.h>
#endif
#ifdef USE_SENDSPIN_PLAYER
#include <sendspin/player_role.h>
#endif
 
#include <functional>
#include <memory>
#include <optional>
 
namespace esphome::sendspin_ {
 
namespace sendspin_priority {
// AFTER_WIFI so the hub runs after the wifi/ethernet drivers are up and we can read the active
// interface's MAC for client_id.
inline constexpr float HUB = esphome::setup_priority::AFTER_WIFI;
inline constexpr float CHILD = HUB - 1.0f;
}  // namespace sendspin_priority
 
struct LastPlayedServerPref {
  uint32_t server_id_hash;
};
 
#ifdef USE_SENDSPIN_PLAYER
struct StaticDelayPref {
  uint16_t delay_ms;
};
#endif
 
class SendspinHub final : public Component,
#ifdef USE_SENDSPIN_ARTWORK
                          public sendspin::ArtworkRoleListener,
#endif
#ifdef USE_SENDSPIN_CONTROLLER
                          public sendspin::ControllerRoleListener,
#endif
#ifdef USE_SENDSPIN_METADATA
                          public sendspin::MetadataRoleListener,
#endif
                          public sendspin::SendspinClientListener,
                          public sendspin::SendspinNetworkProvider,
                          public sendspin::SendspinPersistenceProvider {
 public:
  float get_setup_priority() const override { return sendspin_priority::HUB; }
  void setup() override;
  void loop() override;
  void dump_config() override;
 
  void connect_to_server(const std::string &url);
 
  void disconnect_from_server(sendspin::SendspinGoodbyeReason reason);
 
  void update_state(sendspin::SendspinClientState state);
 
  // --- Configuration setters (called from codegen) ---
 
  template<typename F> void add_group_update_callback(F &&callback) {
    this->group_update_callbacks_.add(std::forward<F>(callback));
  }
 
  void set_task_stack_in_psram(bool task_stack_in_psram) { this->task_stack_in_psram_ = task_stack_in_psram; }
 
  // --- Sendspin role specific methods ---
 
#ifdef USE_SENDSPIN_ARTWORK
  void set_artwork_config(const sendspin::ArtworkRoleConfig &config) { this->artwork_config_ = config; }
 
  void artwork_frame_done(uint8_t slot);
 
  template<typename F> void add_image_decode_callback(F &&callback) {
    this->artwork_image_decode_callbacks_.add(std::forward<F>(callback));
  }
  template<typename F> void add_image_display_callback(F &&callback) {
    this->artwork_image_display_callbacks_.add(std::forward<F>(callback));
  }
  template<typename F> void add_image_clear_callback(F &&callback) {
    this->artwork_image_clear_callbacks_.add(std::forward<F>(callback));
  }
#endif
 
#ifdef USE_SENDSPIN_CONTROLLER
  void send_client_command(sendspin::SendspinControllerCommand command, std::optional<uint8_t> volume = std::nullopt,
                           std::optional<bool> mute = std::nullopt);
 
  template<typename F> void add_controller_state_callback(F &&callback) {
    this->controller_state_callbacks_.add(std::forward<F>(callback));
  }
 
  template<typename F> void add_controller_state_clear_callback(F &&callback) {
    this->controller_state_clear_callbacks_.add(std::forward<F>(callback));
  }
#endif
 
#ifdef USE_SENDSPIN_METADATA
  template<typename F> void add_metadata_update_callback(F &&callback) {
    this->metadata_update_callbacks_.add(std::forward<F>(callback));
  }
 
  uint32_t get_track_progress_ms() const;
#endif
 
#ifdef USE_SENDSPIN_PLAYER
  void set_listener(sendspin::PlayerRoleListener *listener) { this->player_listener_ = listener; }
  void set_player_config(const sendspin::PlayerRoleConfig &config) { this->player_config_ = config; }
 
  sendspin::PlayerRole *get_player_role();
#endif
 
 protected:
  sendspin::SendspinClientConfig build_client_config_();
 
  static const char *get_client_id_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
 
  // --- SendspinClientListener overrides ---
  void on_group_update(const sendspin::GroupUpdateObject &group) override;
 
  void on_request_high_performance() override;
 
  void on_release_high_performance() override;
 
  // --- SendspinNetworkProvider override ---
  bool is_network_ready() override;
 
  // --- SendspinPersistenceProvider overrides ---
  bool save_last_server_hash(uint32_t hash) override;
  std::optional<uint32_t> load_last_server_hash() override;
 
  // --- Sendspin role specific methods/overrides/member variables ---
 
#ifdef USE_SENDSPIN_ARTWORK
  void on_image_decode(uint8_t slot, const uint8_t *data, size_t length, sendspin::SendspinImageFormat format) override;
 
  void on_image_display(uint8_t slot, uint32_t lateness_ms) override;
 
  void on_image_clear(uint8_t slot) override;
 
  sendspin::ArtworkRoleConfig artwork_config_{};
  sendspin::ArtworkRole *artwork_role_{nullptr};
 
  // Callback fan-out to child components; they filter by slot as needed.
  CallbackManager<void(uint8_t, const uint8_t *, size_t, sendspin::SendspinImageFormat)>
      artwork_image_decode_callbacks_{};
  CallbackManager<void(uint8_t, uint32_t)> artwork_image_display_callbacks_{};
  CallbackManager<void(uint8_t)> artwork_image_clear_callbacks_{};
#endif
 
#ifdef USE_SENDSPIN_CONTROLLER
  sendspin::ControllerRole *controller_role_{nullptr};
 
  void on_controller_state(const sendspin::ServerStateControllerObject &state) override;
 
  void on_controller_state_clear() override;
 
  // Callback fan-out to child components; they filter as needed. Only a media_player subscribes, while the switch
  // action and the media source enable the controller role without one, so keep the idle cost to a single pointer.
  LazyCallbackManager<void(const sendspin::ServerStateControllerObject &)> controller_state_callbacks_{};
  LazyCallbackManager<void()> controller_state_clear_callbacks_{};
#endif
 
#ifdef USE_SENDSPIN_METADATA
  sendspin::MetadataRole *metadata_role_{nullptr};
 
  void on_metadata(const sendspin::ServerMetadataStateObject &metadata) override;
 
  void on_metadata_clear() override;
 
  // Callback fan-out to child components; they filter as needed
  CallbackManager<void(const sendspin::ServerMetadataStateObject &)> metadata_update_callbacks_{};
#endif
 
#ifdef USE_SENDSPIN_PLAYER
  sendspin::PlayerRoleListener *player_listener_{nullptr};
  sendspin::PlayerRoleConfig player_config_{};
 
  // Part of SendspinPersistenceProvider overrides
  ESPPreferenceObject static_delay_pref_;
  std::optional<uint16_t> load_static_delay() override;
  bool save_static_delay(uint16_t delay_ms) override;
#endif
 
  // --- Core member variables ---
 
  ESPPreferenceObject last_played_server_pref_;
 
  std::unique_ptr<sendspin::SendspinClient> client_;
 
  // Callback fan-out to child components
  CallbackManager<void(const sendspin::GroupUpdateObject &)> group_update_callbacks_{};
 
  bool task_stack_in_psram_{false};
};
 
class SendspinChild : public Component, public Parented<SendspinHub> {
 public:
  float get_setup_priority() const override { return sendspin_priority::CHILD; }
};
 
class SendspinPollingChild : public PollingComponent, public Parented<SendspinHub> {
 public:
  float get_setup_priority() const override { return sendspin_priority::CHILD; }
};
 
}  // namespace esphome::sendspin_
 
#endif  // USE_ESP32