Merge branch 'dev' into switch-initial-write-state

AGENTS.md

@@ -449,6 +449,8 @@ file does, and it is the authority when they disagree. The most useful starting
           ```
           Restore an owned or standalone switch in `setup()` with `sw->restore()`, or `restore(default)`
           to still drive a state when the restore mode is disabled.
+          A hub that applies its switches' restored states itself reads `sw->get_initial_write_state()`, which
+          already applies `inverted`.
 
         - **Other codegen helpers:** `uart.new_uart_component(config, *ctor_args)` (and `i2c.new_i2c_component`,
           `spi.new_spi_component`, `modbus.new_modbus_client_component`, `ble_client.new_ble_node_component`)

esphome/components/gree/switch/gree_switch.cpp

@@ -5,7 +5,12 @@ namespace esphome::gree {
 
 ESPHOME_LOG_TAG(TAG, "gree.switch");
 
-void GreeModeBitSwitch::setup() { this->restore(); }
+void GreeModeBitSwitch::setup() {
+  auto initial = this->get_initial_state_with_restore_mode();
+  if (initial.has_value()) {
+    this->write_state(*initial);
+  }
+}
 
 void GreeModeBitSwitch::dump_config() { log_switch(TAG, "  ", this->name_, this); }
 

esphome/components/haier_tundra/switch/haier_tundra_switch.cpp

@@ -8,10 +8,9 @@ ESPHOME_LOG_TAG(TAG, "haier_tundra.switch");
 void HaierTundraSwitch::setup() {
   auto initial = this->get_initial_state_with_restore_mode();
   if (initial.has_value()) {
-    // apply_() and publish_state() take the level, which an inverted switch flips
-    const bool level = *initial != this->is_inverted();
-    this->apply_(level, false);
-    this->publish_state(level);
+    const bool state = initial.value();
+    this->apply_(state, false);
+    this->publish_state(state);
   }
 }
 

esphome/components/hbridge/switch/hbridge_switch.cpp

@@ -9,6 +9,8 @@ ESPHOME_LOG_TAG(TAG, "switch.hbridge");
 
 float HBridgeSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 void HBridgeSwitch::setup() {
+  optional<bool> initial_state = this->get_initial_state_with_restore_mode();
+
   // Like GPIOSwitch does, set the pin state both before and after pin setup()
   this->on_pin_->digital_write(false);
   this->on_pin_->setup();
@@ -18,7 +20,8 @@ void HBridgeSwitch::setup() {
   this->off_pin_->setup();
   this->off_pin_->digital_write(false);
 
-  this->restore();
+  if (initial_state.has_value())
+    this->write_state(initial_state.value());
 }
 
 void HBridgeSwitch::dump_config() {

esphome/components/lvgl/switch/lvgl_switch.h

@@ -13,7 +13,7 @@ class LVGLSwitch final : public switch_::Switch, public Component {
  public:
   LVGLSwitch(std::function<void(bool)> state_lambda) : state_lambda_(std::move(state_lambda)) {}
 
-  void setup() override { this->restore(false); }
+  void setup() override { this->write_state(this->get_initial_state_with_restore_mode().value_or(false)); }
 
  protected:
   void write_state(bool value) override { this->state_lambda_(value); }

esphome/components/opentherm/switch/opentherm_switch.cpp

@@ -15,7 +15,7 @@ void OpenthermSwitch::setup() {
     ESP_LOGD(TAG, "Restored state for OpenTherm switch '%s': %d", LOG_STR_ARG(this->get_log_name()), restored.value());
     state = restored.value();
   }
-  this->control(state);
+  this->write_state(state);
 }
 
 void OpenthermSwitch::dump_config() {

esphome/components/switch/switch.cpp

@@ -60,6 +60,11 @@ optional<bool> Switch::get_initial_state_with_restore_mode() {
   }
   return initial_state;
 }
+optional<bool> Switch::get_initial_write_state() {
+  if (auto initial = this->get_initial_state_with_restore_mode())
+    return *initial != this->inverted_;
+  return {};
+}
 void Switch::restore() {
   if (auto initial = this->get_initial_state_with_restore_mode())
     this->control(*initial);

esphome/components/switch/switch.h

@@ -114,6 +114,8 @@ class Switch : public EntityBase {
    * state.
    */
   optional<bool> get_initial_state_with_restore_mode();
+  /// get_initial_state_with_restore_mode() with inverted applied: the level write_state() takes.
+  optional<bool> get_initial_write_state();
 
   /// Drive the switch to the state its restore mode yields, through control(), so inversion and
   /// write_state() apply; a disabled restore mode drives \p when_disabled, or nothing without one.

tests/components/switch/restore_test.cpp

@@ -46,4 +46,16 @@ TEST(SwitchRestore, DefaultAppliesOnlyWhenTheModeIsDisabled) {
   EXPECT_EQ(on.writes, std::vector<bool>{true});
 }
 
+TEST(SwitchRestore, InitialWriteStateAppliesInversion) {
+  RecordingSwitch on, inverted, disabled;
+  on.set_restore_mode(SWITCH_ALWAYS_ON);
+  inverted.set_restore_mode(SWITCH_ALWAYS_ON);
+  inverted.set_inverted(true);
+  disabled.set_restore_mode(SWITCH_RESTORE_DISABLED);
+  disabled.set_inverted(true);
+  EXPECT_EQ(on.get_initial_write_state(), optional<bool>(true));
+  EXPECT_EQ(inverted.get_initial_write_state(), optional<bool>(false));
+  EXPECT_FALSE(disabled.get_initial_write_state().has_value());
+}
+
 }  // namespace esphome::switch_::testing