denonavr 1.1.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

denonavr/input.py

@@ -28,6 +28,7 @@ from .const import (
     DENON_ATTR_SETATTR,
     HDTUNER_SOURCES,
     MAIN_ZONE,
+    NETAUDIO_PLAYING,
     NETAUDIO_SOURCES,
     PLAYING_SOURCES,
     POWER_ON,
@@ -36,6 +37,7 @@ from .const import (
     STATE_ON,
     STATE_PAUSED,
     STATE_PLAYING,
+    STATE_STOPPED,
     STATIC_ALBUM_URL,
     TELNET_MAPPING,
     TUNER_SOURCES,
@@ -73,14 +75,16 @@ def set_input_func(
     if value is None:
         return value
     # Map from input_func_map
-    # AirPlay and Internet Radio are not always listed in available sources
-    if value in ["AirPlay", "Internet Radio"]:
-        if value not in instance._input_func_map:
-            instance._additional_input_funcs.add(value)
-            instance._input_func_map[value] = value
-            instance._input_func_map_rev[value] = value
-            instance._netaudio_func_list.append(value)
-            instance._playing_func_list.append(value)
+    # Some inputs are not always listed in available sources
+    if (
+        value in {"AirPlay", "Internet Radio", "Media Server", "NET"}
+        and value not in instance._input_func_map
+    ):
+        instance._additional_input_funcs.add(value)
+        instance._input_func_map[value] = value
+        instance._input_func_map_rev[value] = value
+        instance._netaudio_func_list.append(value)
+        instance._playing_func_list.append(value)
     try:
         input_func = instance._input_func_map_rev[value]
     except KeyError:
@@ -164,7 +168,7 @@ class DenonAVRInput(DenonAVRFoundation):
     _image_url: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
-    _image_available: Optional[str] = attr.ib(
+    _image_available: Optional[bool] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
 
@@ -174,6 +178,8 @@ class DenonAVRInput(DenonAVRFoundation):
         ),
         default=attr.Factory(set),
     )
+    _callback_tasks: Set[asyncio.Task] = attr.ib(default=attr.Factory(set))
+    _netaudio_state: str = attr.ib(converter=fix_string, default="")
 
     # Update tags for attributes
     # AppCommand.xml interface
@@ -197,22 +203,18 @@ class DenonAVRInput(DenonAVRFoundation):
             power_event = "Z2"
         elif self._device.zone == ZONE3:
             power_event = "Z3"
+        self._device.telnet_api.register_callback(power_event, self._power_callback)
+        self._device.telnet_api.register_callback("SI", self._input_callback)
+        self._device.telnet_api.register_callback("NSE", self._netaudio_callback)
+        self._device.telnet_api.register_callback("TF", self._tuner_callback)
+        self._device.telnet_api.register_callback("HD", self._hdtuner_callback)
         self._device.telnet_api.register_callback(
-            power_event, self._async_power_callback
-        )
-        self._device.telnet_api.register_callback("SI", self._async_input_callback)
-        self._device.telnet_api.register_callback("NSE", self._async_netaudio_callback)
-        self._device.telnet_api.register_callback("TF", self._async_tuner_callback)
-        self._device.telnet_api.register_callback("HD", self._async_hdtuner_callback)
-        self._device.telnet_api.register_callback(
-            "SS", self._async_input_func_update_callback
+            "SS", self._input_func_update_callback
         )
 
         self._is_setup = True
 
-    async def _async_input_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _input_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an input change event."""
         if self._device.zone != zone:
             return
@@ -228,9 +230,7 @@ class DenonAVRInput(DenonAVRFoundation):
             self._unset_media_state()
             self._state = STATE_ON
 
-    async def _async_power_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _power_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a power change event."""
         if self._device.zone != zone:
             return
@@ -240,7 +240,7 @@ class DenonAVRInput(DenonAVRFoundation):
             self._unset_media_state()
             self._state = STATE_OFF
         elif self._schedule_media_updates():
-            self._state = STATE_PLAYING
+            self._state = STATE_ON
         else:
             self._unset_media_state()
             self._state = STATE_ON
@@ -285,16 +285,24 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             self._stop_media_update()
 
-    async def _async_netaudio_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _netaudio_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a netaudio update event."""
         if self._device.power != POWER_ON:
             return
         if self._input_func not in self._netaudio_func_list:
             return
 
-        if parameter.startswith("1"):
+        if parameter.startswith("0"):
+            if parameter[1:].startswith(NETAUDIO_PLAYING):
+                # It is not possible to see if the device is playing or paused.
+                # We assume it is playing first.
+                # Then, the state might be changed by async_play and async_pause.
+                if self._state not in {STATE_PLAYING, STATE_PAUSED}:
+                    self._state = STATE_PLAYING
+            else:
+                self._state = STATE_STOPPED
+            self._netaudio_state = parameter[1:]
+        elif parameter.startswith("1"):
             self._title = parameter[1:]
         elif parameter.startswith("2"):
             self._artist = parameter[1:]
@@ -305,12 +313,13 @@ class DenonAVRInput(DenonAVRFoundation):
         self._station = None
 
         # Refresh cover with a hash for media URL when track is changing
-        self._image_url = ALBUM_COVERS_URL.format(
-            host=self._device.api.host,
-            port=self._device.api.port,
-            hash=hash((self._title, self._artist, self._album)),
+        self._set_image_url(
+            ALBUM_COVERS_URL.format(
+                host=self._device.api.host,
+                port=self._device.api.port,
+                hash=hash((self._title, self._artist, self._album)),
+            )
         )
-        await self._async_test_image_accessible()
 
     def _schedule_tuner_update(self) -> None:
         """Schedule a tuner update task."""
@@ -330,9 +339,7 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             self._stop_media_update()
 
-    async def _async_tuner_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _tuner_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a tuner update event."""
         if self._device.power != POWER_ON:
             return
@@ -353,10 +360,11 @@ class DenonAVRInput(DenonAVRFoundation):
         self._album = None
 
         # No special cover, using a static one
-        self._image_url = STATIC_ALBUM_URL.format(
-            host=self._device.api.host, port=self._device.api.port
+        self._set_image_url(
+            STATIC_ALBUM_URL.format(
+                host=self._device.api.host, port=self._device.api.port
+            )
         )
-        await self._async_test_image_accessible()
 
     def _schedule_hdtuner_update(self) -> None:
         """Schedule a HD tuner update task."""
@@ -374,9 +382,7 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             self._stop_media_update()
 
-    async def _async_hdtuner_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _hdtuner_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an HD tuner update event."""
         if self._device.power != POWER_ON:
             return
@@ -396,19 +402,35 @@ class DenonAVRInput(DenonAVRFoundation):
         self._frequency = None
 
         # No special cover, using a static one
-        self._image_url = STATIC_ALBUM_URL.format(
-            host=self._device.api.host, port=self._device.api.port
+        self._set_image_url(
+            STATIC_ALBUM_URL.format(
+                host=self._device.api.host, port=self._device.api.port
+            )
         )
-        await self._async_test_image_accessible()
 
-    async def _async_input_func_update_callback(
+    def _input_func_update_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle input func update events."""
         if self._input_func_update_lock.locked():
             return
-        async with self._input_func_update_lock:
-            await self.async_update_inputfuncs()
+        task = asyncio.create_task(self.async_update_inputfuncs())
+        self._callback_tasks.add(task)
+        task.add_done_callback(self._callback_tasks.discard)
+
+    def _set_image_url(self, image_url: str) -> None:
+        """Set image URL if it is accessible."""
+        if self._image_available is False:
+            return
+
+        self._image_url = image_url
+
+        if self._image_available:
+            return
+
+        task = asyncio.create_task(self._async_test_image_accessible())
+        self._callback_tasks.add(task)
+        task.add_done_callback(self._callback_tasks.discard)
 
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -525,7 +547,7 @@ class DenonAVRInput(DenonAVRFoundation):
 
         self._replace_duplicate_sources(renamed_sources)
 
-        return (renamed_sources, deleted_sources)
+        return renamed_sources, deleted_sources
 
     async def async_get_changed_sources_status_xml(
         self, cache_id: Optional[Hashable] = None
@@ -615,22 +637,23 @@ class DenonAVRInput(DenonAVRFoundation):
 
         self._replace_duplicate_sources(renamed_sources)
 
-        return (renamed_sources, deleted_sources)
+        return renamed_sources, deleted_sources
 
     async def async_update_inputfuncs(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
         """Update sources list from receiver."""
-        if self._device.receiver in [AVR_X, AVR_X_2016]:
-            await self._async_update_inputfuncs_avr_x(
-                global_update=global_update, cache_id=cache_id
-            )
-        elif self._device.receiver in [AVR]:
-            await self._async_update_inputfuncs_avr(cache_id=cache_id)
-        else:
-            raise AvrProcessingError(
-                "Device is not setup correctly, receiver type not set"
-            )
+        async with self._input_func_update_lock:
+            if self._device.receiver in [AVR_X, AVR_X_2016]:
+                await self._async_update_inputfuncs_avr_x(
+                    global_update=global_update, cache_id=cache_id
+                )
+            elif self._device.receiver in [AVR]:
+                await self._async_update_inputfuncs_avr(cache_id=cache_id)
+            else:
+                raise AvrProcessingError(
+                    "Device is not setup correctly, receiver type not set"
+                )
 
     async def _async_update_inputfuncs_avr_x(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -813,6 +836,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 "_title": "./szLine/value[2]",
                 "_artist": "./szLine/value[3]",
                 "_album": "./szLine/value[5]",
+                "_netaudio_state": "./szLine/value[1]",
             }
             self._band = None
             self._frequency = None
@@ -862,8 +886,15 @@ class DenonAVRInput(DenonAVRFoundation):
                 port=self._device.api.port,
                 hash=hash((self._title, self._artist, self._album)),
             )
-            # On track change assume device is PLAYING
-            self._state = STATE_PLAYING
+
+        if self._netaudio_state.startswith(NETAUDIO_PLAYING):
+            # It is not possible to see if the device is playing or paused.
+            # We assume it is playing first.
+            # Then, the state might be changed by async_play and async_pause.
+            if self._state not in {STATE_PLAYING, STATE_PAUSED}:
+                self._state = STATE_PLAYING
+        else:
+            self._state = STATE_STOPPED
 
         await self._async_test_image_accessible()
 
@@ -1070,13 +1101,9 @@ class DenonAVRInput(DenonAVRFoundation):
             await self.async_play()
 
     async def async_play(self) -> None:
-        """Send play command to receiver command via HTTP post."""
+        """Send play command to receiver command."""
         # Use pause command only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
-            # In fact play command is a play/pause toggle. Thus checking state
-            if self._state == STATE_PLAYING:
-                _LOGGER.info("Already playing, play command not sent")
-                return
             if self._device.telnet_available:
                 await self._device.telnet_api.async_send_commands(
                     self._device.telnet_commands.command_play
@@ -1086,12 +1113,12 @@ class DenonAVRInput(DenonAVRFoundation):
             self._state = STATE_PLAYING
 
     async def async_pause(self) -> None:
-        """Send pause command to receiver command via HTTP post."""
+        """Send pause command to receiver command."""
         # Use pause command only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
             if self._device.telnet_available:
                 await self._device.telnet_api.async_send_commands(
-                    self._device.telnet_commands.command_play
+                    self._device.telnet_commands.command_pause
                 )
             else:
                 await self._device.api.async_get_command(
@@ -1099,8 +1126,20 @@ class DenonAVRInput(DenonAVRFoundation):
                 )
             self._state = STATE_PAUSED
 
+    async def async_stop(self) -> None:
+        """Send stop command to receiver command."""
+        # Use stop command only for sources which support NETAUDIO
+        if self._input_func in self._netaudio_func_list:
+            if self._device.telnet_available:
+                await self._device.telnet_api.async_send_commands(
+                    self._device.telnet_commands.command_stop
+                )
+            else:
+                await self._device.api.async_get_command(self._device.urls.command_stop)
+            self._state = STATE_STOPPED
+
     async def async_previous_track(self) -> None:
-        """Send previous track command to receiver command via HTTP post."""
+        """Send previous track command to receiver command."""
         # Use previous track button only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
             body = {
@@ -1113,7 +1152,7 @@ class DenonAVRInput(DenonAVRFoundation):
             )
 
     async def async_next_track(self) -> None:
-        """Send next track command to receiver command via HTTP post."""
+        """Send next track command to receiver command."""
         # Use next track button only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
             body = {