feat: picture brightness control (number slider + select presets)

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: cmos486

README.md

@@ -150,6 +150,14 @@ The integration creates **30+ entities** for full TV control:
 | `button._ircc_stop` | Stop | ⏹️ |
 | `button._ircc_input` | Input selector | 🔌 |
 
+### 🔢 Numbers
+
+| Entity | Description |
+|--------|-------------|
+| `number._brightness` | Picture brightness slider (range discovered per TV model) |
+
+> Only created if the TV supports `getPictureQualitySettings` for the `brightness` target.
+
 ### 🎚️ Selects
 
 | Entity | Options |
@@ -158,6 +166,7 @@ The integration creates **30+ entities** for full TV control:
 | `select._screen_rotation` | 0°, 90°, 180°, 270° |
 | `select._picture_mode` | Standard, Vivid, Cinema, Custom, Game, Graphics, Photo, Sports |
 | `select._sleep_timer` | Off, 15 min, 30 min, 45 min, 60 min, 90 min, 120 min |
+| `select._brightness_preset` | Min, Low, Medium, High, Max (mapped to % of brightness range) |
 
 ### 📊 Sensors (Diagnostic)
 

custom_components/bravia_rest_api/__init__.py

@@ -32,6 +32,7 @@
     Platform.MEDIA_PLAYER,
     Platform.REMOTE,
     Platform.BUTTON,
+    Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,

custom_components/bravia_rest_api/bravia_client.py

@@ -475,6 +475,27 @@ async def set_picture_quality_settings(
             [{"settings": settings}],
         )
 
+    async def get_brightness(self) -> dict[str, Any] | None:
+        """Get current brightness info.
+
+        Returns the brightness setting dict (with currentValue, min, max, etc.)
+        or None if brightness is not supported by this TV.
+        """
+        try:
+            settings = await self.get_picture_quality_settings("brightness")
+        except BraviaApiError:
+            return None
+        for item in settings:
+            if isinstance(item, dict) and item.get("target") == "brightness":
+                return item
+        return None
+
+    async def set_brightness(self, value: int) -> None:
+        """Set brightness value (as integer within TV-reported range)."""
+        await self.set_picture_quality_settings(
+            [{"target": "brightness", "value": str(value)}]
+        )
+
     async def get_screen_rotation(self) -> int:
         """Get screen rotation angle."""
         result = await self._request(SERVICE_VIDEO, "getScreenRotation")

custom_components/bravia_rest_api/const.py

@@ -102,6 +102,15 @@
     "Sports",
 ]
 
+# Brightness presets (fraction of range 0.0-1.0)
+BRIGHTNESS_PRESETS: Final[dict[str, float]] = {
+    "Min": 0.0,
+    "Low": 0.25,
+    "Medium": 0.5,
+    "High": 0.75,
+    "Max": 1.0,
+}
+
 # WoL
 WOL_PORT: Final = 9
 

custom_components/bravia_rest_api/coordinator.py

@@ -44,6 +44,7 @@ class BraviaState:
     external_inputs: list[dict[str, Any]] = field(default_factory=list)
     app_list: list[dict[str, Any]] = field(default_factory=list)
     app_status: list[dict[str, str]] = field(default_factory=list)
+    brightness: int | None = None
     is_available: bool = False
 
     @property
