feat: absolute volume, picture modes, sleep timer, SSDP discovery

Volume:
- Improved coordinator volume parsing with fallback to first target
- set_volume_level already converts 0.0-1.0 to absolute value correctly

Picture Mode:
- New select entity for scene/picture mode (Standard, Vivid, Cinema, etc.)
- Added getSceneSetting/setSceneSetting to API client
- Modes discovered at runtime, defaults as fallback

Sleep Timer:
- New select entity with Off, 15, 30, 45, 60, 90, 120 min options
- Added getSleepTimerSettings/setSleepTimerSettings to API client

SSDP Discovery:
- TV auto-detected on local network via UPnP/SSDP
- Service type: urn:schemas-sony-com:service:ScalarWebAPI:1
- Config flow pre-fills IP when TV discovered
- Tries to fetch model info without PSK for discovery notification

Bump version to 1.3.0

Author: cmos486

custom_components/bravia_rest_api/bravia_client.py

@@ -498,6 +498,34 @@ async def set_scene_setting(self, scene: str) -> None:
             SERVICE_VIDEO_SCREEN, "setSceneSetting", [{"scene": scene}]
         )
 
+    async def get_scene_setting(self) -> str:
+        """Get current scene/picture mode setting."""
+        result = await self._request(SERVICE_VIDEO_SCREEN, "getSceneSetting")
+        if result and isinstance(result[0], dict):
+            return result[0].get("scene", "")
+        if result and isinstance(result[0], str):
+            return result[0]
+        return ""
+
+    # ------------------------------------------------------------------
+    # Sleep timer (system service)
+    # ------------------------------------------------------------------
+
+    async def get_sleep_timer_settings(self) -> list[dict[str, Any]]:
+        """Get sleep timer settings."""
+        result = await self._request(
+            SERVICE_SYSTEM, "getSleepTimerSettings", [{"target": ""}]
+        )
+        return result[0] if result and isinstance(result[0], list) else result
+
+    async def set_sleep_timer_settings(
+        self, settings: list[dict[str, str]]
+    ) -> None:
+        """Set sleep timer settings."""
+        await self._request(
+            SERVICE_SYSTEM, "setSleepTimerSettings", [{"settings": settings}]
+        )
+
     # ------------------------------------------------------------------
     # IRCC (infrared remote control)
     # ------------------------------------------------------------------

custom_components/bravia_rest_api/config_flow.py

@@ -4,10 +4,12 @@
 
 import logging
 from typing import Any
+from urllib.parse import urlparse
 
 import aiohttp
 import voluptuous as vol
 
+from homeassistant.components import ssdp
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_HOST
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -30,11 +32,16 @@
 )
 
 
-class SonyBraviaProConfigFlow(ConfigFlow, domain=DOMAIN):
+class BraviaRestApiConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Bravia REST API."""
 
     VERSION = 1
 
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovered_host: str | None = None
+        self._discovered_model: str | None = None
+
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -82,8 +89,65 @@ async def async_step_user(
                         },
                     )
 
+        # Pre-fill host if discovered via SSDP
+        schema = STEP_USER_DATA_SCHEMA
+        if self._discovered_host:
+            schema = vol.Schema(
+                {
+                    vol.Required(CONF_HOST, default=self._discovered_host): str,
+                    vol.Required(CONF_PSK): str,
+                }
+            )
+
         return self.async_show_form(
             step_id="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
+            data_schema=schema,
             errors=errors,
+            description_placeholders={"model": self._discovered_model or ""},
+        )
+
+    async def async_step_ssdp(
+        self, discovery_info: ssdp.SsdpServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle SSDP discovery of a Sony Bravia TV."""
+        # Extract host from SSDP location URL
+        location = discovery_info.ssdp_location or ""
+        parsed = urlparse(location)
+        host = parsed.hostname or ""
+
+        if not host:
+            return self.async_abort(reason="cannot_connect")
+
+        _LOGGER.info(
+            "Discovered Sony Bravia TV via SSDP at %s: %s",
+            host,
+            discovery_info.upnp.get(ssdp.ATTR_UPNP_FRIENDLY_NAME, "Unknown"),
         )
