Alarm volume

.gitignore

@@ -2,3 +2,4 @@ __pycache__
 venv*
 .python-version
 .tox/
+/.idea

custom_components/google_home/api.py

@@ -15,13 +15,15 @@
 from homeassistant.core import HomeAssistant
 
 from .const import (
+    API_ENDPOINT_ALARM_DELETE,
+    API_ENDPOINT_ALARM_VOLUME,
     API_ENDPOINT_ALARMS,
-    API_ENDPOINT_DELETE,
     API_ENDPOINT_DO_NOT_DISTURB,
     API_ENDPOINT_REBOOT,
     HEADER_CAST_LOCAL_AUTH,
     HEADER_CONTENT_TYPE,
     JSON_ALARM,
+    JSON_ALARM_VOLUME,
     JSON_NOTIFICATIONS_ENABLED,
     JSON_TIMER,
     PORT,
@@ -195,7 +197,7 @@ async def delete_alarm_or_timer(
         )
 
         response = await self.request(
-            method="POST", endpoint=API_ENDPOINT_DELETE, device=device, data=data
+            method="POST", endpoint=API_ENDPOINT_ALARM_DELETE, device=device, data=data
         )
 
         if response is not None:
@@ -297,6 +299,57 @@ async def update_do_not_disturb(
 
         return device
 
+    async def update_alarm_volume(
+        self, device: GoogleHomeDevice, volume: float | None = None
+    ) -> GoogleHomeDevice:
+        """Gets or sets the alarm volume setting on a Google Home device."""
+
+        data: JsonDict | None = None
+        polling = False
+
+        if volume is not None:
+            # Setting is inverted on device
+            data = {JSON_ALARM_VOLUME: volume}
+            _LOGGER.debug(
+                "Setting Alarm Volume setting to %f on Google Home device %s",
+                volume,
+                device.name,
+            )
+        else:
+            polling = True
+            _LOGGER.debug(
+                "Getting Alarm Volume setting from Google Home device %s",
+                device.name,
+            )
+
+        response = await self.request(
+            method="POST",
+            endpoint=API_ENDPOINT_ALARM_VOLUME,
+            device=device,
+            data=data,
+            polling=polling,
+        )
+        if response is not None:
+            if JSON_NOTIFICATIONS_ENABLED in response:
+                volume_raw: str = str(response[JSON_ALARM_VOLUME])
+                loaded_volume: float = float(volume_raw)
+                _LOGGER.debug(
+                    "Received Alarm Volume setting from Google Home device %s"
+                    " - Volume: %f",
+                    device.name,
+                    loaded_volume,
+                )
+
+                device.set_alarm_volume(loaded_volume)
+            else:
+                _LOGGER.debug(
+                    "Response not expected from Google Home device %s - %s",
+                    device.name,
+                    response,
+                )
+
+        return device
+
     async def request(
         self,
         method: Literal["GET", "POST"],

custom_components/google_home/config_flow.py

@@ -86,7 +86,8 @@ async def _show_config_form(
             errors=self._errors,
         )
 
-    async def _test_credentials(self, client: GlocaltokensApiClient) -> str | None:
+    @staticmethod
+    async def _test_credentials(client: GlocaltokensApiClient) -> str | None:
         """Returns true and master token if credentials are valid."""
         try:
             master_token = await client.async_get_master_token()

custom_components/google_home/const.py

@@ -25,6 +25,10 @@
 ICON_ALARMS: Final[str] = "mdi:alarm-multiple"
 ICON_TIMERS: Final[str] = "mdi:timer-sand"
 ICON_DO_NOT_DISTURB: Final[str] = "mdi:minus-circle"
+ICON_ALARM_VOLUME_LOW: Final[str] = "mdi:volume-low"
+ICON_ALARM_VOLUME_MID: Final[str] = "mdi:volume-medium"
+ICON_ALARM_VOLUME_HIGH: Final[str] = "mdi:volume-high"
+ICON_ALARM_VOLUME_OFF: Final[str] = "mdi:volume-off"
 
 # Device classes
 BINARY_SENSOR_DEVICE_CLASS: Final[str] = "connectivity"
@@ -51,6 +55,7 @@
 DEFAULT_NAME: Final[str] = "Google Home"
 
 LABEL_ALARMS: Final[str] = "alarms"
+LABEL_ALARM_VOLUME: Final[str] = "alarm_volume"
 LABEL_AVAILABLE: Final[str] = "available"
 LABEL_TIMERS: Final[str] = "timers"
 LABEL_DEVICE: Final[str] = "device"
@@ -61,7 +66,8 @@
 
 # API
 API_ENDPOINT_ALARMS: Final[str] = "setup/assistant/alarms"
-API_ENDPOINT_DELETE: Final[str] = "setup/assistant/alarms/delete"
+API_ENDPOINT_ALARM_DELETE: Final[str] = "setup/assistant/alarms/delete"
+API_ENDPOINT_ALARM_VOLUME: Final[str] = "setup/assistant/alarms/volume"
 API_ENDPOINT_REBOOT: Final[str] = "setup/reboot"
 API_ENDPOINT_DO_NOT_DISTURB: Final[str] = "setup/assistant/notifications"
 
@@ -83,6 +89,10 @@
 JSON_ALARM: Final[str] = "alarm"
 JSON_TIMER: Final[str] = "timer"
 JSON_NOTIFICATIONS_ENABLED: Final[str] = "notifications_enabled"
+JSON_ALARM_VOLUME: Final[str] = "volume"
+
+# Device class names
+DEVICE_CLASS_ALARM_VOLUME = "google_home__alarm_volume"
 
 STARTUP_MESSAGE: Final[
     str

custom_components/google_home/models.py

@@ -4,6 +4,7 @@
 from datetime import timedelta
 from enum import Enum
 import sys
+from typing import Final
 
 from homeassistant.util.dt import as_local, utc_from_timestamp
 
@@ -37,6 +38,7 @@ def __init__(
         self.hardware = hardware
         self.available = True
         self._do_not_disturb = False
+        self._alarm_volume = GOOGLE_HOME_ALARM_DEFAULT_VALUE
         self._timers: list[GoogleHomeTimer] = []
         self._alarms: list[GoogleHomeAlarm] = []
 
@@ -100,6 +102,14 @@ def get_do_not_disturb(self) -> bool:
         """Return Do Not Disturb status."""
         return self._do_not_disturb
 
+    def set_alarm_volume(self, volume: float) -> None:
+        """Set Alarm Volume status."""
+        self._alarm_volume = volume
+
+    def get_alarm_volume(self) -> float:
+        """Return Alarm Volume status."""
+        return self._alarm_volume
+
 
 class GoogleHomeTimer:
     """Local representation of Google Home timer"""
@@ -193,3 +203,6 @@ class GoogleHomeTimerStatus(Enum):
     SET = 1
     PAUSED = 2
     RINGING = 3
+
+
+GOOGLE_HOME_ALARM_DEFAULT_VALUE: Final[float] = 1

custom_components/google_home/number.py

@@ -0,0 +1,125 @@
+"""Number Platform for Google Home"""
+from __future__ import annotations
+
+import logging
+from typing import Callable, Iterable
+
+from homeassistant.components.number import NumberEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+
+from .const import (
+    DATA_CLIENT,
+    DATA_COORDINATOR,
+    DEVICE_CLASS_ALARM_VOLUME,
+    DOMAIN,
+    ICON_ALARM_VOLUME_HIGH,
+    ICON_ALARM_VOLUME_LOW,
+    ICON_ALARM_VOLUME_MID,
+    ICON_ALARM_VOLUME_OFF,
+    LABEL_ALARM_VOLUME,
+)
+from .entity import GoogleHomeBaseEntity
+from .models import GOOGLE_HOME_ALARM_DEFAULT_VALUE
+from .types import AlarmVolumeAttributes
+
+_LOGGER: logging.Logger = logging.getLogger(__package__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_devices: Callable[[Iterable[NumberEntity]], None],
+) -> bool:
+    """Setup switch platform."""
+    client = hass.data[DOMAIN][entry.entry_id][DATA_CLIENT]
+    coordinator = hass.data[DOMAIN][entry.entry_id][DATA_COORDINATOR]
+
+    numbers: list[NumberEntity] = []
+    for device in coordinator.data:
+        if device.auth_token and device.available:
+            numbers.append(
+                AlarmVolumeNumber(
+                    coordinator,
+                    client,
+                    device.name,
+                )
+            )
+
+    if numbers:
+        async_add_devices(numbers)
+
+    return True
+
+
+class AlarmVolumeNumber(GoogleHomeBaseEntity, NumberEntity):
+    """Google Home Alarm Volume Number entity."""
+
+    @property
+    def label(self) -> str:
+        """Label to use for name and unique id."""
+        return LABEL_ALARM_VOLUME
+
+    @property
+    def unit_of_measurement(self) -> str | None:
+        """The unit of measurement for the entity"""
+        return PERCENTAGE
+
+    @property
+    def icon(self) -> str:
+        """Return the icon of the sensor."""
+        device = self.get_device()
+        if device is None:
+            return ICON_ALARM_VOLUME_HIGH
+        volume = device.get_alarm_volume()
+        if volume == 0:
+            return ICON_ALARM_VOLUME_OFF
+        if volume <= 0.3:
+            return ICON_ALARM_VOLUME_LOW
+        if volume <= 0.6:
+            return ICON_ALARM_VOLUME_MID
+        return ICON_ALARM_VOLUME_HIGH
+
+    @property
+    def min_value(self) -> float:
+        """Return the minimum value for the volume"""
+        return 0
+
+    @property
+    def max_value(self) -> float:
+        """Return the minimum value for the volume"""
+        return 1
+
+    @property
+    def step(self) -> float:
+        """Return the step value for the volume"""
+        return 0.01
+
+    @property
+    def value(self) -> float:
+        """Return the current volume value"""
+        device = self.get_device()
+
+        if device is None:
+            return GOOGLE_HOME_ALARM_DEFAULT_VALUE
+
+        volume = device.get_alarm_volume()
+        return volume
+
+    @property
+    def device_state_attributes(self) -> AlarmVolumeAttributes:
+        """Return the state attributes."""
+        return {
+            "device_class": DEVICE_CLASS_ALARM_VOLUME,
+            "integration": DOMAIN,
+        }
+
+    async def async_set_value(self, value: float) -> None:
+        """Sets the alarm volume"""
+        device = self.get_device()
+        if device is None:
+            _LOGGER.error("Device %s not found.", self.device_name)
+            return
+
+        await self.client.update_alarm_volume(device=device, volume=value)

custom_components/google_home/sensor.py

@@ -30,7 +30,12 @@
     SERVICE_REBOOT,
 )
 from .entity import GoogleHomeBaseEntity
-from .models import GoogleHomeAlarmStatus, GoogleHomeDevice, GoogleHomeTimerStatus
+from .models import (
+    GOOGLE_HOME_ALARM_DEFAULT_VALUE,
+    GoogleHomeAlarmStatus,
+    GoogleHomeDevice,
+    GoogleHomeTimerStatus,
+)
 from .types import (
     AlarmsAttributes,
     DeviceAttributes,
@@ -188,6 +193,7 @@ def device_state_attributes(self) -> AlarmsAttributes:
         """Return the state attributes."""
         return {
             "next_alarm_status": self._get_next_alarm_status(),
+            "alarm_volume": self._get_alarm_volume(),
             "alarms": self._get_alarms_data(),
             "integration": DOMAIN,
         }
@@ -202,6 +208,12 @@ def _get_next_alarm_status(self) -> str:
             else GoogleHomeAlarmStatus.NONE.name.lower()
         )
 
+    def _get_alarm_volume(self) -> float:
+        """Update alarm volume status from coordinator"""
+        device = self.get_device()
+        alarm_volume = device.get_alarm_volume() if device else None
+        return alarm_volume if alarm_volume else GOOGLE_HOME_ALARM_DEFAULT_VALUE
+
     def _get_alarms_data(self) -> list[GoogleHomeAlarmDict]:
         """Update alarms data extracting it from coordinator"""
         device = self.get_device()

custom_components/google_home/types.py

@@ -63,10 +63,18 @@ class AlarmsAttributes(TypedDict):
     """Typed dict for alarms attributes"""
 
     next_alarm_status: str
+    alarm_volume: float
     alarms: list[GoogleHomeAlarmDict]
     integration: str
 
 
+class AlarmVolumeAttributes(TypedDict):
+    """Typed dict for alarm volume attributes"""
+
+    device_class: str
+    integration: str
+
+
 class TimersAttributes(TypedDict):
     """Typed dict for timers attributes"""
 
@@ -90,5 +98,6 @@ class OptionsFlowDict(TypedDict):
 
 
 JsonDict = Mapping[
-    str, Union[bool, int, str, List[str], List[AlarmJsonDict], List[TimerJsonDict]]
+    str,
+    Union[bool, float, int, str, List[str], List[AlarmJsonDict], List[TimerJsonDict]],
 ]