esphome 2025.2.1__py3-none-any.whl → 2025.3.0__py3-none-any.whl

esphome/components/ld2450/sensor.py

@@ -0,0 +1,156 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ANGLE,
+    CONF_DISTANCE,
+    CONF_RESOLUTION,
+    CONF_SPEED,
+    DEVICE_CLASS_DISTANCE,
+    DEVICE_CLASS_SPEED,
+    UNIT_DEGREES,
+    UNIT_MILLIMETER,
+)
+
+from . import CONF_LD2450_ID, LD2450Component
+
+DEPENDENCIES = ["ld2450"]
+
+CONF_MOVING_TARGET_COUNT = "moving_target_count"
+CONF_STILL_TARGET_COUNT = "still_target_count"
+CONF_TARGET_COUNT = "target_count"
+CONF_X = "x"
+CONF_Y = "y"
+
+ICON_ACCOUNT_GROUP = "mdi:account-group"
+ICON_ACCOUNT_SWITCH = "mdi:account-switch"
+ICON_ALPHA_X_BOX_OUTLINE = "mdi:alpha-x-box-outline"
+ICON_ALPHA_Y_BOX_OUTLINE = "mdi:alpha-y-box-outline"
+ICON_FORMAT_TEXT_ROTATION_ANGLE_UP = "mdi:format-text-rotation-angle-up"
+ICON_HUMAN_GREETING_PROXIMITY = "mdi:human-greeting-proximity"
+ICON_MAP_MARKER_ACCOUNT = "mdi:map-marker-account"
+ICON_MAP_MARKER_DISTANCE = "mdi:map-marker-distance"
+ICON_RELATION_ZERO_OR_ONE_TO_ZERO_OR_ONE = "mdi:relation-zero-or-one-to-zero-or-one"
+ICON_SPEEDOMETER_SLOW = "mdi:speedometer-slow"
+
+MAX_TARGETS = 3
+MAX_ZONES = 3
+
+UNIT_MILLIMETER_PER_SECOND = "mm/s"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+        cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
+            icon=ICON_ACCOUNT_GROUP,
+        ),
+        cv.Optional(CONF_STILL_TARGET_COUNT): sensor.sensor_schema(
+            icon=ICON_HUMAN_GREETING_PROXIMITY,
+        ),
+        cv.Optional(CONF_MOVING_TARGET_COUNT): sensor.sensor_schema(
+            icon=ICON_ACCOUNT_SWITCH,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"target_{n + 1}"): cv.Schema(
+            {
+                cv.Optional(CONF_X): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_ALPHA_X_BOX_OUTLINE,
+                ),
+                cv.Optional(CONF_Y): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_ALPHA_Y_BOX_OUTLINE,
+                ),
+                cv.Optional(CONF_SPEED): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_SPEED,
+                    unit_of_measurement=UNIT_MILLIMETER_PER_SECOND,
+                    icon=ICON_SPEEDOMETER_SLOW,
+                ),
+                cv.Optional(CONF_ANGLE): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_DEGREES,
+                    icon=ICON_FORMAT_TEXT_ROTATION_ANGLE_UP,
+                ),
+                cv.Optional(CONF_DISTANCE): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_MAP_MARKER_DISTANCE,
+                ),
+                cv.Optional(CONF_RESOLUTION): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_RELATION_ZERO_OR_ONE_TO_ZERO_OR_ONE,
+                ),
+            }
+        )
+        for n in range(MAX_TARGETS)
+    },
+    {
+        cv.Optional(f"zone_{n + 1}"): cv.Schema(
+            {
+                cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
+                    icon=ICON_MAP_MARKER_ACCOUNT,
+                ),
+                cv.Optional(CONF_STILL_TARGET_COUNT): sensor.sensor_schema(
+                    icon=ICON_MAP_MARKER_ACCOUNT,
+                ),
+                cv.Optional(CONF_MOVING_TARGET_COUNT): sensor.sensor_schema(
+                    icon=ICON_MAP_MARKER_ACCOUNT,
+                ),
+            }
+        )
+        for n in range(MAX_ZONES)
+    },
+)
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+
+    if target_count_config := config.get(CONF_TARGET_COUNT):
+        sens = await sensor.new_sensor(target_count_config)
+        cg.add(ld2450_component.set_target_count_sensor(sens))
+
+    if still_target_count_config := config.get(CONF_STILL_TARGET_COUNT):
+        sens = await sensor.new_sensor(still_target_count_config)
+        cg.add(ld2450_component.set_still_target_count_sensor(sens))
+
+    if moving_target_count_config := config.get(CONF_MOVING_TARGET_COUNT):
+        sens = await sensor.new_sensor(moving_target_count_config)
+        cg.add(ld2450_component.set_moving_target_count_sensor(sens))
+    for n in range(MAX_TARGETS):
+        if target_conf := config.get(f"target_{n + 1}"):
+            if x_config := target_conf.get(CONF_X):
+                sens = await sensor.new_sensor(x_config)
+                cg.add(ld2450_component.set_move_x_sensor(n, sens))
+            if y_config := target_conf.get(CONF_Y):
+                sens = await sensor.new_sensor(y_config)
+                cg.add(ld2450_component.set_move_y_sensor(n, sens))
+            if speed_config := target_conf.get(CONF_SPEED):
+                sens = await sensor.new_sensor(speed_config)
+                cg.add(ld2450_component.set_move_speed_sensor(n, sens))
+            if angle_config := target_conf.get(CONF_ANGLE):
+                sens = await sensor.new_sensor(angle_config)
+                cg.add(ld2450_component.set_move_angle_sensor(n, sens))
+            if distance_config := target_conf.get(CONF_DISTANCE):
+                sens = await sensor.new_sensor(distance_config)
+                cg.add(ld2450_component.set_move_distance_sensor(n, sens))
+            if resolution_config := target_conf.get(CONF_RESOLUTION):
+                sens = await sensor.new_sensor(resolution_config)
+                cg.add(ld2450_component.set_move_resolution_sensor(n, sens))
+    for n in range(MAX_ZONES):
+        if zone_config := config.get(f"zone_{n + 1}"):
+            if target_count_config := zone_config.get(CONF_TARGET_COUNT):
+                sens = await sensor.new_sensor(target_count_config)
+                cg.add(ld2450_component.set_zone_target_count_sensor(n, sens))
+            if still_target_count_config := zone_config.get(CONF_STILL_TARGET_COUNT):
+                sens = await sensor.new_sensor(still_target_count_config)
+                cg.add(ld2450_component.set_zone_still_target_count_sensor(n, sens))
+            if moving_target_count_config := zone_config.get(CONF_MOVING_TARGET_COUNT):
+                sens = await sensor.new_sensor(moving_target_count_config)
+                cg.add(ld2450_component.set_zone_moving_target_count_sensor(n, sens))