+
+        # Try to get system info to find unique_id
+        session = async_get_clientsession(self.hass)
+        # Try without PSK for read-only endpoints
+        client = BraviaClient(host, "", session)
+
+        try:
+            system_info = await client.get_system_info()
+            serial = system_info.get("serial", "")
+            mac = system_info.get("macAddr", "")
+            model = system_info.get("model", "")
+            unique_id = serial or mac or host
+        except BraviaError:
+            # System info may require PSK — use host as fallback
+            unique_id = host
+            model = discovery_info.upnp.get(
+                ssdp.ATTR_UPNP_MODEL_NAME, "Sony Bravia"
+            )
+
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured(updates={CONF_HOST: host})
+
+        self._discovered_host = host
+        self._discovered_model = model
+
+        self.context["title_placeholders"] = {"name": model or host}
+
+        return await self.async_step_user()

custom_components/bravia_rest_api/const.py

@@ -76,6 +76,29 @@
     270: "270\u00b0",
 }
 
+# Sleep timer options (value -> display label)
+SLEEP_TIMER_OPTIONS: Final = {
+    "off": "Off",
+    "15": "15 min",
+    "30": "30 min",
+    "45": "45 min",
+    "60": "60 min",
+    "90": "90 min",
+    "120": "120 min",
+}
+
+# Default picture modes (fallback — actual modes discovered at runtime)
+DEFAULT_PICTURE_MODES: Final = [
+    "Standard",
+    "Vivid",
+    "Cinema",
+    "Custom",
+    "Game",
+    "Graphics",
+    "Photo",
+    "Sports",
+]
+
 # WoL
 WOL_PORT: Final = 9
 

custom_components/bravia_rest_api/coordinator.py

@@ -124,16 +124,20 @@ async def _async_update_data(self) -> BraviaState:
         # TV is on — fetch detailed state
         try:
             volume_info = await self.client.get_volume_info()
+            # Prefer "speaker" or "" target, fall back to first available
+            chosen = None
             for item in volume_info:
-                if isinstance(item, dict) and item.get("target") in (
-                    "speaker",
-                    "",
-                ):
-                    state.volume = item.get("volume")
-                    state.is_muted = item.get("mute", False)
-                    state.max_volume = item.get("maxVolume", 100)
-                    state.min_volume = item.get("minVolume", 0)
-                    break
+                if isinstance(item, dict):
+                    if item.get("target") in ("speaker", ""):
+                        chosen = item
+                        break
+                    if chosen is None:
+                        chosen = item
+            if chosen:
+                state.volume = chosen.get("volume")
+                state.is_muted = chosen.get("mute", False)
+                state.max_volume = chosen.get("maxVolume", 100)
+                state.min_volume = chosen.get("minVolume", 0)
         except BraviaError as err:
             _LOGGER.debug("Could not fetch volume info: %s", err)
 

custom_components/bravia_rest_api/manifest.json

@@ -7,7 +7,12 @@
     "issue_tracker": "https://github.com/cmos486/Bravia-REST-API/issues",
     "integration_type": "device",
     "iot_class": "local_polling",
-    "version": "1.2.1",
+    "version": "1.3.0",
     "requirements": [],
-    "homeassistant": "2024.1.0"
+    "homeassistant": "2024.1.0",
+    "ssdp": [
+        {
+            "st": "urn:schemas-sony-com:service:ScalarWebAPI:1"
+        }
+    ]
 }

custom_components/bravia_rest_api/select.py

@@ -11,8 +11,10 @@
 
 from .bravia_client import BraviaError
 from .const import (
+    DEFAULT_PICTURE_MODES,
     DOMAIN,
     SCREEN_ROTATION_OPTIONS,
+    SLEEP_TIMER_OPTIONS,
     SOUND_OUTPUT_OPTIONS,
 )
 from .coordinator import BraviaCoordinator
@@ -32,6 +34,8 @@ async def async_setup_entry(
         [
             BraviaSoundOutputSelect(coordinator, entry),
             BraviaScreenRotationSelect(coordinator, entry),
+            BraviaPictureModeSelect(coordinator, entry),
+            BraviaSleepTimerSelect(coordinator, entry),
         ]
     )
 
@@ -142,3 +146,104 @@ async def async_added_to_hass(self) -> None:
             self._current_angle = await self.coordinator.client.get_screen_rotation()
         except BraviaError:
             pass
