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

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/dfrobot_sen0609/dfrobot_sen0609.cpp

@@ -173,8 +173,8 @@ void DFRobotSEN0609Component::setup() {
     switch_::Switch *sw = this->switches_[i];
     if (sw == nullptr)
       continue;
-    const bool on = sw->get_initial_state_with_restore_mode().value_or(true);
-    this->publish_switch_(static_cast<SwitchSetting>(i), on != sw->is_inverted());
+    // A disabled restore mode leaves the switch on, which an inverted switch writes as off
+    this->publish_switch_(static_cast<SwitchSetting>(i), sw->get_initial_write_state().value_or(!sw->is_inverted()));
   }
 #endif
   this->queue_configuration_();

esphome/components/hitachi_ac344/hitachi_ac344.cpp

@@ -155,12 +155,9 @@ void HitachiClimate::setup() {
     set_swing_v_(swing_vertical(restore->swing_mode));
   }
 #ifdef USE_SWITCH
-  // The restored value is the switch state, which an inverted switch flips relative to the frame bit
   if (this->mildew_proof_switch_ != nullptr) {
-    if (auto initial = this->mildew_proof_switch_->get_initial_state_with_restore_mode()) {
-      assign_bits(this->remote_state_[HITACHI_AC344_MILDEWPROOF_BYTE], 1 << HITACHI_AC344_MILDEWPROOF_OFFSET,
-                  *initial != this->mildew_proof_switch_->is_inverted());
-    }
+    if (auto initial = this->mildew_proof_switch_->get_initial_write_state())
+      assign_bits(this->remote_state_[HITACHI_AC344_MILDEWPROOF_BYTE], 1 << HITACHI_AC344_MILDEWPROOF_OFFSET, *initial);
   }
 #endif
   this->setup_(restore);

esphome/components/seeed_multi_channel_relay/seeed_multi_channel_relay.cpp

@@ -25,7 +25,7 @@ void SeeedMultiChannelRelay::setup() {
     switch_::Switch *sw = this->switches_[channel];
     if (sw == nullptr)
       continue;
-    const bool on = sw->get_initial_state_with_restore_mode().value_or(sw->is_inverted()) != sw->is_inverted();
+    const bool on = sw->get_initial_write_state().value_or(false);
     assign_bits(value, 1 << channel, on);
   }
   if (!this->status_comm_result(this->write_byte(CMD_CHANNEL_CTRL, value)))

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