esphome/components/ld2450/switch/__init__.py

@@ -0,0 +1,45 @@
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_SWITCH,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_BLUETOOTH,
+    ICON_PULSE,
+)
+
+from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
+
+BluetoothSwitch = ld2450_ns.class_("BluetoothSwitch", switch.Switch)
+MultiTargetSwitch = ld2450_ns.class_("MultiTargetSwitch", switch.Switch)
+
+CONF_BLUETOOTH = "bluetooth"
+CONF_MULTI_TARGET = "multi_target"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+    cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
+        BluetoothSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_BLUETOOTH,
+    ),
+    cv.Optional(CONF_MULTI_TARGET): switch.switch_schema(
+        MultiTargetSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_PULSE,
+    ),
+}
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+    if bluetooth_config := config.get(CONF_BLUETOOTH):
+        s = await switch.new_switch(bluetooth_config)
+        await cg.register_parented(s, config[CONF_LD2450_ID])
+        cg.add(ld2450_component.set_bluetooth_switch(s))
+    if multi_target_config := config.get(CONF_MULTI_TARGET):
+        s = await switch.new_switch(multi_target_config)
+        await cg.register_parented(s, config[CONF_LD2450_ID])
+        cg.add(ld2450_component.set_multi_target_switch(s))

esphome/components/ld2450/switch/bluetooth_switch.cpp

