diff --git a/README.md b/README.md index 73957f2..0da52a0 100644 --- a/README.md +++ b/README.md @@ -69,6 +69,7 @@ - [Изменение языка Алисы](#изменение-языка-алисы) - [Несколько TTS в конфиге](#несколько-tts-в-конфиге) - [Звук Яндекс.Станции по HDMI](#звук-яндексстанции-по-hdmi) +- [Тип контента ТВ и Кинопоиска](#тип-контента-тв-и-кинопоиска) - [Управление яркостью экрана станции Макс](#управление-яркостью-станции-макс) - [Поиск и устранение проблем](#troubleshooting) - [Полезные автоматизации](#полезные-автоматизации) @@ -973,6 +974,22 @@ script: source: HDMI ``` +## Тип контента ТВ и Кинопоиска + +При локальном подключении атрибут `media_content_type` показывает, что воспроизводится: + +- `music` и `radio` — музыка и радио; +- `channel` — эфирный телеканал; +- `movie` — фильм; +- `tvshow` — серия, с названием сериала в `media_series_title`; +- `video` — другое видео; если формат не распознан, тип остаётся неизвестным. + +На YaOS фоновая музыка не перебивает карточку открытого видео, в том числе на паузе. Громкость и состояние Алисы обновляются как обычно, а запуск музыки сразу переключает карточку на трек. Play в HA продолжает Кинопоиск после паузы через сценарий `player_continue`, без голосовых реплик Алисы. Для музыки сохраняется обычная команда `play`. + +Проверено на Станции Макс с YaOS 3.364.14 через сервисы HA; другие модели и прошивки отдельно не проверялись. Пауза прямого эфира этим исправлением не добавляется. + +**Для старых прошивок:** неразмеченный `ru.yandex.quasar.app` теперь получает `video` вместо `tvshow`. Если карточки или автоматизации проверяли именно `tvshow`, их условия может понадобиться изменить. + ## Управление яркостью экрана станции Макс **Только для Яндекс.Станции Макс** diff --git a/custom_components/yandex_station/core/yandex_station.py b/custom_components/yandex_station/core/yandex_station.py index 716221e..9877d0a 100644 --- a/custom_components/yandex_station/core/yandex_station.py +++ b/custom_components/yandex_station/core/yandex_station.py @@ -527,6 +527,7 @@ def update_device_info(self, sw_version: str): @callback def async_set_state(self, data: dict): + self._local_media_accepted = False if data is None: if self._attr_assumed_state: return @@ -556,16 +557,48 @@ def async_set_state(self, data: dict): state = data["state"] state.pop("timeSinceLastVoiceActivity", None) - - # skip same state + previous = self.local_state or {} + current_player = previous.get("playerState") or {} + incoming_player = state.get("playerState") or {} + current_type = current_player.get("playerType") + screen_closed = ( + state.get("playing") is False + and incoming_player.get("showPlayer") is False + and all(incoming_player.get(key) == "" for key in ("playerType", "type", "id", "title")) + ) + retain_media = ( + current_type in ("com.yandex.tv.videoplayer", "com.yandex.tv.live") + and incoming_player.get("playerType") == "music_thin" + and state.get("playing") is False + and incoming_player.get("showPlayer") is True + ) or ( + screen_closed + and current_type == "music_thin" + and current_player.get("showPlayer") is True + ) + if retain_media: + # Keep selected media, but accept the speaker's volume/Alice state. + selected = ( + {**current_player, "showPlayer": False} + if screen_closed else current_player + ) + state = {**state, "playerState": selected, "playing": previous["playing"]} + elif screen_closed: + # A populated but cleared playerState is idle, not an unknown pause. + state = {**state, "playerState": {}} + + self._local_media_accepted = not retain_media + media_changed = not retain_media and ( + self.local_state is None + or previous.get("playerState") != state.get("playerState") + or previous.get("playing") != state.get("playing") + ) + if sw_version := data.get("softwareVersion"): + self.update_device_info(sw_version) if self.local_state == state: return - self.local_state = state - if sw_version := data.get("softwareVersion"): - self.update_device_info(sw_version) - # возвращаем из состояния mute, если нужно # if self.prev_volume and state['volume']: # self.prev_volume = None @@ -577,8 +610,22 @@ def async_set_state(self, data: dict): self._attr_assumed_state = False self._attr_available = True self._attr_should_poll = False - self._attr_supported_features = LOCAL_FEATURES + if media_changed: + self._update_local_player(state) + + if isinstance(state["volume"], float): + if state["volume"] > 0: + self._attr_is_volume_muted = False + self._attr_volume_level = state["volume"] + else: + self._attr_is_volume_muted = True + + if self.hass: + self.async_write_ha_state() + @callback + def _update_local_player(self, state: dict): + self._attr_supported_features = LOCAL_FEATURES # optional attributes for local mode self._attr_media_artist = None self._attr_media_channel = None @@ -597,19 +644,31 @@ def async_set_state(self, data: dict): if player_state["duration"]: self._attr_supported_features |= MediaPlayerEntityFeature.SEEK - # https://github.com/home-assistant/frontend/blob/dev/src/data/media-player.ts - # supported computeMediaDescription: music/image/playlist/tvshow/channel - if player_state["type"] == "Track": - self._attr_media_artist = player_state["subtitle"] or None + # Audio first, then live TV, explicit VOD types and generic video. + content_type = player_state.get("type") + player_type = player_state.get("playerType") + subtitle = player_state.get("subtitle") or None + if content_type == "Track": + self._attr_media_artist = subtitle self._attr_media_content_type = MediaType.MUSIC - elif player_state["type"] == "FmRadio": + elif content_type == "FmRadio": self._attr_media_content_type = "radio" - elif player_state["liveStreamText"] == "Прямой эфир": - self._attr_media_channel = player_state["subtitle"] or None + elif ( + player_type in ("com.yandex.tv.live", "live") + or player_state.get("liveStreamText") == "Прямой эфир" + ): + self._attr_media_channel = subtitle self._attr_media_content_type = MediaType.CHANNEL - elif player_state["playerType"] == "ru.yandex.quasar.app": + elif content_type == "movie": + self._attr_media_content_type = MediaType.MOVIE + elif content_type == "tv_show_episode": self._attr_media_content_type = MediaType.TVSHOW - self._attr_media_series_title = player_state["subtitle"] or None + self._attr_media_series_title = subtitle + elif ( + content_type == "video" + or player_type in ("com.yandex.tv.videoplayer", "ru.yandex.quasar.app") + ): + self._attr_media_content_type = MediaType.VIDEO if player_state["playlistType"] == "Track": self._attr_media_playlist = MediaType.TRACK @@ -659,16 +718,6 @@ def async_set_state(self, data: dict): self._attr_media_title = None self._attr_state = MediaPlayerState.IDLE - if isinstance(state["volume"], float): - if state["volume"] > 0: - self._attr_is_volume_muted = False - self._attr_volume_level = state["volume"] - else: - self._attr_is_volume_muted = True - - if self.hass: - self.async_write_ha_state() - # BASE MEDIA PLAYER FUNCTIONS @property @@ -780,6 +829,14 @@ async def async_media_play(self): ) return + player_type = (self.local_state.get("playerState") or {}).get("playerType") + if player_type in ("com.yandex.tv.videoplayer", "com.yandex.tv.live"): + # YaOS video uses the continue scenario; play targets the audio player. + await self.glagol.send( + utils.update_form("personal_assistant.scenarios.player_continue") + ) + return + await self.glagol.send({"command": "play"}) else: @@ -1105,28 +1162,29 @@ async def async_media_seek(self, position): def async_set_state(self, data: dict): super().async_set_state(data) - if not self.sync_enabled or data is None or "playerState" not in data["state"]: + if not self.sync_enabled or data is None: return - state = data["state"] - player_state = state["playerState"] - - if self.sync_playing != data["state"]["playing"]: - self.sync_playing = data["state"]["playing"] - if self.sync_playing: - if self.sync_id == player_state["id"]: - # продолжаем играть, если ID не изменился - self.sync_service_call("media_play") - else: - # останавливаем, если ничего не играет - self.sync_service_call("media_pause") - - # Состояние проверяем для исправления бага Станция Макс 2020 - # https://github.com/AlexxIT/YandexStation/issues/819 - # https://github.com/AlexxIT/YandexStation/issues/835 - if self.sync_id != player_state["id"] and data["state"]["playing"]: - self.sync_id = player_state["id"] - self.hass.create_task(self.sync_play_media(data)) + state = self.local_state + player_state = state.get("playerState") or {} + # Common speaker fields still apply when this frame's media was rejected. + if self._local_media_accepted and "playing" in state: + if self.sync_playing != state["playing"]: + self.sync_playing = state["playing"] + if self.sync_playing: + if player_state and self.sync_id == player_state["id"]: + # продолжаем играть, если ID не изменился + self.sync_service_call("media_play") + else: + # останавливаем, если ничего не играет + self.sync_service_call("media_pause") + + # Состояние проверяем для исправления бага Станция Макс 2020 + # https://github.com/AlexxIT/YandexStation/issues/819 + # https://github.com/AlexxIT/YandexStation/issues/835 + if player_state and self.sync_id != player_state["id"] and state["playing"]: + self.sync_id = player_state["id"] + self.hass.create_task(self.sync_play_media(data)) if state["volume"] and self.sync_volume != state["volume"]: self.sync_volume = state["volume"] diff --git a/tests/test_local.py b/tests/test_local.py index 61238d8..b881e0c 100644 --- a/tests/test_local.py +++ b/tests/test_local.py @@ -1,3 +1,8 @@ +import asyncio +from unittest.mock import AsyncMock + +import pytest + from homeassistant.components.media_player import ( MediaPlayerEntityFeature, MediaPlayerState, @@ -8,6 +13,367 @@ from . import FakeYandexStation +def _player_frame(*, playing=True, omit=(), **changes): + player = { + "duration": 1920.0, + "entityInfo": {"description": "", "id": "", "type": ""}, + "extra": {}, + "hasNext": False, + "hasPause": True, + "hasPlay": False, + "hasPrev": False, + "hasProgressBar": True, + "id": "", + "liveStreamText": "", + "playerType": "com.yandex.tv.live", + "playlistDescription": "", + "playlistId": "", + "playlistPuid": "", + "playlistType": "", + "progress": 27.0, + "showPlayer": True, + "subtitle": "360 Новости — Новости 360", + "title": "Новости 360", + "type": "", + } + player.update(changes) + for key in omit: + player.pop(key) + return { + "state": { + "aliceState": "IDLE", + "canStop": True, + "hdmi": {"capable": True, "present": False}, + "playerState": player, + "playing": playing, + "volume": 0.2, + } + } + + +@pytest.mark.parametrize( + "changes,channel", + [ + ({}, "360 Новости — Новости 360"), + ({"subtitle": ""}, None), + ({"subtitle": None, "liveStreamText": None}, None), + ({"omit": ("liveStreamText",)}, "360 Новости — Новости 360"), + ({"playerType": "live"}, "360 Новости — Новости 360"), # Synthetic alias. + ], +) +def test_yaos_live_tv(changes, channel): + # Reconstructed envelope using measured modern Live TV markers, not raw capture. + entity = FakeYandexStation() + entity.async_set_state(_player_frame(**changes)) + + assert entity.media_content_type == MediaType.CHANNEL + assert entity.media_channel == channel + assert entity.media_artist is None + assert entity.media_series_title is None + assert entity.media_content_id == "" + assert entity.media_title == "Новости 360" + assert entity.media_duration == 1920.0 + assert entity.media_position == 27.0 + assert entity.state == MediaPlayerState.PLAYING + + +@pytest.mark.parametrize( + "kind,subtitle,duration,title,expected,series", + [ + ("tv_show_episode", "Смешарики", 390.0, "1. Скамейка", + MediaType.TVSHOW, "Смешарики"), + ("movie", "", 6756.0, "Чебурашка", MediaType.MOVIE, None), + ], +) +def test_yaos_kinopoisk_vod(kind, subtitle, duration, title, expected, series): + # Reconstructed from J-0193 measured fields; other envelope values are synthetic. + entity = FakeYandexStation() + entity.async_set_state(_player_frame( + type=kind, playerType="com.yandex.tv.videoplayer", subtitle=subtitle, + duration=duration, title=title, id="synthetic-vod", + )) + + assert entity.media_content_type == expected + assert entity.media_series_title == series + assert entity.media_artist is None + assert entity.media_channel is None + assert entity.media_title == title + assert entity.media_content_id == "synthetic-vod" + assert entity.media_duration == duration + assert entity.media_position == 27.0 + + +@pytest.mark.parametrize("backend,continue_video", [ + ("com.yandex.tv.videoplayer", True), ("com.yandex.tv.live", True), + ("music_thin", False), ("ru.yandex.quasar.app", False), + ("unknown", False), (None, False), +]) +def test_media_play_resumes_selected_player(backend, continue_video): + async def scenario(): + entity = FakeYandexStation() + entity.glagol = AsyncMock() + entity.async_set_state(_player_frame( + playing=False, playerType=backend, type="tv_show_episode", + omit=("playerType",) if backend is None else (), + )) + if continue_video: + entity.async_set_state(_player_frame( + playing=False, playerType="music_thin", type="Track", + )) + await entity.async_media_play() + if continue_video: + entity.glagol.send.assert_awaited_once_with({ + "command": "serverAction", + "serverActionEventPayload": { + "type": "server_action", "name": "update_form", + "payload": { + "form_update": { + "name": "personal_assistant.scenarios.player_continue", + "slots": [], + }, + "resubmit": True, + }, + }, + }) + entity.async_set_state(_player_frame(playerType="music_thin", type="Track")) + entity.async_set_state(_player_frame( + playing=False, playerType="music_thin", type="Track", + )) + await entity.async_media_play() + entity.glagol.send.assert_awaited_with({"command": "play"}) + else: + entity.glagol.send.assert_awaited_once_with({"command": "play"}) + assert entity.state == MediaPlayerState.PAUSED + + asyncio.run(scenario()) + + +@pytest.mark.parametrize("backend", ["com.yandex.tv.videoplayer", "com.yandex.tv.live"]) +@pytest.mark.parametrize("playing", [True, False]) +def test_glagol_background_music_keeps_video_and_updates_device(backend, playing): + entity = FakeYandexStation() + video = _player_frame( + playerType=backend, type="tv_show_episode", id="synthetic-video", + title="1. Скамейка", subtitle="Смешарики", + extra={"coverURI": "https://example.invalid/cover.jpg"}, + playlistType="Playlist", hasNext=True, + entityInfo={"repeatMode": "All", "shuffled": True}, + ) + video["state"]["playing"] = playing + entity.async_set_state(video) + assert entity.state == (MediaPlayerState.PLAYING if playing else MediaPlayerState.PAUSED) + fields = ( + "state", "media_title", "media_content_type", "media_content_id", + "media_artist", "media_channel", "media_series_title", "media_duration", + "media_position", "media_position_updated_at", "media_image_url", + "media_playlist", "repeat", "shuffle", "supported_features", + ) + selected = tuple(getattr(entity, key) for key in fields) + for volume in (0.8, 0.0): + background = _player_frame( + playerType="music_thin", type="Track", title="Другой трек", + showPlayer=True, progress=0.0, + ) + background["state"].update(playing=False, volume=volume, aliceState="LISTENING") + entity.async_set_state(background) + assert tuple(getattr(entity, key) for key in fields) == selected + assert entity.volume_level == 0.8 + assert entity.is_volume_muted is (volume == 0.0) + assert entity.extra_state_attributes["alice_state"] == "LISTENING" + + +@pytest.mark.parametrize("playing", [True, False]) +def test_glagol_video_cleanup_respects_selected_music(playing): + entity = FakeYandexStation() + video = dict(playerType="com.yandex.tv.videoplayer", type="tv_show_episode") + clear = dict( + playing=False, playerType="", type="", id="", title="", subtitle="", + showPlayer=False, duration=0.0, progress=0.0, + ) + entity.async_set_state(_player_frame(playing=False, **video)) + entity.async_set_state(_player_frame(**clear)) + assert entity.state == MediaPlayerState.IDLE + assert entity.media_title is None + assert entity.media_content_type is None + + entity.async_set_state(_player_frame(**video)) + music = dict(playerType="music_thin", type="Track", title="Музыка", showPlayer=True) + entity.async_set_state(_player_frame(**music)) + entity.async_set_state(_player_frame(playing=playing, **music)) + position_time = entity.media_position_updated_at + entity.async_set_state(_player_frame(**clear)) + assert entity.state == (MediaPlayerState.PLAYING if playing else MediaPlayerState.PAUSED) + assert entity.media_content_type == MediaType.MUSIC + assert entity.media_title == "Музыка" + assert entity.media_position_updated_at == position_time + # Once the screen has closed, cleanup is no longer a delayed video teardown. + entity.async_set_state(_player_frame(**clear)) + assert entity.state == MediaPlayerState.IDLE + assert entity.media_title is None + assert entity.media_position is None + + +@pytest.mark.parametrize( + "backend,show", + [ + ("com.yandex.tv.videoplayer", False), + ("com.yandex.tv.videoplayer", None), + ("com.yandex.tv.videoplayer", "absent"), + ("ru.yandex.quasar.app", True), + ("unknown", True), + ], +) +def test_glagol_unconfirmed_background_is_not_blocked(backend, show): + entity = FakeYandexStation() + entity.async_set_state(_player_frame(playerType=backend, type="movie")) + entity.async_set_state(_player_frame( + playing=False, playerType="music_thin", type="Track", showPlayer=show, + omit=("showPlayer",) if show == "absent" else (), + )) + assert entity.state == MediaPlayerState.PAUSED + assert entity.media_content_type == MediaType.MUSIC + + +@pytest.mark.parametrize( + "current,incoming", + [(None, "music_thin"), ("", "music_thin"), + ("com.yandex.tv.videoplayer", None), ("com.yandex.tv.videoplayer", "")], +) +def test_glagol_pause_without_player_identity(current, incoming): + entity = FakeYandexStation() + entity.async_set_state(_player_frame(playerType=current, type="movie")) + paused = _player_frame(playerType=incoming, type="Track", title="Другой трек") + paused["state"]["playing"] = False + entity.async_set_state(paused) + assert entity.state == MediaPlayerState.PAUSED + assert entity.media_title == "Другой трек" + + +@pytest.mark.parametrize( + "changes,live_text,expected", + [ + ({"type": "Track"}, "Прямой эфир", MediaType.MUSIC), + ({"type": "FmRadio"}, "Прямой эфир", "radio"), + ({"type": "movie"}, "", MediaType.CHANNEL), + ({"type": "video", "playerType": "live"}, "", MediaType.CHANNEL), + ({"type": "movie", "playerType": "unknown"}, "Прямой эфир", MediaType.CHANNEL), + ({"type": "video", "playerType": "unknown"}, "Прямой эфир", MediaType.CHANNEL), + ({"type": "tv_show_episode", "playerType": "unknown"}, + "Прямой эфир", MediaType.CHANNEL), + ({"playerType": "com.yandex.tv.videoplayer"}, "", MediaType.VIDEO), + ({"playerType": "com.yandex.tv.videoplayer", "subtitle": ""}, "", MediaType.VIDEO), + ({"playerType": "ru.yandex.quasar.app"}, "", MediaType.VIDEO), + ({"playerType": "ru.yandex.quasar.app", "subtitle": ""}, "", MediaType.VIDEO), + ({"type": "unrecognized", "playerType": "unknown"}, "", None), + ], +) +def test_video_classification_priority(changes, live_text, expected): + # Synthetic conflicts: audio beats live; either live marker beats VOD. + frame = _player_frame(**{ + "subtitle": "Подпись", "liveStreamText": live_text, **changes, + }) + entity = FakeYandexStation() + entity.async_set_state(frame) + + assert entity.media_content_type == expected + assert entity.media_artist == ("Подпись" if expected == MediaType.MUSIC else None) + assert entity.media_channel == ("Подпись" if expected == MediaType.CHANNEL else None) + assert entity.media_series_title == ( + "Подпись" if expected == MediaType.TVSHOW else None + ) + + +@pytest.mark.parametrize("mode", ["absent", "null", "empty"]) +@pytest.mark.parametrize( + "signal,expected", + [ + ({"type": "Track"}, MediaType.MUSIC), + ({"type": "FmRadio"}, "radio"), + ({"type": "movie"}, MediaType.MOVIE), + ({"type": "tv_show_episode"}, MediaType.TVSHOW), + ({"type": "video"}, MediaType.VIDEO), + ({"playerType": "com.yandex.tv.live"}, MediaType.CHANNEL), + ({"liveStreamText": "Прямой эфир"}, MediaType.CHANNEL), + ({"playerType": "com.yandex.tv.videoplayer"}, MediaType.VIDEO), + ({}, None), + ], +) +def test_classification_optional_fields(mode, signal, expected): + # Missing/null/empty optional markers do not mask the remaining positive signal. + optional = ("type", "playerType", "liveStreamText", "subtitle") + changes = dict.fromkeys(optional, None if mode == "null" else "") + changes.update(signal) + omitted = tuple(key for key in optional if key not in signal) + entity = FakeYandexStation() + entity.async_set_state(_player_frame( + omit=omitted if mode == "absent" else (), **changes, + )) + + assert entity.media_content_type == expected + assert entity.media_artist is None + assert entity.media_channel is None + assert entity.media_series_title is None + assert entity.media_title == "Новости 360" + + +def test_content_type_transitions_reset_metadata(monkeypatch): + entity = FakeYandexStation() + # Cloud fallback publishes unconditionally; this seam has no HA instance. + monkeypatch.setattr(entity, "async_write_ha_state", lambda: None) + for changes, expected, metadata in [ + ({"playerType": "com.yandex.tv.live"}, MediaType.CHANNEL, + (None, "Подпись", None)), + ({"type": "Track"}, MediaType.MUSIC, ("Подпись", None, None)), + ({"type": "FmRadio"}, "radio", (None, None, None)), + ({"type": "tv_show_episode"}, MediaType.TVSHOW, (None, None, "Подпись")), + ({"type": "movie"}, MediaType.MOVIE, (None, None, None)), + ({"type": "video"}, MediaType.VIDEO, (None, None, None)), + ({"type": "unknown"}, None, (None, None, None)), + ]: + # Every update owns a fresh envelope; never mutate retained local_state. + entity.async_set_state(_player_frame(**{ + "playerType": "unknown", "subtitle": "Подпись", + "id": "synthetic-content", "playlistType": "Playlist", + "extra": {"coverURI": "https://example.invalid/cover.jpg"}, + "entityInfo": {"type": "Playlist", "repeatMode": "All", "shuffled": True}, + **changes, + })) + assert entity.media_content_type == expected + assert (entity.media_artist, entity.media_channel, + entity.media_series_title) == metadata + assert entity.media_playlist == MediaType.PLAYLIST + assert entity.repeat == RepeatMode.ALL + assert entity.shuffle is True + assert entity.media_image_url == "https://example.invalid/cover.jpg" + + entity.async_set_state(_player_frame( + type="movie", playerType="com.yandex.tv.videoplayer", + )) + idle = _player_frame() + del idle["state"]["playerState"] + idle["state"]["playing"] = False + entity.async_set_state(idle) + assert entity.state == MediaPlayerState.IDLE + assert entity.assumed_state is False + for cloud in (False, True): + if cloud: + entity.async_set_state(None) + assert entity.assumed_state is cloud + assert entity.media_content_type is None + assert entity.media_artist is None + assert entity.media_channel is None + assert entity.media_series_title is None + assert entity.media_title is None + assert entity.media_content_id is None + assert entity.media_duration is None + assert entity.media_position is None + assert entity.media_position_updated_at is None + assert entity.media_image_url is None + assert entity.media_playlist is None + assert entity.repeat is None + assert entity.shuffle is None + + def test_idle(): state = { "aliceState": "IDLE", @@ -445,8 +811,8 @@ def test_video(): assert entity.media_artist is None assert entity.media_content_id == "4e0a11ba3b549da0b7291235f8a50c2e" - assert entity.media_content_type == MediaType.TVSHOW - assert entity.media_series_title == "Фиксики, 1 сезон, 1 серия" + assert entity.media_content_type == MediaType.VIDEO + assert entity.media_series_title is None assert entity.shuffle is None @@ -486,6 +852,6 @@ def test_movie(): assert entity.media_artist is None assert entity.media_content_id == "402f8e529e4e7a31b3b43f4383cbc10d" - assert entity.media_content_type == MediaType.TVSHOW - assert entity.media_series_title == "военный, боевик, история, биография, 18+, 2019" + assert entity.media_content_type == MediaType.VIDEO + assert entity.media_series_title is None assert entity.shuffle is None