Add support for favorites

aiorussound/connection.py

@@ -31,12 +31,17 @@ def _process_response(res: bytes) -> Optional[RussoundMessage]:
     if tag == "E":
         _LOGGER.debug("Device responded with error: %s", payload)
         raise CommandError(payload)
+
     m = RESPONSE_REGEX.match(payload.strip())
+
     if not m:
         return RussoundMessage(tag, None, None, None, None, None)
+
     p = m.groupdict()
     value = p["value"] or p["value_only"]
-    return RussoundMessage(tag, p["variable"], value, p["zone"], p["controller"], p["source"])
+    variable = p["variable"] or p["variable_only"]
+
+    return RussoundMessage(tag, variable, value, p["zone"], p["controller"], p["source"])
 
 
 class RussoundConnectionHandler:
@@ -129,7 +134,7 @@ async def close(self):
         self._set_connected(False)
 
     async def _ioloop(
-            self, reader: StreamReader, writer: StreamWriter, reconnect: bool
+        self, reader: StreamReader, writer: StreamWriter, reconnect: bool
     ) -> None:
         queue_future = ensure_future(self._cmd_queue.get())
         net_future = ensure_future(reader.readline())

aiorussound/const.py

@@ -15,6 +15,8 @@
 
 MAX_SOURCE = 17
 
+SYSTEM_VARIABLES = "System"
+
 RESPONSE_REGEX = re.compile(
     r"^(?:C\[(?P<controller>\d+)](?:\.Z\[(?P<zone>\d+)])?|S\[(?P<source>\d+)])?\."
     r"(?P<variable>\S+)=\s*\"(?P<value>.*)\"$|^(?P<variable_only>\S+)=\s*\"(?P<value_only>.*)\"$"
@@ -154,7 +156,19 @@ class FeatureFlag(Enum):
 
 VERSIONS_BY_FLAGS = defaultdict(list)
 
-ZONE_PROPERTIES: list[str] = ["currentSource"]
+ZONE_PROPERTIES: list[str] = [
+    "currentSource",
+    "favorite[1].valid",
+    "favorite[1].name",
+    "favorite[1].providerMode",
+    "favorite[1].albumCoverURL",
+    "favorite[1].source",
+    "favorite[2].valid",
+    "favorite[2].name",
+    "favorite[2].providerMode",
+    "favorite[2].albumCoverURL",
+    "favorite[2].source",
+]
 
 SOURCE_PROPERTIES: list[str] = []
 

aiorussound/models.py

@@ -6,6 +6,18 @@
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 
+@dataclass
+class RussoundFavorite:
+    """Russound Favorite."""
+
+    favorite_id: int
+    issystemfavorite: bool
+    name: str
+    providermode: str
+    albumcoverurl: str
+    source_id: int
+
+
 @dataclass
 class RussoundMessage:
     """Incoming russound message."""
@@ -63,4 +75,4 @@ class SourceProperties(DataClassORJSONMixin):
     bit_rate: str = field(metadata=field_options(alias="bitrate"), default=None)
     bit_depth: str = field(metadata=field_options(alias="bitdepth"), default=None)
     play_time: str = field(metadata=field_options(alias="playtime"), default=None)
-    track_time: str = field(metadata=field_options(alias="tracktime"), default=None)
+    track_time: str = field(metadata=field_options(alias="tracktime"), default=None)

aiorussound/rio.py

@@ -13,13 +13,14 @@
     SOURCE_PROPERTIES,
     ZONE_PROPERTIES,
     FeatureFlag,
+    SYSTEM_VARIABLES,
 )
 from aiorussound.exceptions import (
     CommandError,
     UncachedVariableError,
     UnsupportedFeatureError,
 )