@@ -78,6 +79,9 @@ def __init__(
         self.client = client
         self.ircc_codes = {}
         self.system_info = {}
+        self.brightness_supported = False
+        self.brightness_min = 0
+        self.brightness_max = 100
         self._app_list_fetched = False
         self._cached_app_list = []
 
@@ -104,6 +108,23 @@ async def async_setup(self) -> None:
         except BraviaError as err:
             _LOGGER.warning("Could not fetch IRCC codes: %s", err)
 
+        # Probe brightness capability (device-specific)
+        try:
+            info = await self.client.get_brightness()
+            if info is not None:
+                self.brightness_supported = True
+                self.brightness_min = int(info.get("min", 0))
+                self.brightness_max = int(info.get("max", 100))
+                _LOGGER.debug(
+                    "Brightness supported: range %d-%d",
+                    self.brightness_min,
+                    self.brightness_max,
+                )
+            else:
+                _LOGGER.debug("Brightness not available on this device")
+        except BraviaError as err:
+            _LOGGER.debug("Could not probe brightness capability: %s", err)
+
     async def _async_update_data(self) -> BraviaState:
         """Fetch latest state from the TV."""
         state = BraviaState()
@@ -167,6 +188,14 @@ async def _async_update_data(self) -> BraviaState:
         except BraviaError as err:
             _LOGGER.debug("Could not fetch app status: %s", err)
 
+        if self.brightness_supported:
+            try:
+                info = await self.client.get_brightness()
+                if info is not None:
+                    state.brightness = int(info.get("currentValue", 0))
+            except BraviaError as err:
+                _LOGGER.debug("Could not fetch brightness: %s", err)
+
         return state
 
     def get_ircc_code(self, command: str) -> str | None:

custom_components/bravia_rest_api/manifest.json

@@ -7,7 +7,7 @@
     "issue_tracker": "https://github.com/cmos486/Bravia-REST-API/issues",
     "integration_type": "device",
     "iot_class": "local_polling",
-    "version": "1.3.2",
+    "version": "1.4.0",
     "requirements": [],
     "homeassistant": "2024.1.0",
     "ssdp": [

custom_components/bravia_rest_api/number.py

@@ -0,0 +1,63 @@
+"""Number entities for Bravia REST API."""
+
+from __future__ import annotations
+
+import logging
+
+from homeassistant.components.number import NumberEntity, NumberMode
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .bravia_client import BraviaError
+from .const import DOMAIN
+from .coordinator import BraviaCoordinator
+from .entity import BraviaEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up Bravia REST API number entities."""
+    coordinator: BraviaCoordinator = hass.data[DOMAIN][entry.entry_id]
+    if coordinator.brightness_supported:
+        async_add_entities([BraviaBrightnessNumber(coordinator, entry)])
+
+
+class BraviaBrightnessNumber(BraviaEntity, NumberEntity):
+    """Number entity for TV picture brightness."""
+
+    _attr_translation_key = "brightness"
+    _attr_icon = "mdi:brightness-6"
+    _attr_mode = NumberMode.SLIDER
+    _attr_native_step = 1.0
+
+    def __init__(
+        self,
+        coordinator: BraviaCoordinator,
+        entry: ConfigEntry,
+    ) -> None:
+        super().__init__(coordinator, entry)
+        self._attr_unique_id = f"{entry.unique_id}_brightness"
+        self._attr_native_min_value = float(coordinator.brightness_min)
+        self._attr_native_max_value = float(coordinator.brightness_max)
+
+    @property
+    def native_value(self) -> float | None:
+        """Return the current brightness value."""
+        data = self.coordinator.data
+        if not data or data.brightness is None:
+            return None
+        return float(data.brightness)
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the brightness value."""
+        try:
+            await self.coordinator.client.set_brightness(int(value))
+        except BraviaError as err:
+            _LOGGER.error("Failed to set brightness: %s", err)
+        await self.coordinator.async_request_refresh()

custom_components/bravia_rest_api/select.py

@@ -11,6 +11,7 @@
 
 from .bravia_client import BraviaError
 from .const import (
+    BRIGHTNESS_PRESETS,
     DEFAULT_PICTURE_MODES,
     DOMAIN,
     SCREEN_ROTATION_OPTIONS,
@@ -30,14 +31,15 @@ async def async_setup_entry(
 ) -> None:
     """Set up Bravia REST API select entities."""
     coordinator: BraviaCoordinator = hass.data[DOMAIN][entry.entry_id]
-    async_add_entities(
-        [
-            BraviaSoundOutputSelect(coordinator, entry),
-            BraviaScreenRotationSelect(coordinator, entry),
-            BraviaPictureModeSelect(coordinator, entry),
-            BraviaSleepTimerSelect(coordinator, entry),
-        ]
-    )
+    entities: list[SelectEntity] = [
+        BraviaSoundOutputSelect(coordinator, entry),
+        BraviaScreenRotationSelect(coordinator, entry),
+        BraviaPictureModeSelect(coordinator, entry),
+        BraviaSleepTimerSelect(coordinator, entry),
+    ]
+    if coordinator.brightness_supported:
+        entities.append(BraviaBrightnessSelect(coordinator, entry))
+    async_add_entities(entities)
 
 
 class BraviaSoundOutputSelect(BraviaEntity, SelectEntity):
@@ -247,3 +249,58 @@ async def async_added_to_hass(self) -> None:
                         break
         except BraviaError:
             pass
+
+
+class BraviaBrightnessSelect(BraviaEntity, SelectEntity):
+    """Select entity for brightness presets."""
+
+    _attr_translation_key = "brightness_preset"
+    _attr_icon = "mdi:brightness-6"
+
+    def __init__(
+        self,
+        coordinator: BraviaCoordinator,
+        entry: ConfigEntry,
+    ) -> None:
+        super().__init__(coordinator, entry)
+        self._attr_unique_id = f"{entry.unique_id}_brightness_preset"
+        self._attr_options = list(BRIGHTNESS_PRESETS.keys())
+        self._bri_min = coordinator.brightness_min
+        self._bri_max = coordinator.brightness_max
+
+    def _value_for_preset(self, preset: str) -> int:
+        """Calculate brightness value for a preset name."""
+        fraction = BRIGHTNESS_PRESETS[preset]
+        return round(self._bri_min + fraction * (self._bri_max - self._bri_min))
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the closest brightness preset to the current value."""
+        data = self.coordinator.data
+        if not data or data.brightness is None:
+            return None
+        current = data.brightness
+        bri_range = self._bri_max - self._bri_min
+        if bri_range == 0:
+            return "Min"
+        fraction = (current - self._bri_min) / bri_range
+        closest = "Medium"
+        closest_dist = float("inf")
+        for name, pct in BRIGHTNESS_PRESETS.items():
+            dist = abs(fraction - pct)
+            if dist < closest_dist:
+                closest_dist = dist
+                closest = name
+        return closest
+
+    async def async_select_option(self, option: str) -> None:
+        """Set brightness to a preset value."""
+        if option not in BRIGHTNESS_PRESETS:
+            _LOGGER.error("Unknown brightness preset: %s", option)
+            return
+        value = self._value_for_preset(option)
+        try:
+            await self.coordinator.client.set_brightness(value)
+        except BraviaError as err:
+            _LOGGER.error("Failed to set brightness preset: %s", err)
+        await self.coordinator.async_request_refresh()

custom_components/bravia_rest_api/strings.json

@@ -52,6 +52,11 @@
                 "name": "Picture On"
             }
         },
+        "number": {
+            "brightness": {
+                "name": "Brightness"
+            }
+        },
         "select": {
             "sound_output": {
                 "name": "Sound Output"
@@ -64,6 +69,9 @@
             },
             "sleep_timer": {
                 "name": "Sleep Timer"
+            },
+            "brightness_preset": {
+                "name": "Brightness Preset"
             }
         },
         "sensor": {

custom_components/bravia_rest_api/translations/es.json

@@ -52,6 +52,11 @@
                 "name": "Encender Pantalla"
             }
         },
+        "number": {
+            "brightness": {
+                "name": "Brillo"
+            }
+        },
         "select": {
             "sound_output": {
                 "name": "Salida de Audio"
@@ -64,6 +69,9 @@
             },
             "sleep_timer": {
                 "name": "Temporizador de Sue\u00f1o"
+            },
+            "brightness_preset": {
+                "name": "Preajuste de Brillo"
             }
         },
         "sensor": {