+
+
+class BraviaPictureModeSelect(BraviaEntity, SelectEntity):
+    """Select entity for picture mode (scene setting)."""
+
+    _attr_translation_key = "picture_mode"
+    _attr_icon = "mdi:image-filter-hdr"
+
+    def __init__(
+        self,
+        coordinator: BraviaCoordinator,
+        entry: ConfigEntry,
+    ) -> None:
+        super().__init__(coordinator, entry)
+        self._attr_unique_id = f"{entry.unique_id}_picture_mode"
+        self._attr_options = list(DEFAULT_PICTURE_MODES)
+        self._current: str | None = None
+
+    @property
+    def current_option(self) -> str | None:
+        """Return current picture mode."""
+        return self._current
+
+    async def async_select_option(self, option: str) -> None:
+        """Set picture mode."""
+        try:
+            await self.coordinator.client.set_scene_setting(option.lower())
+            self._current = option
+        except BraviaError as err:
+            _LOGGER.error("Failed to set picture mode: %s", err)
+
+    async def async_added_to_hass(self) -> None:
+        """Fetch current picture mode and discover available modes."""
+        await super().async_added_to_hass()
+        try:
+            current = await self.coordinator.client.get_scene_setting()
+            if current:
+                self._current = current.capitalize()
+                # Ensure current mode is in options
+                if self._current not in self._attr_options:
+                    self._attr_options.append(self._current)
+        except BraviaError:
+            pass
+
+
+class BraviaSleepTimerSelect(BraviaEntity, SelectEntity):
+    """Select entity for sleep timer."""
+
+    _attr_translation_key = "sleep_timer"
+    _attr_icon = "mdi:timer-outline"
+
+    def __init__(
+        self,
+        coordinator: BraviaCoordinator,
+        entry: ConfigEntry,
+    ) -> None:
+        super().__init__(coordinator, entry)
+        self._attr_unique_id = f"{entry.unique_id}_sleep_timer"
+        self._attr_options = list(SLEEP_TIMER_OPTIONS.values())
+        self._current_value: str = "off"
+
+    @property
+    def current_option(self) -> str | None:
+        """Return current sleep timer setting."""
+        return SLEEP_TIMER_OPTIONS.get(self._current_value)
+
+    async def async_select_option(self, option: str) -> None:
+        """Set sleep timer."""
+        # Reverse lookup: display name -> API value
+        api_value = None
+        for key, label in SLEEP_TIMER_OPTIONS.items():
+            if label == option:
+                api_value = key
+                break
+
+        if api_value is None:
+            _LOGGER.error("Unknown sleep timer option: %s", option)
+            return
+
+        try:
+            await self.coordinator.client.set_sleep_timer_settings(
+                [{"target": "sleepTimer", "value": api_value}]
+            )
+            self._current_value = api_value
+        except BraviaError as err:
+            _LOGGER.error("Failed to set sleep timer: %s", err)
+
+    async def async_added_to_hass(self) -> None:
+        """Fetch initial sleep timer state."""
+        await super().async_added_to_hass()
+        try:
+            settings = await self.coordinator.client.get_sleep_timer_settings()
+            if settings:
+                for setting in settings:
+                    if isinstance(setting, dict):
+                        value = str(setting.get("currentValue", "off"))
+                        if value in SLEEP_TIMER_OPTIONS:
+                            self._current_value = value
+                        break
+        except BraviaError:
+            pass

custom_components/bravia_rest_api/strings.json

@@ -19,7 +19,8 @@
             "invalid_auth": "Invalid Pre-Shared Key. Check the PSK configured on your TV."
         },
         "abort": {
-            "already_configured": "This TV is already configured."
+            "already_configured": "This TV is already configured.",
+            "cannot_connect": "Cannot connect to the discovered TV."
         }
     },
     "entity": {
@@ -43,6 +44,12 @@
             },
             "screen_rotation": {
                 "name": "Screen Rotation"
+            },
+            "picture_mode": {
+                "name": "Picture Mode"
+            },
+            "sleep_timer": {
+                "name": "Sleep Timer"
             }
         },
         "sensor": {

custom_components/bravia_rest_api/translations/es.json

@@ -19,7 +19,8 @@
             "invalid_auth": "Clave Pre-Compartida inv\u00e1lida. Verifica el PSK configurado en tu TV."
         },
         "abort": {
-            "already_configured": "Esta TV ya est\u00e1 configurada."
+            "already_configured": "Esta TV ya est\u00e1 configurada.",
+            "cannot_connect": "No se puede conectar a la TV detectada."
         }
     },
     "entity": {
@@ -43,6 +44,12 @@
             },
             "screen_rotation": {
                 "name": "Rotaci\u00f3n de Pantalla"
+            },
+            "picture_mode": {
+                "name": "Modo de Imagen"
+            },
+            "sleep_timer": {
+                "name": "Temporizador de Sue\u00f1o"
             }
         },
         "sensor": {