lghorizon 0.9.0.dev2__py3-none-any.whl → 0.9.0.dev4__py3-none-any.whl

{lghorizon-0.9.0.dev2.dist-info → lghorizon-0.9.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lghorizon
-Version: 0.9.0.dev2
+Version: 0.9.0.dev4
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins

lghorizon-0.9.0.dev4.dist-info/RECORD

@@ -0,0 +1,12 @@
+lghorizon/__init__.py,sha256=GrctR8IIj0G7Sps_N_YjvKsrvMcbhp3O0KxE7yi-_R8,991
+lghorizon/const.py,sha256=j_rugTybx8n2kKEKaRWhgAFzBSEKztWTBFP7ABuMEgg,5013
+lghorizon/exceptions.py,sha256=-6v55KDTogBldGAg1wV9Mrxm5L5BsaVguhBgVMOeJHk,404
+lghorizon/helpers.py,sha256=W7ppV9MJ1MyXH_49GliNtiu_kA7h1KRzMdmRdrC5kaw,266
+lghorizon/lghorizon_api.py,sha256=PgQdW38yK30Lg45K4gvZEpYTK6NGGArhtu-gzuU_L-M,22279
+lghorizon/models.py,sha256=W9Op8sq3NJHFWe2sk94o3TE9FIM1J6ZjDCCCg8VrpCM,26268
+lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lghorizon-0.9.0.dev4.dist-info/licenses/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
+lghorizon-0.9.0.dev4.dist-info/METADATA,sha256=AwhqG5MYcrM7uyh-hM0AF7Xc_lD_7HFB-3SGLs8IuRc,1287
+lghorizon-0.9.0.dev4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lghorizon-0.9.0.dev4.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
+lghorizon-0.9.0.dev4.dist-info/RECORD,,

lghorizon/lghorizon_device.py

@@ -1,336 +0,0 @@
-"""LG Horizon Device."""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Any, Callable, Coroutine, Dict, Optional
-from .lghorizon_models import (
-    LGHorizonRunningState,
-    LGHorizonStatusMessage,
-    LGHorizonUIStatusMessage,
-    LGHorizonDeviceState,
-    LGHorizonAuth,
-    LGHorizonChannel,
-)
-
-from .exceptions import LGHorizonApiConnectionError
-from .helpers import make_id
-from .lghorizon_device_state_processor import LGHorizonDeviceStateProcessor
-from .lghorizon_mqtt_client import LGHorizonMqttClient
-from .const import (
-    MEDIA_KEY_CHANNEL_DOWN,
-    MEDIA_KEY_CHANNEL_UP,
-    MEDIA_KEY_ENTER,
-    MEDIA_KEY_FAST_FORWARD,
-    MEDIA_KEY_PLAY_PAUSE,
-    MEDIA_KEY_POWER,
-    MEDIA_KEY_RECORD,
-    MEDIA_KEY_REWIND,
-    MEDIA_KEY_STOP,
-    ONLINE_RUNNING,
-    PLATFORM_TYPES,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class LGHorizonDevice:
-    """The LG Horizon device (set-top box)."""
-
-    _device_id: str
-    _hashed_cpe_id: str
-    _device_friendly_name: str
-    _platform_type: str
-    _device_state: LGHorizonDeviceState
-    _manufacturer: Optional[str]
-    _model: Optional[str]
-    _recording_capacity: Optional[int]
-    _device_state_processor: LGHorizonDeviceStateProcessor
-    _mqtt_client: LGHorizonMqttClient
-    _change_callback: Callable[[str], Coroutine[Any, Any, Any]]
-    _auth: LGHorizonAuth
-    _channels: Dict[str, LGHorizonChannel]
-    _last_ui_message_timestamp: int = 0
-
-    def __init__(
-        self,
-        device_json,
-        mqtt_client: LGHorizonMqttClient,
-        device_state_processor: LGHorizonDeviceStateProcessor,
-        auth: LGHorizonAuth,
-        channels: Dict[str, LGHorizonChannel],
-    ):
-        """Initialize the LG Horizon device."""
-        self._device_id = device_json["deviceId"]
-        self._hashed_cpe_id = device_json["hashedCPEId"]
-        self._device_friendly_name = device_json["settings"]["deviceFriendlyName"]
-        self._platform_type = device_json.get("platformType")
-        self._mqtt_client = mqtt_client
-        self._auth = auth
-        self._channels = channels
-        self._device_state = LGHorizonDeviceState()  # Initialize state
-        self._manufacturer = None
-        self._model = None
-        self._recording_capacity = None
-        self._device_state_processor = device_state_processor
-
-    @property
-    def device_id(self) -> str:
-        """Return the device ID."""
-        return self._device_id
-
-    @property
-    def platform_type(self) -> str:
-        """Return the device ID."""
-        return self._platform_type
-
-    @property
-    def manufacturer(self) -> str:
-        """Return the manufacturer of the settop box."""
-        platform_info = PLATFORM_TYPES.get(self._platform_type, dict())
-        return platform_info.get("manufacturer", "unknown")
-
-    @property
-    def model(self) -> str:
-        """Return the model of the settop box."""
-        platform_info = PLATFORM_TYPES.get(self._platform_type, dict())
-        return platform_info.get("model", "unknown")
-
-    @property
-    def is_available(self) -> bool:
-        """Return the availability of the settop box."""
-        return self._device_state.state in (
-            LGHorizonRunningState.ONLINE_RUNNING,
-            LGHorizonRunningState.ONLINE_STANDBY,
-        )
-
-    @property
-    def hashed_cpe_id(self) -> str:
-        """Return the hashed CPE ID."""
-        return self._hashed_cpe_id
-
-    @property
-    def device_friendly_name(self) -> str:
-        """Return the device friendly name."""
-        return self._device_friendly_name
-
-    @property
-    def device_state(self) -> LGHorizonDeviceState:
-        """Return the current playing information."""
-        return self._device_state
-
-    @property
-    def recording_capacity(self) -> Optional[int]:
-        """Return the recording capacity used."""
-        return self._recording_capacity
-
-    @recording_capacity.setter
-    def recording_capacity(self, value: int) -> None:
-        """Set the recording capacity used."""
-        self._recording_capacity = value
-
-    @property
-    def last_ui_message_timestamp(self) -> int:
-        """Return the last ui message timestamp."""
-        return self._last_ui_message_timestamp
-
-    @last_ui_message_timestamp.setter
-    def last_ui_message_timestamp(self, value: int) -> None:
-        """Set the last ui message timestamp."""
-        self._last_ui_message_timestamp = value
-
-    async def update_channels(self, channels: Dict[str, LGHorizonChannel]):
-        """Update the channels list."""
-        self._channels = channels
-
-    async def register_mqtt(self) -> None:
-        """Register the mqtt connection."""
-        if not self._mqtt_client.is_connected:
-            raise LGHorizonApiConnectionError("MQTT client not connected.")
-        topic = f"{self._auth.household_id}/{self._mqtt_client.client_id}/status"
-        payload = {
-            "source": self._mqtt_client.client_id,
-            "state": ONLINE_RUNNING,
-            "deviceType": "HGO",
-        }
-        await self._mqtt_client.publish_message(topic, json.dumps(payload))
-
-    async def set_callback(
-        self, change_callback: Callable[[str], Coroutine[Any, Any, Any]]
-    ) -> None:
-        """Set a callback function."""
-        self._change_callback = change_callback
-        await self.register_mqtt()  # type: ignore [assignment] # Callback can be None
-
-    async def handle_status_message(
-        self, status_message: LGHorizonStatusMessage
-    ) -> None:
-        """Register a new settop box."""
-        old_running_state = self.device_state.state
-        new_running_state = status_message.running_state
-        if (
-            old_running_state == new_running_state
-        ):  # Access backing field for comparison
-            return
-        await self._device_state_processor.process_state(
-            self.device_state, status_message
-        )  # Use the setter
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self._request_settop_box_state()
-
-        await self._trigger_callback()
-        await self._request_settop_box_recording_capacity()
-
-    async def handle_ui_status_message(
-        self, status_message: LGHorizonUIStatusMessage
-    ) -> None:
-        """Handle UI status message."""
-
-        await self._device_state_processor.process_ui_state(
-            self.device_state, status_message
-        )
-        self.last_ui_message_timestamp = status_message.message_timestamp
-        await self._trigger_callback()
-
-    async def update_recording_capacity(self, payload) -> None:
-        """Updates the recording capacity."""
-        if "CPE.capacity" not in payload or "used" not in payload:
-            return
-        self.recording_capacity = payload["used"]  # Use the setter
-
-    async def _trigger_callback(self):
-        if self._change_callback:
-            _LOGGER.debug("Callback called from box %s", self.device_id)
-            await self._change_callback(self.device_id)
-
-    async def turn_on(self) -> None:
-        """Turn the settop box on."""
-
-        if self._device_state.state == LGHorizonRunningState.ONLINE_STANDBY:
-            await self.send_key_to_box(MEDIA_KEY_POWER)
-
-    async def turn_off(self) -> None:
-        """Turn the settop box off."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_POWER)
-            await self._device_state.reset()
-
-    async def pause(self) -> None:
-        """Pause the given settopbox."""
-        if (
-            self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING
-            and not self._device_state.paused
-        ):
-            await self.send_key_to_box(MEDIA_KEY_PLAY_PAUSE)
-
-    async def play(self) -> None:
-        """Resume the settopbox."""
-        if (
-            self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING
-            and self._device_state.paused
-        ):
-            await self.send_key_to_box(MEDIA_KEY_PLAY_PAUSE)
-
-    async def stop(self) -> None:
-        """Stop the settopbox."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_STOP)
-
-    async def next_channel(self):
-        """Select the next channel for given settop box."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_CHANNEL_UP)
-
-    async def previous_channel(self) -> None:
-        """Select the previous channel for given settop box."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_CHANNEL_DOWN)
-
-    async def press_enter(self) -> None:
-        """Press enter on the settop box."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_ENTER)
-
-    async def rewind(self) -> None:
-        """Rewind the settop box."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_REWIND)
-
-    async def fast_forward(self) -> None:
-        """Fast forward the settop box."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_FAST_FORWARD)
-
-    async def record(self):
-        """Record on the settop box."""
-        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
-            await self.send_key_to_box(MEDIA_KEY_RECORD)
-
-    async def set_channel(self, source: str) -> None:
-        """Change te channel from the settopbox."""
-        channel = [src for src in self._channels.values() if src.title == source][0]
-        payload = (
-            '{"id":"'
-            + await make_id(8)
-            + '","type":"CPE.pushToTV","source":{"clientId":"'
-            + self._mqtt_client.client_id
-            + '","friendlyDeviceName":"Home Assistant"},'
-            + '"status":{"sourceType":"linear","source":{"channelId":"'
-            + channel.id
-            + '"},"relativePosition":0,"speed":1}}'
-        )
-
-        await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", payload
-        )
-
-    async def play_recording(self, recording_id):
-        """Play recording."""
-        payload = (
-            '{"id":"'
-            + await make_id(8)
-            + '","type":"CPE.pushToTV","source":{"clientId":"'
-            + self._mqtt_client.client_id
-            + '","friendlyDeviceName":"Home Assistant"},'
-            + '"status":{"sourceType":"nDVR","source":{"recordingId":"'
-            + recording_id
-            + '"},"relativePosition":0}}'
-        )
-        await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", payload
-        )
-
-    async def send_key_to_box(self, key: str) -> None:
-        """Send emulated (remote) key press to settopbox."""
-        payload_dict = {
-            "type": "CPE.KeyEvent",
-            "runtimeType": "key",
-            "id": "ha",
-            "source": self.device_id.lower(),
-            "status": {"w3cKey": key, "eventType": "keyDownUp"},
-        }
-        payload = json.dumps(payload_dict)
-        await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", payload
-        )
-
-    async def _request_settop_box_state(self) -> None:
-        """Send mqtt message to receive state from settop box."""
-        topic = f"{self._auth.household_id}/{self.device_id}"
-        payload = {
-            "id": await make_id(8),
-            "type": "CPE.getUiStatus",
-            "source": self._mqtt_client.client_id,
-        }
-        await self._mqtt_client.publish_message(topic, json.dumps(payload))
-
-    async def _request_settop_box_recording_capacity(self) -> None:
-        """Send mqtt message to receive state from settop box."""
-        topic = f"{self._auth.household_id}/{self.device_id}"
-        payload = {
-            "id": await make_id(8),
-            "type": "CPE.capacity",
-            "source": self._mqtt_client.client_id,
-        }
-        await self._mqtt_client.publish_message(topic, json.dumps(payload))

lghorizon/lghorizon_device_state_processor.py

@@ -1,301 +0,0 @@
-"""LG Horizon device (set-top box) model."""
-
-import random
-import json
-import urllib.parse
-
-from typing import cast, Dict, Optional
-
-from .lghorizon_models import LGHorizonDeviceState, LGHorizonRunningState
-from .lghorizon_models import LGHorizonStatusMessage, LGHorizonUIStatusMessage
-from .lghorizon_models import (
-    LGHorizonSourceType,
-    LGHorizonLinearSource,
-    LGHorizonVODSource,
-    LGHorizonReplaySource,
-    LGHorizonNDVRSource,
-    LGHorizonReviewBufferSource,
-)
-from .lghorizon_models import LGHorizonAuth
-from .lghorizon_models import (
-    LGHorizonReplayEvent,
-    LGHorizonVOD,
-)
-
-from .lghorizon_models import LGHorizonRecordingSingle
-from .lghorizon_models import LGHorizonChannel
-from .lghorizon_models import (
-    LGHorizonUIStateType,
-    LGHorizonAppsState,
-    LGHorizonPlayerState,
-)
-from .lghorizon_models import LGHorizonCustomer
-
-
-class LGHorizonDeviceStateProcessor:
-    """Process incoming device state messages"""
-
-    def __init__(
-        self,
-        auth: LGHorizonAuth,
-        channels: Dict[str, LGHorizonChannel],
-        customer: LGHorizonCustomer,
-        profile_id: str,
-    ):
-        self._auth = auth
-        self._channels = channels
-        self._customer = customer
-        self._profile_id = profile_id
-
-    async def process_state(
-        self, device_state: LGHorizonDeviceState, status_message: LGHorizonStatusMessage
-    ) -> None:
-        """Process the device state based on the status message."""
-        await device_state.reset()
-        device_state.state = status_message.running_state
-
-    async def process_ui_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        ui_status_message: LGHorizonUIStatusMessage,
-    ) -> None:
-        """Process the device state based on the UI status message."""
-        await device_state.reset()
-        if (
-            ui_status_message.ui_state is None
-            or device_state.state == LGHorizonRunningState.ONLINE_STANDBY
-        ):
-            await device_state.reset()
-            return
-
-        if ui_status_message.ui_state is None:
-            return
-        match ui_status_message.ui_state.ui_status:
-            case LGHorizonUIStateType.MAINUI:
-                if ui_status_message.ui_state.player_state is None:
-                    return
-                await self._process_main_ui_state(
-                    device_state, ui_status_message.ui_state.player_state
-                )
-            case LGHorizonUIStateType.APPS:
-                if ui_status_message.ui_state.apps_state is None:
-                    return
-                await self._process_apps_state(
-                    device_state, ui_status_message.ui_state.apps_state
-                )
-
-        if ui_status_message.ui_state.ui_status == LGHorizonUIStateType.APPS:
-            return
-
-        if ui_status_message.ui_state.player_state is None:
-            return
-
-    async def _process_main_ui_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        player_state: LGHorizonPlayerState,
-    ) -> None:
-        if player_state is None:
-            return
-        await device_state.reset()
-        device_state.source_type = player_state.source_type
-        match player_state.source_type:
-            case LGHorizonSourceType.LINEAR:
-                await self._process_linear_state(device_state, player_state)
-            case LGHorizonSourceType.REVIEWBUFFER:
-                await self._process_reviewbuffer_state(device_state, player_state)
-            case LGHorizonSourceType.REPLAY:
-                await self._process_replay_state(device_state, player_state)
-            case LGHorizonSourceType.VOD:
-                await self._process_vod_state(device_state, player_state)
-            case LGHorizonSourceType.NDVR:
-                await self._process_ndvr_state(device_state, player_state)
-
-    async def _process_apps_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        apps_state: LGHorizonAppsState,
-    ) -> None:
-        device_state.channel_id = apps_state.id
-        device_state.title = apps_state.app_name
-        device_state.image = apps_state.logo_path
-
-    async def _process_linear_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        player_state: LGHorizonPlayerState,
-    ) -> None:
-        """Process the device state based on the UI status message."""
-        if player_state.source is None:
-            return
-        player_state.source.__class__ = LGHorizonLinearSource
-        source = cast(LGHorizonLinearSource, player_state.source)
-        service_config = await self._auth.get_service_config()
-        service_url = await service_config.get_service_url("linearService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        service_path = f"/v2/replayEvent/{source.event_id}?returnLinearContent=true&language={lang}"
-
-        event_json = await self._auth.request(
-            service_url,
-            service_path,
-        )
-        replay_event = LGHorizonReplayEvent(event_json)
-        channel = self._channels[replay_event.channel_id]
-        device_state.source_type = source.source_type
-        device_state.channel_id = channel.channel_number
-        device_state.channel_name = channel.title
-        device_state.title = replay_event.title
-        device_state.sub_title = replay_event.full_episode_title
-
-        # Add random number to url to force refresh
-        join_param = "?"
-        if join_param in channel.stream_image:
-            join_param = "&"
-        image_url = (
-            f"{channel.stream_image}{join_param}{str(random.randrange(1000000))}"
-        )
-        device_state.image = image_url
-        await device_state.reset_progress()
-
-    async def _process_reviewbuffer_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        player_state: LGHorizonPlayerState,
-    ) -> None:
-        """Process the device state based on the UI status message."""
-        if player_state.source is None:
-            return
-        player_state.source.__class__ = LGHorizonReviewBufferSource
-        source = cast(LGHorizonReviewBufferSource, player_state.source)
-        service_config = await self._auth.get_service_config()
-        service_url = await service_config.get_service_url("linearService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        service_path = f"/v2/replayEvent/{source.event_id}?returnLinearContent=true&language={lang}"
-
-        event_json = await self._auth.request(
-            service_url,
-            service_path,
-        )
-        replay_event = LGHorizonReplayEvent(event_json)
-        channel = self._channels[replay_event.channel_id]
-        device_state.source_type = source.source_type
-        device_state.channel_id = channel.channel_number
-        device_state.channel_name = channel.title
-        device_state.title = replay_event.title
-        device_state.sub_title = replay_event.full_episode_title
-
-        # Add random number to url to force refresh
-        join_param = "?"
-        if join_param in channel.stream_image:
-            join_param = "&"
-        image_url = (
-            f"{channel.stream_image}{join_param}{str(random.randrange(1000000))}"
-        )
-        device_state.image = image_url
-        await device_state.reset_progress()
-
-    async def _process_replay_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        player_state: LGHorizonPlayerState,
-    ) -> None:
-        """Process the device state based on the UI status message."""
-        if player_state.source is None:
-            return
-        player_state.source.__class__ = LGHorizonReplaySource
-        source = cast(LGHorizonReplaySource, player_state.source)
-        service_config = await self._auth.get_service_config()
-        service_url = await service_config.get_service_url("linearService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        service_path = f"/v2/replayEvent/{source.event_id}?returnLinearContent=true&language={lang}"
-
-        event_json = await self._auth.request(
-            service_url,
-            service_path,
-        )
-        replay_event = LGHorizonReplayEvent(event_json)
-        device_state.source_type = source.source_type
-        device_state.channel_id = None
-        device_state.title = replay_event.title
-        if replay_event.full_episode_title:
-            device_state.sub_title = replay_event.full_episode_title
-
-        # Add random number to url to force refresh
-        device_state.image = await self._get_intent_image_url(replay_event.event_id)
-        await device_state.reset_progress()
-
-    async def _process_vod_state(
-        self,
-        device_state: LGHorizonDeviceState,
-        player_state: LGHorizonPlayerState,
-    ) -> None:
-        """Process the device state based on the UI status message."""
-        if player_state.source is None:
-            return
-        player_state.source.__class__ = LGHorizonVODSource
-        source = cast(LGHorizonVODSource, player_state.source)
-        service_config = await self._auth.get_service_config()
-        service_url = await service_config.get_service_url("vodService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        service_path = f"/v2/detailscreen/{source.title_id}?language={lang}&profileId={self._profile_id}&cityId={self._customer.city_id}"
-
-        vod_json = await self._auth.request(
-            service_url,
-            service_path,
-        )
-        vod = LGHorizonVOD(vod_json)
-        device_state.title = vod.title
-        device_state.sub_title = vod.full_episode_title
-        device_state.duration = vod.duration
-        device_state.image = await self._get_intent_image_url(vod.id)
-        await device_state.reset_progress()
-
-    async def _process_ndvr_state(
-        self, device_state: LGHorizonDeviceState, player_state: LGHorizonPlayerState
-    ) -> None:
-        """Process the device state based on the UI status message."""
-        if player_state.source is None:
-            return
-        player_state.source.__class__ = LGHorizonNDVRSource
-        source = cast(LGHorizonNDVRSource, player_state.source)
-        service_config = await self._auth.get_service_config()
-        service_url = await service_config.get_service_url("recordingService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        service_path = f"/customers/{self._customer.customer_id}/details/single/{source.recording_id}?profileId={self._profile_id}&language={lang}"
-        recording_json = await self._auth.request(
-            service_url,
-            service_path,
-        )
-        recording = LGHorizonRecordingSingle(recording_json)
-        device_state.title = recording.title
-        device_state.sub_title = recording.full_episode_title
-        device_state.channel_id = recording.channel_id
-        if recording.channel_id:
-            channel = self._channels[recording.channel_id]
-            device_state.channel_name = channel.title
-
-    async def _get_intent_image_url(self, intent_id: str) -> Optional[str]:
-        """Get intent image url."""
-        service_config = await self._auth.get_service_config()
-        intents_url = await service_config.get_service_url("imageService")
-        intents_path = "/intent"
-        body_json = [
-            {
-                "id": intent_id,
-                "intents": ["detailedBackground", "posterTile"],
-            }
-        ]
-        intents_body = urllib.parse.quote(
-            json.dumps(body_json, separators=(",", ":"), indent=None), safe="~"
-        )
-
-        # Construct the full path with the URL-encoded JSON as a query parameter
-        full_intents_path = f"{intents_path}?jsonBody={intents_body}"
-        intents_result = await self._auth.request(intents_url, full_intents_path)
-        if (
-            "intents" in intents_result[0]
-            and len(intents_result[0]["intents"]) > 0
-            and intents_result[0]["intents"][0]["url"]
-        ):
-            return intents_result[0]["intents"][0]["url"]
-        return None