esphome 2025.7.5__py3-none-any.whl → 2025.8.0__py3-none-any.whl

esphome/components/mcp23x08_base/mcp23x08_base.cpp

@@ -6,19 +6,21 @@ namespace mcp23x08_base {
 
 static const char *const TAG = "mcp23x08_base";
 
-bool MCP23X08Base::digital_read(uint8_t pin) {
-  uint8_t bit = pin % 8;
-  uint8_t reg_addr = mcp23x08_base::MCP23X08_GPIO;
-  uint8_t value = 0;
-  this->read_reg(reg_addr, &value);
-  return value & (1 << bit);
+bool MCP23X08Base::digital_read_hw(uint8_t pin) {
+  if (!this->read_reg(mcp23x08_base::MCP23X08_GPIO, &this->input_mask_)) {
+    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+    return false;
+  }
+  return true;
 }
 
-void MCP23X08Base::digital_write(uint8_t pin, bool value) {
+void MCP23X08Base::digital_write_hw(uint8_t pin, bool value) {
   uint8_t reg_addr = mcp23x08_base::MCP23X08_OLAT;
   this->update_reg(pin, value, reg_addr);
 }
 
+bool MCP23X08Base::digital_read_cache(uint8_t pin) { return this->input_mask_ & (1 << pin); }
+
 void MCP23X08Base::pin_mode(uint8_t pin, gpio::Flags flags) {
   uint8_t iodir = mcp23x08_base::MCP23X08_IODIR;
   uint8_t gppu = mcp23x08_base::MCP23X08_GPPU;

esphome/components/mcp23x08_base/mcp23x08_base.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/components/mcp23xxx_base/mcp23xxx_base.h"
+#include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 
 namespace esphome {
@@ -22,10 +22,12 @@ enum MCP23S08GPIORegisters {
   MCP23X08_OLAT = 0x0A,
 };
 
-class MCP23X08Base : public mcp23xxx_base::MCP23XXXBase {
+class MCP23X08Base : public mcp23xxx_base::MCP23XXXBase<8> {
  public:
-  bool digital_read(uint8_t pin) override;
-  void digital_write(uint8_t pin, bool value) override;
+  bool digital_read_hw(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+  bool digital_read_cache(uint8_t pin) override;
+
   void pin_mode(uint8_t pin, gpio::Flags flags) override;
   void pin_interrupt_mode(uint8_t pin, mcp23xxx_base::MCP23XXXInterruptMode interrupt_mode) override;
 
@@ -33,6 +35,9 @@ class MCP23X08Base : public mcp23xxx_base::MCP23XXXBase {
   void update_reg(uint8_t pin, bool pin_value, uint8_t reg_a) override;
 
   uint8_t olat_{0x00};
+
+  /// State read in digital_read_hw
+  uint8_t input_mask_{0x00};
 };
 
 }  // namespace mcp23x08_base

esphome/components/mcp23x17_base/__init__.py

@@ -4,5 +4,7 @@ from esphome.components import mcp23xxx_base
 AUTO_LOAD = ["mcp23xxx_base"]
 CODEOWNERS = ["@jesserockz"]
 
+NUM_PINS = 16
+
 mcp23x17_base_ns = cg.esphome_ns.namespace("mcp23x17_base")
 MCP23X17Base = mcp23x17_base_ns.class_("MCP23X17Base", mcp23xxx_base.MCP23XXXBase)

esphome/components/mcp23x17_base/mcp23x17_base.cpp

@@ -1,4 +1,5 @@
 #include "mcp23x17_base.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -6,19 +7,31 @@ namespace mcp23x17_base {
 
 static const char *const TAG = "mcp23x17_base";
 
-bool MCP23X17Base::digital_read(uint8_t pin) {
-  uint8_t bit = pin % 8;
-  uint8_t reg_addr = pin < 8 ? mcp23x17_base::MCP23X17_GPIOA : mcp23x17_base::MCP23X17_GPIOB;
-  uint8_t value = 0;
-  this->read_reg(reg_addr, &value);
-  return value & (1 << bit);
+bool MCP23X17Base::digital_read_hw(uint8_t pin) {
+  uint8_t data;
+  if (pin < 8) {
+    if (!this->read_reg(mcp23x17_base::MCP23X17_GPIOA, &data)) {
+      this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+      return false;
+    }
+    this->input_mask_ = encode_uint16(this->input_mask_ >> 8, data);
+  } else {
+    if (!this->read_reg(mcp23x17_base::MCP23X17_GPIOB, &data)) {
+      this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+      return false;
+    }
+    this->input_mask_ = encode_uint16(data, this->input_mask_ & 0xFF);
+  }
+  return true;
 }
 
-void MCP23X17Base::digital_write(uint8_t pin, bool value) {
+void MCP23X17Base::digital_write_hw(uint8_t pin, bool value) {
   uint8_t reg_addr = pin < 8 ? mcp23x17_base::MCP23X17_OLATA : mcp23x17_base::MCP23X17_OLATB;
   this->update_reg(pin, value, reg_addr);
 }
 
+bool MCP23X17Base::digital_read_cache(uint8_t pin) { return this->input_mask_ & (1 << pin); }
+
 void MCP23X17Base::pin_mode(uint8_t pin, gpio::Flags flags) {
   uint8_t iodir = pin < 8 ? mcp23x17_base::MCP23X17_IODIRA : mcp23x17_base::MCP23X17_IODIRB;
   uint8_t gppu = pin < 8 ? mcp23x17_base::MCP23X17_GPPUA : mcp23x17_base::MCP23X17_GPPUB;

esphome/components/mcp23x17_base/mcp23x17_base.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/components/mcp23xxx_base/mcp23xxx_base.h"
+#include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 
 namespace esphome {
@@ -34,10 +34,12 @@ enum MCP23X17GPIORegisters {
   MCP23X17_OLATB = 0x15,
 };
 
-class MCP23X17Base : public mcp23xxx_base::MCP23XXXBase {
+class MCP23X17Base : public mcp23xxx_base::MCP23XXXBase<16> {
  public:
-  bool digital_read(uint8_t pin) override;
-  void digital_write(uint8_t pin, bool value) override;
+  bool digital_read_hw(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+  bool digital_read_cache(uint8_t pin) override;
+
   void pin_mode(uint8_t pin, gpio::Flags flags) override;
   void pin_interrupt_mode(uint8_t pin, mcp23xxx_base::MCP23XXXInterruptMode interrupt_mode) override;
 
@@ -46,6 +48,9 @@ class MCP23X17Base : public mcp23xxx_base::MCP23XXXBase {
 
   uint8_t olat_a_{0x00};
   uint8_t olat_b_{0x00};
+
+  /// State read in digital_read_hw
+  uint16_t input_mask_{0x00};
 };
 
 }  // namespace mcp23x17_base

esphome/components/mcp23xxx_base/__init__.py

@@ -12,8 +12,9 @@ from esphome.const import (
     CONF_OUTPUT,
     CONF_PULLUP,
 )
-from esphome.core import coroutine
+from esphome.core import CORE, ID, coroutine
 
+AUTO_LOAD = ["gpio_expander"]
 CODEOWNERS = ["@jesserockz"]
 
 mcp23xxx_base_ns = cg.esphome_ns.namespace("mcp23xxx_base")
@@ -36,9 +37,11 @@ MCP23XXX_CONFIG_SCHEMA = cv.Schema(
 
 
 @coroutine
-async def register_mcp23xxx(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+async def register_mcp23xxx(config, num_pins):
+    id: ID = config[CONF_ID]
+    var = cg.new_Pvariable(id)
     await cg.register_component(var, config)
+    CORE.data.setdefault(CONF_MCP23XXX, {})[id.id] = num_pins
     cg.add(var.set_open_drain_ints(config[CONF_OPEN_DRAIN_INTERRUPT]))
     return var
 
@@ -73,9 +76,12 @@ MCP23XXX_PIN_SCHEMA = pins.gpio_base_schema(
 
 @pins.PIN_SCHEMA_REGISTRY.register(CONF_MCP23XXX, MCP23XXX_PIN_SCHEMA)
 async def mcp23xxx_pin_to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    parent = await cg.get_variable(config[CONF_MCP23XXX])
+    parent_id: ID = config[CONF_MCP23XXX]
+    parent = await cg.get_variable(parent_id)
 
+    num_pins = cg.TemplateArguments(CORE.data[CONF_MCP23XXX][parent_id.id])
+
+    var = cg.new_Pvariable(config[CONF_ID], num_pins)
     cg.add(var.set_parent(parent))
 
     num = config[CONF_NUMBER]

esphome/components/mcp23xxx_base/mcp23xxx_base.cpp

@@ -1,24 +1,27 @@
 #include "mcp23xxx_base.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
 namespace mcp23xxx_base {
 
-float MCP23XXXBase::get_setup_priority() const { return setup_priority::IO; }
-
-void MCP23XXXGPIOPin::setup() {
-  pin_mode(flags_);
+template<uint8_t N> void MCP23XXXGPIOPin<N>::setup() {
+  this->pin_mode(flags_);
   this->parent_->pin_interrupt_mode(this->pin_, this->interrupt_mode_);
 }
-
-void MCP23XXXGPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
-bool MCP23XXXGPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
-void MCP23XXXGPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
-std::string MCP23XXXGPIOPin::dump_summary() const {
-  char buffer[32];
-  snprintf(buffer, sizeof(buffer), "%u via MCP23XXX", pin_);
-  return buffer;
+template<uint8_t N> void MCP23XXXGPIOPin<N>::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
+template<uint8_t N> bool MCP23XXXGPIOPin<N>::digital_read() {
+  return this->parent_->digital_read(this->pin_) != this->inverted_;
+}
+template<uint8_t N> void MCP23XXXGPIOPin<N>::digital_write(bool value) {
+  this->parent_->digital_write(this->pin_, value != this->inverted_);
 }
+template<uint8_t N> std::string MCP23XXXGPIOPin<N>::dump_summary() const {
+  return str_snprintf("%u via MCP23XXX", 15, pin_);
+}
+
+template class MCP23XXXGPIOPin<8>;
+template class MCP23XXXGPIOPin<16>;
 
 }  // namespace mcp23xxx_base
 }  // namespace esphome

esphome/components/mcp23xxx_base/mcp23xxx_base.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "esphome/components/gpio_expander/cached_gpio.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 
@@ -8,15 +9,15 @@ namespace mcp23xxx_base {
 
 enum MCP23XXXInterruptMode : uint8_t { MCP23XXX_NO_INTERRUPT = 0, MCP23XXX_CHANGE, MCP23XXX_RISING, MCP23XXX_FALLING };
 
-class MCP23XXXBase : public Component {
+template<uint8_t N> class MCP23XXXBase : public Component, public gpio_expander::CachedGpioExpander<uint8_t, N> {
  public:
-  virtual bool digital_read(uint8_t pin);
-  virtual void digital_write(uint8_t pin, bool value);
   virtual void pin_mode(uint8_t pin, gpio::Flags flags);
   virtual void pin_interrupt_mode(uint8_t pin, MCP23XXXInterruptMode interrupt_mode);
 
   void set_open_drain_ints(const bool value) { this->open_drain_ints_ = value; }
-  float get_setup_priority() const override;
+  float get_setup_priority() const override { return setup_priority::IO; }
+
+  void loop() override { this->reset_pin_cache_(); }
 
  protected:
   // read a given register
@@ -29,7 +30,7 @@ class MCP23XXXBase : public Component {
   bool open_drain_ints_;
 };
 
-class MCP23XXXGPIOPin : public GPIOPin {
+template<uint8_t N> class MCP23XXXGPIOPin : public GPIOPin {
  public:
   void setup() override;
   void pin_mode(gpio::Flags flags) override;
@@ -37,7 +38,7 @@ class MCP23XXXGPIOPin : public GPIOPin {
   void digital_write(bool value) override;
   std::string dump_summary() const override;
 
-  void set_parent(MCP23XXXBase *parent) { parent_ = parent; }
+  void set_parent(MCP23XXXBase<N> *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
@@ -46,7 +47,7 @@ class MCP23XXXGPIOPin : public GPIOPin {
   gpio::Flags get_flags() const override { return this->flags_; }
 
  protected:
-  MCP23XXXBase *parent_;
+  MCP23XXXBase<N> *parent_;
   uint8_t pin_;
   bool inverted_;
   gpio::Flags flags_;

esphome/components/mcp3008/mcp3008.cpp

@@ -10,10 +10,7 @@ static const char *const TAG = "mcp3008";
 
 float MCP3008::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-void MCP3008::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-  this->spi_setup();
-}
+void MCP3008::setup() { this->spi_setup(); }
 
 void MCP3008::dump_config() {
   ESP_LOGCONFIG(TAG, "MCP3008:");

esphome/components/mcp3204/mcp3204.cpp

@@ -8,10 +8,7 @@ static const char *const TAG = "mcp3204";
 
 float MCP3204::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-void MCP3204::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-  this->spi_setup();
-}
+void MCP3204::setup() { this->spi_setup(); }
 
 void MCP3204::dump_config() {
   ESP_LOGCONFIG(TAG, "MCP3204:");

esphome/components/mcp4461/mcp4461.cpp

@@ -10,7 +10,6 @@ static const char *const TAG = "mcp4461";
 constexpr uint8_t EEPROM_WRITE_TIMEOUT_MS = 10;
 
 void Mcp4461Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for address 0x%02X", this->address_);
   auto err = this->write(nullptr, 0);
   if (err != i2c::ERROR_OK) {
     this->error_code_ = MCP4461_STATUS_I2C_ERROR;

esphome/components/mcp4725/mcp4725.cpp

@@ -7,7 +7,6 @@ namespace mcp4725 {
 static const char *const TAG = "mcp4725";
 
 void MCP4725::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for address 0x%02X", this->address_);
   auto err = this->write(nullptr, 0);
   if (err != i2c::ERROR_OK) {
     this->error_code_ = COMMUNICATION_FAILED;

esphome/components/mcp4728/mcp4728.cpp

@@ -9,7 +9,6 @@ namespace mcp4728 {
 static const char *const TAG = "mcp4728";
 
 void MCP4728Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for address 0x%02X", this->address_);
   auto err = this->write(nullptr, 0);
   if (err != i2c::ERROR_OK) {
     this->mark_failed();

esphome/components/mcp9600/mcp9600.cpp

@@ -28,8 +28,6 @@ static const uint8_t MCP9600_REGISTER_ALERT4_LIMIT = 0x13;
 static const uint8_t MCP9600_REGISTER_DEVICE_ID = 0x20;
 
 void MCP9600Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   uint16_t dev_id = 0;
   this->read_byte_16(MCP9600_REGISTER_DEVICE_ID, &dev_id);
   this->device_id_ = (uint8_t) (dev_id >> 8);

esphome/components/mcp9808/mcp9808.cpp

@@ -18,8 +18,6 @@ static const uint8_t MCP9808_AMBIENT_TEMP_NEGATIVE = 0x10;
 static const char *const TAG = "mcp9808";
 
 void MCP9808Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
-
   uint16_t manu = 0;
   if (!this->read_byte_16(MCP9808_REG_MANUF_ID, &manu) || manu != MCP9808_MANUF_ID) {
     this->mark_failed();

esphome/components/mdns/__init__.py

@@ -93,6 +93,9 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
+    if config[CONF_SERVICES]:
+        cg.add_define("USE_MDNS_EXTRA_SERVICES")
+
     for service in config[CONF_SERVICES]:
         txt = [
             cg.StructInitializer(

esphome/components/mdns/mdns_component.cpp

@@ -104,7 +104,9 @@ void MDNSComponent::compile_records_() {
   }
 #endif
 
+#ifdef USE_MDNS_EXTRA_SERVICES
   this->services_.insert(this->services_.end(), this->services_extra_.begin(), this->services_extra_.end());
+#endif
 
   if (this->services_.empty()) {
     // Publish "http" service if not using native API

esphome/components/mdns/mdns_component.h

@@ -35,14 +35,18 @@ class MDNSComponent : public Component {
 #endif
   float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
+#ifdef USE_MDNS_EXTRA_SERVICES
   void add_extra_service(MDNSService service) { services_extra_.push_back(std::move(service)); }
+#endif
 
   std::vector<MDNSService> get_services();
 
   void on_shutdown() override;
 
  protected:
+#ifdef USE_MDNS_EXTRA_SERVICES
   std::vector<MDNSService> services_extra_{};
+#endif
   std::vector<MDNSService> services_{};
   std::string hostname_;
   void compile_records_();

esphome/components/media_player/__init__.py

@@ -7,6 +7,8 @@ from esphome.const import (
     CONF_ID,
     CONF_ON_IDLE,
     CONF_ON_STATE,
+    CONF_ON_TURN_OFF,
+    CONF_ON_TURN_ON,
     CONF_TRIGGER_ID,
     CONF_VOLUME,
 )
@@ -58,6 +60,12 @@ VolumeDownAction = media_player_ns.class_(
 VolumeSetAction = media_player_ns.class_(
     "VolumeSetAction", automation.Action, cg.Parented.template(MediaPlayer)
 )
+TurnOnAction = media_player_ns.class_(
+    "TurnOnAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+TurnOffAction = media_player_ns.class_(
+    "TurnOffAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
 
 CONF_ANNOUNCEMENT = "announcement"
 CONF_ON_PLAY = "on_play"
@@ -72,12 +80,16 @@ PauseTrigger = media_player_ns.class_("PauseTrigger", automation.Trigger.templat
 AnnoucementTrigger = media_player_ns.class_(
     "AnnouncementTrigger", automation.Trigger.template()
 )
+OnTrigger = media_player_ns.class_("OnTrigger", automation.Trigger.template())
+OffTrigger = media_player_ns.class_("OffTrigger", automation.Trigger.template())
 IsIdleCondition = media_player_ns.class_("IsIdleCondition", automation.Condition)
 IsPausedCondition = media_player_ns.class_("IsPausedCondition", automation.Condition)
 IsPlayingCondition = media_player_ns.class_("IsPlayingCondition", automation.Condition)
 IsAnnouncingCondition = media_player_ns.class_(
     "IsAnnouncingCondition", automation.Condition
 )
+IsOnCondition = media_player_ns.class_("IsOnCondition", automation.Condition)
+IsOffCondition = media_player_ns.class_("IsOffCondition", automation.Condition)
 
 
 async def setup_media_player_core_(var, config):
@@ -97,6 +109,12 @@ async def setup_media_player_core_(var, config):
     for conf in config.get(CONF_ON_ANNOUNCEMENT, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_TURN_ON, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_TURN_OFF, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
 
 
 async def register_media_player(var, config):
@@ -140,6 +158,16 @@ _MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(AnnoucementTrigger),
             }
         ),
+        cv.Optional(CONF_ON_TURN_ON): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_TURN_OFF): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OffTrigger),
+            }
+        ),
     }
 )
 
@@ -218,6 +246,12 @@ async def media_player_play_media_action(config, action_id, template_arg, args):
 @automation.register_action(
     "media_player.volume_down", VolumeDownAction, MEDIA_PLAYER_ACTION_SCHEMA
 )
+@automation.register_action(
+    "media_player.turn_on", TurnOnAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action(
+    "media_player.turn_off", TurnOffAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
 async def media_player_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
@@ -238,6 +272,12 @@ async def media_player_action(config, action_id, template_arg, args):
 @automation.register_condition(
     "media_player.is_announcing", IsAnnouncingCondition, MEDIA_PLAYER_CONDITION_SCHEMA
 )
+@automation.register_condition(
+    "media_player.is_on", IsOnCondition, MEDIA_PLAYER_CONDITION_SCHEMA
+)
+@automation.register_condition(
+    "media_player.is_off", IsOffCondition, MEDIA_PLAYER_CONDITION_SCHEMA
+)
 async def media_player_condition(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])

esphome/components/media_player/automation.h

@@ -28,6 +28,10 @@ template<typename... Ts>
 using VolumeUpAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_VOLUME_UP, Ts...>;
 template<typename... Ts>
 using VolumeDownAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_VOLUME_DOWN, Ts...>;
+template<typename... Ts>
+using TurnOnAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TURN_ON, Ts...>;
+template<typename... Ts>
+using TurnOffAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TURN_OFF, Ts...>;
 
 template<typename... Ts> class PlayMediaAction : public Action<Ts...>, public Parented<MediaPlayer> {
   TEMPLATABLE_VALUE(std::string, media_url)
@@ -66,6 +70,8 @@ using IdleTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE
 using PlayTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_PLAYING>;
 using PauseTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_PAUSED>;
 using AnnouncementTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING>;
+using OnTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_ON>;
+using OffTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_OFF>;
 
 template<typename... Ts> class IsIdleCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
  public:
@@ -87,5 +93,15 @@ template<typename... Ts> class IsAnnouncingCondition : public Condition<Ts...>,
   bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING; }
 };
 
+template<typename... Ts> class IsOnCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
+ public:
+  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_ON; }
+};
+
+template<typename... Ts> class IsOffCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
+ public:
+  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_OFF; }
+};
+
 }  // namespace media_player
 }  // namespace esphome

esphome/components/media_player/media_player.cpp

@@ -9,6 +9,10 @@ static const char *const TAG = "media_player";
 
 const char *media_player_state_to_string(MediaPlayerState state) {
   switch (state) {
+    case MEDIA_PLAYER_STATE_ON:
+      return "ON";
+    case MEDIA_PLAYER_STATE_OFF:
+      return "OFF";
     case MEDIA_PLAYER_STATE_IDLE:
       return "IDLE";
     case MEDIA_PLAYER_STATE_PLAYING:
@@ -18,6 +22,7 @@ const char *media_player_state_to_string(MediaPlayerState state) {
     case MEDIA_PLAYER_STATE_ANNOUNCING:
       return "ANNOUNCING";
     case MEDIA_PLAYER_STATE_NONE:
+      return "NONE";
     default:
       return "UNKNOWN";
   }
@@ -49,6 +54,10 @@ const char *media_player_command_to_string(MediaPlayerCommand command) {
       return "REPEAT_OFF";
     case MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST:
       return "CLEAR_PLAYLIST";
+    case MEDIA_PLAYER_COMMAND_TURN_ON:
+      return "TURN_ON";
+    case MEDIA_PLAYER_COMMAND_TURN_OFF:
+      return "TURN_OFF";
     default:
       return "UNKNOWN";
   }
@@ -110,6 +119,10 @@ MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
     this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
   } else if (str_equals_case_insensitive(command, "TOGGLE")) {
     this->set_command(MEDIA_PLAYER_COMMAND_TOGGLE);
+  } else if (str_equals_case_insensitive(command, "TURN_ON")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_TURN_ON);
+  } else if (str_equals_case_insensitive(command, "TURN_OFF")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_TURN_OFF);
   } else {
     ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
   }

esphome/components/media_player/media_player.h

@@ -6,12 +6,40 @@
 namespace esphome {
 namespace media_player {
 
+enum MediaPlayerEntityFeature : uint32_t {
+  PAUSE = 1 << 0,
+  SEEK = 1 << 1,
+  VOLUME_SET = 1 << 2,
+  VOLUME_MUTE = 1 << 3,
+  PREVIOUS_TRACK = 1 << 4,
+  NEXT_TRACK = 1 << 5,
+
+  TURN_ON = 1 << 7,
+  TURN_OFF = 1 << 8,
+  PLAY_MEDIA = 1 << 9,
+  VOLUME_STEP = 1 << 10,
+  SELECT_SOURCE = 1 << 11,
+  STOP = 1 << 12,
+  CLEAR_PLAYLIST = 1 << 13,
+  PLAY = 1 << 14,
+  SHUFFLE_SET = 1 << 15,
+  SELECT_SOUND_MODE = 1 << 16,
+  BROWSE_MEDIA = 1 << 17,
+  REPEAT_SET = 1 << 18,
+  GROUPING = 1 << 19,
+  MEDIA_ANNOUNCE = 1 << 20,
+  MEDIA_ENQUEUE = 1 << 21,
+  SEARCH_MEDIA = 1 << 22,
+};
+
 enum MediaPlayerState : uint8_t {
   MEDIA_PLAYER_STATE_NONE = 0,
   MEDIA_PLAYER_STATE_IDLE = 1,
   MEDIA_PLAYER_STATE_PLAYING = 2,
   MEDIA_PLAYER_STATE_PAUSED = 3,
-  MEDIA_PLAYER_STATE_ANNOUNCING = 4
+  MEDIA_PLAYER_STATE_ANNOUNCING = 4,
+  MEDIA_PLAYER_STATE_OFF = 5,
+  MEDIA_PLAYER_STATE_ON = 6,
 };
 const char *media_player_state_to_string(MediaPlayerState state);
 
@@ -28,6 +56,8 @@ enum MediaPlayerCommand : uint8_t {
   MEDIA_PLAYER_COMMAND_REPEAT_ONE = 9,
   MEDIA_PLAYER_COMMAND_REPEAT_OFF = 10,
   MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST = 11,
+  MEDIA_PLAYER_COMMAND_TURN_ON = 12,
+  MEDIA_PLAYER_COMMAND_TURN_OFF = 13,
 };
 const char *media_player_command_to_string(MediaPlayerCommand command);
 
@@ -51,14 +81,31 @@ class MediaPlayerTraits {
   MediaPlayerTraits() = default;
 
   void set_supports_pause(bool supports_pause) { this->supports_pause_ = supports_pause; }
-
   bool get_supports_pause() const { return this->supports_pause_; }
 
+  void set_supports_turn_off_on(bool supports_turn_off_on) { this->supports_turn_off_on_ = supports_turn_off_on; }
+  bool get_supports_turn_off_on() const { return this->supports_turn_off_on_; }
+
   std::vector<MediaPlayerSupportedFormat> &get_supported_formats() { return this->supported_formats_; }
 
+  uint32_t get_feature_flags() const {
+    uint32_t flags = 0;
+    flags |= MediaPlayerEntityFeature::PLAY_MEDIA | MediaPlayerEntityFeature::BROWSE_MEDIA |
+             MediaPlayerEntityFeature::STOP | MediaPlayerEntityFeature::VOLUME_SET |
+             MediaPlayerEntityFeature::VOLUME_MUTE | MediaPlayerEntityFeature::MEDIA_ANNOUNCE;
+    if (this->get_supports_pause()) {
+      flags |= MediaPlayerEntityFeature::PAUSE | MediaPlayerEntityFeature::PLAY;
+    }
+    if (this->get_supports_turn_off_on()) {
+      flags |= MediaPlayerEntityFeature::TURN_OFF | MediaPlayerEntityFeature::TURN_ON;
+    }
+    return flags;
+  }
+
  protected:
-  bool supports_pause_{false};
   std::vector<MediaPlayerSupportedFormat> supported_formats_{};
+  bool supports_pause_{false};
+  bool supports_turn_off_on_{false};
 };
 
 class MediaPlayerCall {