@@ -0,0 +1,12 @@
+#include "bluetooth_switch.h"
+
+namespace esphome {
+namespace ld2450 {
+
+void BluetoothSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_bluetooth(state);
+}
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/switch/bluetooth_switch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2450.h"
+
+namespace esphome {
+namespace ld2450 {
+
+class BluetoothSwitch : public switch_::Switch, public Parented<LD2450Component> {
+ public:
+  BluetoothSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/switch/multi_target_switch.cpp

@@ -0,0 +1,12 @@
+#include "multi_target_switch.h"
+
+namespace esphome {
+namespace ld2450 {
+
+void MultiTargetSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_multi_target(state);
+}
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/switch/multi_target_switch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2450.h"
+
+namespace esphome {
+namespace ld2450 {
+
+class MultiTargetSwitch : public switch_::Switch, public Parented<LD2450Component> {
+ public:
+  MultiTargetSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/text_sensor.py

@@ -0,0 +1,62 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_DIRECTION,
+    CONF_MAC_ADDRESS,
+    CONF_VERSION,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ENTITY_CATEGORY_NONE,
+    ICON_BLUETOOTH,
+    ICON_CHIP,
+    ICON_SIGN_DIRECTION,
+)
+
+from . import CONF_LD2450_ID, LD2450Component
+
+DEPENDENCIES = ["ld2450"]
+
+MAX_TARGETS = 3
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+        cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            icon=ICON_CHIP,
+        ),
+        cv.Optional(CONF_MAC_ADDRESS): text_sensor.text_sensor_schema(
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            icon=ICON_BLUETOOTH,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"target_{n + 1}"): cv.Schema(
+            {
+                cv.Optional(CONF_DIRECTION): text_sensor.text_sensor_schema(
+                    entity_category=ENTITY_CATEGORY_NONE,
+                    icon=ICON_SIGN_DIRECTION,
+                ),
+            }
+        )
+        for n in range(MAX_TARGETS)
+    }
+)
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+    if version_config := config.get(CONF_VERSION):
+        sens = await text_sensor.new_text_sensor(version_config)
+        cg.add(ld2450_component.set_version_text_sensor(sens))
+    if mac_address_config := config.get(CONF_MAC_ADDRESS):
+        sens = await text_sensor.new_text_sensor(mac_address_config)
+        cg.add(ld2450_component.set_mac_text_sensor(sens))
+    for n in range(MAX_TARGETS):
+        if direction_conf := config.get(f"target_{n + 1}"):
+            if direction_config := direction_conf.get(CONF_DIRECTION):
+                sens = await text_sensor.new_text_sensor(direction_config)
+                cg.add(ld2450_component.set_direction_text_sensor(n, sens))

esphome/components/ltr390/ltr390.cpp

@@ -1,7 +1,7 @@
 #include "ltr390.h"
+#include <bitset>
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include <bitset>
 
 namespace esphome {
 namespace ltr390 {
@@ -91,7 +91,12 @@ void LTR390Component::read_uvs_() {
   uint32_t uv = *val;
 
   if (this->uvi_sensor_ != nullptr) {
-    this->uvi_sensor_->publish_state((uv / this->sensitivity_uv_) * this->wfac_);
+    // Set sensitivity by linearly scaling against known value in the datasheet
+    float gain_scale_uv = GAINVALUES[this->gain_uv_] / GAIN_MAX;
+    float intg_scale_uv = (RESOLUTIONVALUE[this->res_uv_] * 100) / INTG_MAX;
+    float sensitivity_uv = SENSITIVITY_MAX * gain_scale_uv * intg_scale_uv;
+
+    this->uvi_sensor_->publish_state((uv / sensitivity_uv) * this->wfac_);
   }
 
   if (this->uv_sensor_ != nullptr) {
@@ -166,11 +171,6 @@ void LTR390Component::setup() {
     return;
   }
 
-  // Set sensitivity by linearly scaling against known value in the datasheet
-  float gain_scale_uv = GAINVALUES[this->gain_uv_] / GAIN_MAX;
-  float intg_scale_uv = (RESOLUTIONVALUE[this->res_uv_] * 100) / INTG_MAX;
-  this->sensitivity_uv_ = SENSITIVITY_MAX * gain_scale_uv * intg_scale_uv;
-
   // Set sensor read state
   this->reading_ = false;
 

esphome/components/ltr390/ltr390.h

@@ -77,7 +77,6 @@ class LTR390Component : public PollingComponent, public i2c::I2CDevice {
   LTR390GAIN gain_uv_;
   LTR390RESOLUTION res_als_;
   LTR390RESOLUTION res_uv_;
-  float sensitivity_uv_;
   float wfac_;
 
   sensor::Sensor *light_sensor_{nullptr};

esphome/components/lvgl/defines.py

@@ -462,8 +462,6 @@ CONF_LVGL_ID = "lvgl_id"
 CONF_LONG_MODE = "long_mode"
 CONF_MSGBOXES = "msgboxes"
 CONF_OBJ = "obj"
-CONF_OFFSET_X = "offset_x"
-CONF_OFFSET_Y = "offset_y"
 CONF_ONE_CHECKED = "one_checked"
 CONF_ONE_LINE = "one_line"
 CONF_ON_PAUSE = "on_pause"

esphome/components/lvgl/font.cpp

@@ -19,7 +19,7 @@ static bool get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, ui
   const auto *gd = fe->get_glyph_data(unicode_letter);
   if (gd == nullptr)
     return false;
-  dsc->adv_w = gd->offset_x + gd->width;
+  dsc->adv_w = gd->advance;
   dsc->ofs_x = gd->offset_x;
   dsc->ofs_y = fe->height - gd->height - gd->offset_y - fe->baseline;
   dsc->box_w = gd->width;

esphome/components/lvgl/lvgl_esphome.cpp

@@ -416,37 +416,45 @@ LvglComponent::LvglComponent(std::vector<display::Display *> displays, float buf
       buffer_frac_(buffer_frac),
       full_refresh_(full_refresh),
       resume_on_input_(resume_on_input) {
-  auto *display = this->displays_[0];
-  size_t buffer_pixels = display->get_width() * display->get_height() / this->buffer_frac_;
-  auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
-  this->rotation = display->get_rotation();
-  if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
-    this->rotate_buf_ = static_cast<lv_color_t *>(lv_custom_mem_alloc(buf_bytes));  // NOLINT
-    if (this->rotate_buf_ == nullptr)
-      return;
-  }
-  auto *buf = lv_custom_mem_alloc(buf_bytes);  // NOLINT
-  if (buf == nullptr)
-    return;
-  lv_disp_draw_buf_init(&this->draw_buf_, buf, nullptr, buffer_pixels);
+  lv_disp_draw_buf_init(&this->draw_buf_, nullptr, nullptr, 0);
   lv_disp_drv_init(&this->disp_drv_);
   this->disp_drv_.draw_buf = &this->draw_buf_;
   this->disp_drv_.user_data = this;
   this->disp_drv_.full_refresh = this->full_refresh_;
   this->disp_drv_.flush_cb = static_flush_cb;
   this->disp_drv_.rounder_cb = rounder_cb;
-  this->disp_drv_.hor_res = (lv_coord_t) display->get_width();
-  this->disp_drv_.ver_res = (lv_coord_t) display->get_height();
+  this->disp_drv_.hor_res = 0;
+  this->disp_drv_.ver_res = 0;
   this->disp_ = lv_disp_drv_register(&this->disp_drv_);
 }
 
 void LvglComponent::setup() {
-  if (this->draw_buf_.buf1 == nullptr) {
+  ESP_LOGCONFIG(TAG, "LVGL Setup starts");
+  auto *display = this->displays_[0];
+  auto width = display->get_width();
+  auto height = display->get_height();
+  size_t buffer_pixels = width * height / this->buffer_frac_;
+  auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
+  auto *buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
+  if (buffer == nullptr) {
     this->mark_failed();
     this->status_set_error("Memory allocation failure");
     return;
   }
-  ESP_LOGCONFIG(TAG, "LVGL Setup starts");
+  lv_disp_draw_buf_init(&this->draw_buf_, buffer, nullptr, buf_bytes);
+  this->disp_drv_.hor_res = width;
+  this->disp_drv_.ver_res = height;
+  // this->setup_driver_(display->get_width(), display->get_height());
+  lv_disp_drv_update(this->disp_, &this->disp_drv_);
+  this->rotation = display->get_rotation();
+  if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
+    this->rotate_buf_ = static_cast<lv_color_t *>(lv_custom_mem_alloc(this->draw_buf_.size));  // NOLINT
+    if (this->rotate_buf_ == nullptr) {
+      this->mark_failed();
+      this->status_set_error("Memory allocation failure");
+      return;
+    }
+  }
 #if LV_USE_LOG
   lv_log_register_print_cb([](const char *buf) {
     auto next = strchr(buf, ')');
@@ -458,8 +466,8 @@ void LvglComponent::setup() {
   });
 #endif
   // Rotation will be handled by our drawing function, so reset the display rotation.
-  for (auto *display : this->displays_)
-    display->set_rotation(display::DISPLAY_ROTATION_0_DEGREES);
+  for (auto *disp : this->displays_)
+    disp->set_rotation(display::DISPLAY_ROTATION_0_DEGREES);
   this->show_page(0, LV_SCR_LOAD_ANIM_NONE, 0);
   lv_disp_trig_activity(this->disp_);
   ESP_LOGCONFIG(TAG, "LVGL Setup complete");

esphome/components/lvgl/widgets/img.py

@@ -1,11 +1,9 @@
 import esphome.config_validation as cv
-from esphome.const import CONF_ANGLE, CONF_MODE
+from esphome.const import CONF_ANGLE, CONF_MODE, CONF_OFFSET_X, CONF_OFFSET_Y
 
 from ..defines import (
     CONF_ANTIALIAS,
     CONF_MAIN,
-    CONF_OFFSET_X,
-    CONF_OFFSET_Y,
     CONF_PIVOT_X,
     CONF_PIVOT_Y,
     CONF_SRC,

esphome/components/mcp2515/mcp2515.cpp

@@ -550,6 +550,7 @@ canbus::Error MCP2515::set_bitrate_(canbus::CanSpeed can_speed, CanClock can_clo
           cfg3 = MCP_16MHZ_40KBPS_CFG3;
           break;
         case (canbus::CAN_50KBPS):  //  50Kbps
+          cfg1 = MCP_16MHZ_50KBPS_CFG1;
           cfg2 = MCP_16MHZ_50KBPS_CFG2;
           cfg3 = MCP_16MHZ_50KBPS_CFG3;
           break;

esphome/components/mdns/__init__.py

@@ -91,7 +91,7 @@ async def to_code(config):
         add_idf_component(
             name="mdns",
             repo="https://github.com/espressif/esp-protocols.git",
-            ref="mdns-v1.5.1",
+            ref="mdns-v1.8.0",
             path="components/mdns",
         )
 

esphome/components/mixer/speaker/mixer_speaker.cpp

@@ -177,11 +177,15 @@ void SourceSpeaker::set_mute_state(bool mute_state) {
   this->parent_->get_output_speaker()->set_mute_state(mute_state);
 }
 
+bool SourceSpeaker::get_mute_state() { return this->parent_->get_output_speaker()->get_mute_state(); }
+
 void SourceSpeaker::set_volume(float volume) {
   this->volume_ = volume;
   this->parent_->get_output_speaker()->set_volume(volume);
 }
 
+float SourceSpeaker::get_volume() { return this->parent_->get_output_speaker()->get_volume(); }
+
 size_t SourceSpeaker::process_data_from_source(TickType_t ticks_to_wait) {
   if (!this->transfer_buffer_.use_count()) {
     return 0;
@@ -490,7 +494,8 @@ void MixerSpeaker::audio_mixer_task(void *params) {
       break;
     }
 
-    output_transfer_buffer->transfer_data_to_sink(pdMS_TO_TICKS(TASK_DELAY_MS));
+    // Never shift the data in the output transfer buffer to avoid unnecessary, slow data moves
+    output_transfer_buffer->transfer_data_to_sink(pdMS_TO_TICKS(TASK_DELAY_MS), false);
 
     const uint32_t output_frames_free =
         this_mixer->audio_stream_info_.value().bytes_to_frames(output_transfer_buffer->free());

esphome/components/mixer/speaker/mixer_speaker.h

@@ -53,9 +53,11 @@ class SourceSpeaker : public speaker::Speaker, public Component {
 
   /// @brief Mute state changes are passed to the parent's output speaker
   void set_mute_state(bool mute_state) override;
+  bool get_mute_state() override;
 
   /// @brief Volume state changes are passed to the parent's output speaker
   void set_volume(float volume) override;
+  float get_volume() override;
 
   void set_pause_state(bool pause_state) override { this->pause_state_ = pause_state; }
   bool get_pause_state() const override { return this->pause_state_; }