-from aiorussound.models import RussoundMessage, ZoneProperties, SourceProperties
+from aiorussound.models import RussoundMessage, ZoneProperties, SourceProperties, RussoundFavorite
 from aiorussound.util import (
     controller_device_str,
     get_max_zones,
@@ -36,7 +37,7 @@ class RussoundClient:
     """Manages the RIO connection to a Russound device."""
 
     def __init__(
-            self, connection_handler: RussoundConnectionHandler
+                self, connection_handler: RussoundConnectionHandler
     ) -> None:
         """Initialize the Russound object using the event loop, host and port
         provided.
@@ -94,6 +95,8 @@ def _on_msg_recv(self, msg: RussoundMessage) -> None:
             self._store_cached_variable(
                 zone_device_str(controller_id, zone_id), msg.variable, msg.value
             )
+        elif msg.variable:
+            self._store_cached_variable(SYSTEM_VARIABLES, msg.variable, msg.value)
 
     def add_callback(self, device_str: str, callback) -> None:
         """Register a callback to be called whenever a device variable changes.
@@ -126,7 +129,7 @@ async def close(self) -> None:
         await self.connection_handler.close()
 
     async def set_variable(
-            self, device_str: str, key: str, value: str
+        self, device_str: str, key: str, value: str
     ) -> Coroutine[Any, Any, str]:
         """Set a zone variable to a new value."""
         return self.connection_handler.send(f'SET {device_str}.{key}="{value}"')
@@ -173,7 +176,7 @@ async def enumerate_controllers(self) -> dict[int, Controller]:
                     pass
                 firmware_version = None
                 if is_feature_supported(
-                        self.rio_version, FeatureFlag.PROPERTY_FIRMWARE_VERSION
+                    self.rio_version, FeatureFlag.PROPERTY_FIRMWARE_VERSION
                 ):
                     firmware_version = await self.get_variable(
                         device_str, "firmwareVersion"
@@ -232,18 +235,105 @@ async def init_sources(self) -> None:
             except CommandError:
                 break
 
+    async def enumerate_zone_favorites(self, zone: Zone) -> list[RussoundFavorite]:
+        """Return a list of RussoundFavorite for this zone."""
+        favorites = []
+
+        for favorite_id in range(1, 2):
+            try:
+                valid = await self.get_variable(
+                    zone.device_str(), f"favorite[{favorite_id}].valid"
+                )
+                if valid == "TRUE":
+                    try:
+                        name = await self.get_variable(
+                            zone.device_str(), f"favorite[{favorite_id}].name"
+                        )
+                        providerMode = await self.get_variable(
+                            zone.device_str(), f"favorite[{favorite_id}].providerMode"
+                        )
+                        albumCoverURL = await self.get_variable(
+                            zone.device_str(), f"favorite[{favorite_id}].albumCoverURL"
+                        )
+                        source_id = await self.get_variable(
+                            zone.device_str(), f"favorite[{favorite_id}].source"
+                        )
+
+                        favorites.append(
+                            RussoundFavorite(
+                                favorite_id,
+                                False,
+                                name,
+                                providerMode,
+                                albumCoverURL,
+                                source_id,
+                            )
+                        )
+                    except CommandError:
+                        break
+            except CommandError:
+                continue
+        return favorites
+
+    async def enumerate_system_favorites(self) -> list[RussoundFavorite]:
+        """Return a list of RussoundFavorite for this system."""
+        favorites = []
+
+        for favorite_id in range(1, 32):
+            try:
+                valid = await self._get_system_favorite_variable(favorite_id, "valid")
+                if valid == "TRUE":
+                    try:
+                        name = await self._get_system_favorite_variable(
+                            favorite_id, "name"
+                        )
+                        providerMode = await self._get_system_favorite_variable(
+                            favorite_id, "providerMode"
+                        )
+                        albumCoverURL = await self._get_system_favorite_variable(
+                            favorite_id, "albumCoverURL"
+                        )
+                        source_id = await self._get_system_favorite_variable(
+                            favorite_id, "source"
+                        )
+
+                        favorites.append(
+                            RussoundFavorite(
+                                favorite_id,
+                                True,
+                                name,
+                                providerMode,
+                                albumCoverURL,
+                                source_id,
+                            )
+                        )
+                    except CommandError:
+                        break
+            except CommandError:
+                continue
+        return favorites
+
+    async def _get_system_favorite_variable(self, favorite_id, variable) -> str:
+        """Return a system favorite variable."""
+        try:
+            return await self.get_variable(
+                SYSTEM_VARIABLES, f"favorite[{favorite_id}].{variable}"
+            )
+        except UncachedVariableError:
+            return "False"
+
 
 class Controller:
     """Uniquely identifies a controller."""
 
     def __init__(
-            self,
-            instance: RussoundClient,
-            parent_controller: Controller,
-            controller_id: int,
-            mac_address: str,
-            controller_type: str,
-            firmware_version: str,
+        self,
+        instance: RussoundClient,
+        parent_controller: Controller,
+        controller_id: int,
+        mac_address: str,
+        controller_type: str,
+        firmware_version: str,
     ) -> None:
         """Initialize the controller."""
         self.instance = instance
@@ -266,8 +356,8 @@ def __str__(self) -> str:
     def __eq__(self, other: object) -> bool:
         """Equality check."""
         return (
-                hasattr(other, "controller_id")
-                and other.controller_id == self.controller_id
+            hasattr(other, "controller_id")
+            and other.controller_id == self.controller_id
         )
 
     def __hash__(self) -> int:
@@ -307,7 +397,7 @@ class Zone:
     """
 
     def __init__(
-            self, instance: RussoundClient, controller: Controller, zone_id: int, name: str
+        self, instance: RussoundClient, controller: Controller, zone_id: int, name: str
     ) -> None:
         """Initialize a zone object."""
         self.instance = instance
@@ -330,10 +420,10 @@ def __str__(self) -> str:
     def __eq__(self, other: object) -> bool:
         """Equality check."""
         return (
-                hasattr(other, "zone_id")
-                and hasattr(other, "controller")
-                and other.zone_id == self.zone_id
-                and other.controller == self.controller
+            hasattr(other, "zone_id")
+            and hasattr(other, "controller")
+            and other.zone_id == self.zone_id
+            and other.controller == self.controller
         )
 
     def __hash__(self) -> int:
@@ -440,7 +530,7 @@ class Source:
     """Uniquely identifies a Source."""
 
     def __init__(
-            self, instance: RussoundClient, source_id: int, name: str
+                self, instance: RussoundClient, source_id: int, name: str
     ) -> None:
         """Initialize a Source."""
         self.instance = instance
@@ -466,7 +556,7 @@ def __eq__(self, other: object) -> bool:
                 and other.source_id == self.source_id
         )
 
-    def __hash__(self) -> int:
+        def __hash__(self) -> int:
         """Hash the current configuration of the source."""
         return hash(str(self))