Complete removal of auto_start, zeroconf_default_interface, and safe_mode from HomeKit (#58320)

homeassistant/components/homekit/__init__.py

@@ -69,7 +69,6 @@ from .const import (
     BRIDGE_NAME,
     BRIDGE_SERIAL_NUMBER,
     CONF_ADVERTISE_IP,
-    CONF_AUTO_START,
     CONF_ENTITY_CONFIG,
     CONF_ENTRY_INDEX,
     CONF_EXCLUDE_ACCESSORY_MODE,
@@ -80,14 +79,10 @@ from .const import (
     CONF_LINKED_DOORBELL_SENSOR,
     CONF_LINKED_HUMIDITY_SENSOR,
     CONF_LINKED_MOTION_SENSOR,
-    CONF_SAFE_MODE,
-    CONF_ZEROCONF_DEFAULT_INTERFACE,
     CONFIG_OPTIONS,
-    DEFAULT_AUTO_START,
     DEFAULT_EXCLUDE_ACCESSORY_MODE,
     DEFAULT_HOMEKIT_MODE,
     DEFAULT_PORT,
-    DEFAULT_SAFE_MODE,
     DOMAIN,
     HOMEKIT,
     HOMEKIT_MODE_ACCESSORY,
@@ -141,9 +136,6 @@ def _has_all_unique_names_and_ports(bridges):
 
 
 BRIDGE_SCHEMA = vol.All(
-    cv.deprecated(CONF_ZEROCONF_DEFAULT_INTERFACE),
-    cv.deprecated(CONF_SAFE_MODE),
-    cv.deprecated(CONF_AUTO_START),
     vol.Schema(
         {
             vol.Optional(CONF_HOMEKIT_MODE, default=DEFAULT_HOMEKIT_MODE): vol.In(
@@ -155,11 +147,8 @@ BRIDGE_SCHEMA = vol.All(
             vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
             vol.Optional(CONF_IP_ADDRESS): vol.All(ipaddress.ip_address, cv.string),
             vol.Optional(CONF_ADVERTISE_IP): vol.All(ipaddress.ip_address, cv.string),
-            vol.Optional(CONF_AUTO_START, default=DEFAULT_AUTO_START): cv.boolean,
-            vol.Optional(CONF_SAFE_MODE, default=DEFAULT_SAFE_MODE): cv.boolean,
             vol.Optional(CONF_FILTER, default={}): BASE_FILTER_SCHEMA,
             vol.Optional(CONF_ENTITY_CONFIG, default={}): validate_entity_config,
-            vol.Optional(CONF_ZEROCONF_DEFAULT_INTERFACE): cv.boolean,
             vol.Optional(CONF_DEVICES): cv.ensure_list,
         },
         extra=vol.ALLOW_EXTRA,
@@ -279,7 +268,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     )
     homekit_mode = options.get(CONF_HOMEKIT_MODE, DEFAULT_HOMEKIT_MODE)
     entity_config = options.get(CONF_ENTITY_CONFIG, {}).copy()
-    auto_start = options.get(CONF_AUTO_START, DEFAULT_AUTO_START)
     entity_filter = FILTER_SCHEMA(options.get(CONF_FILTER, {}))
     devices = options.get(CONF_DEVICES, [])
 
@@ -307,7 +295,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     if hass.state == CoreState.running:
         await homekit.async_start()
-    elif auto_start:
+    else:
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, homekit.async_start)
 
     return True

homeassistant/components/homekit/config_flow.py

@@ -36,14 +36,12 @@ from homeassistant.helpers.entityfilter import (
 from homeassistant.loader import async_get_integration
 
 from .const import (
-    CONF_AUTO_START,
     CONF_ENTITY_CONFIG,
     CONF_EXCLUDE_ACCESSORY_MODE,
     CONF_FILTER,
     CONF_HOMEKIT_MODE,
     CONF_SUPPORT_AUDIO,
     CONF_VIDEO_CODEC,
-    DEFAULT_AUTO_START,
     DEFAULT_CONFIG_FLOW_PORT,
     DEFAULT_HOMEKIT_MODE,
     DOMAIN,
@@ -311,14 +309,14 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
     async def async_step_advanced(self, user_input=None):
         """Choose advanced options."""
-        if not self.show_advanced_options or user_input is not None:
+        if (
+            not self.show_advanced_options
+            or user_input is not None
+            or self.hk_options[CONF_HOMEKIT_MODE] != HOMEKIT_MODE_BRIDGE
+        ):
             if user_input:
                 self.hk_options.update(user_input)
 
-            self.hk_options[CONF_AUTO_START] = self.hk_options.get(
-                CONF_AUTO_START, DEFAULT_AUTO_START
-            )
-
             for key in (CONF_DOMAINS, CONF_ENTITIES):
                 if key in self.hk_options:
                     del self.hk_options[key]
@@ -331,23 +329,16 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
             return self.async_create_entry(title="", data=self.hk_options)
 
-        data_schema = {
-            vol.Optional(
-                CONF_AUTO_START,
-                default=self.hk_options.get(CONF_AUTO_START, DEFAULT_AUTO_START),
-            ): bool
-        }
-
-        if self.hk_options[CONF_HOMEKIT_MODE] == HOMEKIT_MODE_BRIDGE:
         all_supported_devices = await _async_get_supported_devices(self.hass)
-            devices = self.hk_options.get(CONF_DEVICES, [])
-            data_schema[vol.Optional(CONF_DEVICES, default=devices)] = cv.multi_select(
-                all_supported_devices
-            )
-
         return self.async_show_form(
             step_id="advanced",
-            data_schema=vol.Schema(data_schema),
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(
+                        CONF_DEVICES, default=self.hk_options.get(CONF_DEVICES, [])
+                    ): cv.multi_select(all_supported_devices)
+                }
+            ),
         )
 
     async def async_step_cameras(self, user_input=None):

homeassistant/components/homekit/const.py

@@ -34,7 +34,6 @@ CONF_ADVERTISE_IP = "advertise_ip"
 CONF_AUDIO_CODEC = "audio_codec"
 CONF_AUDIO_MAP = "audio_map"
 CONF_AUDIO_PACKET_SIZE = "audio_packet_size"
-CONF_AUTO_START = "auto_start"
 CONF_ENTITY_CONFIG = "entity_config"
 CONF_FEATURE = "feature"
 CONF_FEATURE_LIST = "feature_list"
@@ -50,8 +49,6 @@ CONF_LOW_BATTERY_THRESHOLD = "low_battery_threshold"
 CONF_MAX_FPS = "max_fps"
 CONF_MAX_HEIGHT = "max_height"
 CONF_MAX_WIDTH = "max_width"
-CONF_SAFE_MODE = "safe_mode"
-CONF_ZEROCONF_DEFAULT_INTERFACE = "zeroconf_default_interface"
 CONF_STREAM_ADDRESS = "stream_address"
 CONF_STREAM_SOURCE = "stream_source"
 CONF_SUPPORT_AUDIO = "support_audio"
@@ -65,7 +62,6 @@ DEFAULT_SUPPORT_AUDIO = False
 DEFAULT_AUDIO_CODEC = AUDIO_CODEC_OPUS
 DEFAULT_AUDIO_MAP = "0:a:0"
 DEFAULT_AUDIO_PACKET_SIZE = 188
-DEFAULT_AUTO_START = True
 DEFAULT_EXCLUDE_ACCESSORY_MODE = False
 DEFAULT_LOW_BATTERY_THRESHOLD = 20
 DEFAULT_MAX_FPS = 30
@@ -73,7 +69,6 @@ DEFAULT_MAX_HEIGHT = 1080
 DEFAULT_MAX_WIDTH = 1920
 DEFAULT_PORT = 21063
 DEFAULT_CONFIG_FLOW_PORT = 21064
-DEFAULT_SAFE_MODE = False
 DEFAULT_VIDEO_CODEC = VIDEO_CODEC_LIBX264
 DEFAULT_VIDEO_MAP = "0:v:0"
 DEFAULT_VIDEO_PACKET_SIZE = 1316
@@ -293,8 +288,6 @@ HK_NOT_CHARGABLE = 2
 # ### Config Options ###
 CONFIG_OPTIONS = [
     CONF_FILTER,
-    CONF_AUTO_START,
-    CONF_SAFE_MODE,
     CONF_ENTITY_CONFIG,
     CONF_HOMEKIT_MODE,
     CONF_DEVICES,

tests/components/homekit/test_config_flow.py

@@ -1,8 +1,6 @@
 """Test the HomeKit config flow."""
 from unittest.mock import patch
 
-import pytest
-
 from homeassistant import config_entries, data_entry_flow
 from homeassistant.components.homekit.const import DOMAIN, SHORT_BRIDGE_NAME
 from homeassistant.config_entries import SOURCE_IGNORE, SOURCE_IMPORT
@@ -273,8 +271,7 @@ async def test_import(hass, mock_get_source_ip):
     assert len(mock_setup_entry.mock_calls) == 2
 
 
-@pytest.mark.parametrize("auto_start", [True, False])
+async def test_options_flow_exclude_mode_advanced(hass, mock_get_source_ip):
-async def test_options_flow_exclude_mode_advanced(auto_start, hass, mock_get_source_ip):
     """Test config flow options in exclude mode with advanced options."""
 
     config_entry = _mock_config_entry_with_options_populated()
@@ -308,12 +305,11 @@ async def test_options_flow_exclude_mode_advanced(auto_start, hass, mock_get_sou
     with patch("homeassistant.components.homekit.async_setup_entry", return_value=True):
         result3 = await hass.config_entries.options.async_configure(
             result2["flow_id"],
-            user_input={"auto_start": auto_start},
+            user_input={},
         )
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": auto_start,
         "devices": [],
         "mode": "bridge",
         "filter": {
@@ -355,7 +351,6 @@ async def test_options_flow_exclude_mode_basic(hass, mock_get_source_ip):
     )
     assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "bridge",
         "filter": {
             "exclude_domains": [],
@@ -412,12 +407,11 @@ async def test_options_flow_devices(
     with patch("homeassistant.components.homekit.async_setup_entry", return_value=True):
         result3 = await hass.config_entries.options.async_configure(
             result2["flow_id"],
-            user_input={"auto_start": True, "devices": [device_id]},
+            user_input={"devices": [device_id]},
         )
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "devices": [device_id],
         "mode": "bridge",
         "filter": {
@@ -486,7 +480,6 @@ async def test_options_flow_devices_preserved_when_advanced_off(
 
     assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "devices": ["1fabcabcabcabcabcabcabcabcabc"],
         "mode": "bridge",
         "filter": {
@@ -530,7 +523,6 @@ async def test_options_flow_include_mode_basic(hass, mock_get_source_ip):
     )
     assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "bridge",
         "filter": {
             "exclude_domains": [],
@@ -586,7 +578,6 @@ async def test_options_flow_exclude_mode_with_cameras(hass, mock_get_source_ip):
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "bridge",
         "filter": {
             "exclude_domains": [],
@@ -632,7 +623,6 @@ async def test_options_flow_exclude_mode_with_cameras(hass, mock_get_source_ip):
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
 
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "bridge",
         "filter": {
             "exclude_domains": [],
@@ -689,7 +679,6 @@ async def test_options_flow_include_mode_with_cameras(hass, mock_get_source_ip):
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "bridge",
         "filter": {
             "exclude_domains": [],
@@ -762,7 +751,6 @@ async def test_options_flow_include_mode_with_cameras(hass, mock_get_source_ip):
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "entity_config": {"camera.native_h264": {}},
         "filter": {
             "exclude_domains": [],
@@ -819,7 +807,6 @@ async def test_options_flow_with_camera_audio(hass, mock_get_source_ip):
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "bridge",
         "filter": {
             "exclude_domains": [],
@@ -892,7 +879,6 @@ async def test_options_flow_with_camera_audio(hass, mock_get_source_ip):
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "entity_config": {"camera.audio": {}},
         "filter": {
             "exclude_domains": [],
@@ -911,7 +897,6 @@ async def test_options_flow_blocked_when_from_yaml(hass, mock_get_source_ip):
         domain=DOMAIN,
         data={CONF_NAME: "mock_name", CONF_PORT: 12345},
         options={
-            "auto_start": True,
             "devices": [],
             "filter": {
                 "include_domains": [
@@ -988,7 +973,6 @@ async def test_options_flow_include_mode_basic_accessory(hass, mock_get_source_i
     )
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "mode": "accessory",
         "filter": {
             "exclude_domains": [],
@@ -1093,7 +1077,6 @@ async def test_converting_bridge_to_accessory_mode(hass, hk_driver, mock_get_sou
 
     assert result3["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
     assert config_entry.options == {
-        "auto_start": True,
         "entity_config": {"camera.tv": {"video_codec": "copy"}},
         "mode": "accessory",
         "filter": {

tests/components/homekit/test_homekit.py

@@ -27,14 +27,12 @@ from homeassistant.components.homekit.accessories import HomeBridge
 from homeassistant.components.homekit.const import (
     BRIDGE_NAME,
     BRIDGE_SERIAL_NUMBER,
-    CONF_AUTO_START,
     DEFAULT_PORT,
     DOMAIN,
     HOMEKIT,
     HOMEKIT_MODE_ACCESSORY,
     HOMEKIT_MODE_BRIDGE,
     SERVICE_HOMEKIT_RESET_ACCESSORY,
-    SERVICE_HOMEKIT_START,
     SERVICE_HOMEKIT_UNPAIR,
 )
 from homeassistant.components.homekit.type_triggers import DeviceTriggerAccessory
@@ -45,7 +43,6 @@ from homeassistant.const import (
     ATTR_DEVICE_ID,
     ATTR_ENTITY_ID,
     ATTR_UNIT_OF_MEASUREMENT,
-    CONF_IP_ADDRESS,
     CONF_NAME,
     CONF_PORT,
     DEVICE_CLASS_BATTERY,
@@ -184,63 +181,6 @@ async def test_setup_min(hass, mock_zeroconf):
     assert mock_homekit().async_start.called is True
 
 
-async def test_setup_auto_start_disabled(hass, mock_zeroconf):
-    """Test async_setup with auto start disabled and test service calls."""
-
-    entry = MockConfigEntry(
-        domain=DOMAIN,
-        data={CONF_NAME: "Test Name", CONF_PORT: 11111, CONF_IP_ADDRESS: "172.0.0.0"},
-        options={CONF_AUTO_START: False},
-    )
-    entry.add_to_hass(hass)
-
-    with patch(f"{PATH_HOMEKIT}.HomeKit") as mock_homekit:
-        mock_homekit.return_value = homekit = Mock()
-        type(homekit).async_start = AsyncMock()
-        assert await hass.config_entries.async_setup(entry.entry_id)
-        await hass.async_block_till_done()
-
-    mock_homekit.assert_any_call(
-        hass,
-        "Test Name",
-        11111,
-        "172.0.0.0",
-        ANY,
-        ANY,
-        {},
-        HOMEKIT_MODE_BRIDGE,
-        None,
-        entry.entry_id,
-        entry.title,
-        devices=[],
-    )
-
-    # Test auto_start disabled
-    homekit.reset_mock()
-    homekit.async_start.reset_mock()
-    hass.bus.async_fire(EVENT_HOMEASSISTANT_STARTED)
-    await hass.async_block_till_done()
-    assert homekit.async_start.called is False
-
-    # Test start call with driver is ready
-    homekit.reset_mock()
-    homekit.async_start.reset_mock()
-    homekit.status = STATUS_READY
-
-    await hass.services.async_call(DOMAIN, SERVICE_HOMEKIT_START, blocking=True)
-    await hass.async_block_till_done()
-    assert homekit.async_start.called is True
-
-    # Test start call with driver started
-    homekit.reset_mock()
-    homekit.async_start.reset_mock()
-    homekit.status = STATUS_STOPPED
-
-    await hass.services.async_call(DOMAIN, SERVICE_HOMEKIT_START, blocking=True)
-    await hass.async_block_till_done()
-    assert homekit.async_start.called is False
-
-
 async def test_homekit_setup(hass, hk_driver, mock_zeroconf):
     """Test setup of bridge and driver."""
     entry = MockConfigEntry(