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

denonavr/foundation.py

@@ -22,12 +22,13 @@ from .const import (
     APPCOMMAND_CMD_TEXT,
     APPCOMMAND_NAME,
     AUDIO_RESTORER_MAP,
-    AUDIO_RESTORER_MAP_LABELS,
+    AUDIO_RESTORER_MAP_REVERSE,
+    AUTO_STANDBY_MAP,
     AVR,
     AVR_X,
     AVR_X_2016,
-    BLUETOOTH_OUTPUT_MAP_LABELS,
     BLUETOOTH_OUTPUT_MODES_MAP,
+    BLUETOOTH_OUTPUT_MODES_MAP_REVERSE,
     CHANNEL_VOLUME_MAP,
     DENON_ATTR_SETATTR,
     DENONAVR_TELNET_COMMANDS,
@@ -36,18 +37,22 @@ from .const import (
     DEVICEINFO_AVR_X_PATTERN,
     DEVICEINFO_COMMAPI_PATTERN,
     DIMMER_MODE_MAP,
-    DIMMER_MODE_MAP_LABELS,
+    DIMMER_MODE_MAP_REVERSE,
+    DIMMER_MODE_MAP_TELNET,
     ECO_MODE_MAP,
-    ECO_MODE_MAP_LABELS,
+    ECO_MODE_MAP_REVERSE,
+    ECO_MODE_MAP_TELNET,
     HDMI_OUTPUT_MAP,
-    HDMI_OUTPUT_MAP_LABELS,
+    HDMI_OUTPUT_MAP_REVERSE,
+    ILLUMINATION_MAP,
+    ILLUMINATION_MAP_REVERSE,
     MAIN_ZONE,
     POWER_STATES,
     SETTINGS_MENU_STATES,
     VALID_RECEIVER_TYPES,
     VALID_ZONES,
     VIDEO_PROCESSING_MODES_MAP,
-    VIDEO_PROCESSING_MODES_MAP_LABELS,
+    VIDEO_PROCESSING_MODES_MAP_REVERSE,
     ZONE2,
     ZONE2_TELNET_COMMANDS,
     ZONE2_URLS,
@@ -61,6 +66,8 @@ from .const import (
     EcoModes,
     HDMIAudioDecodes,
     HDMIOutputs,
+    Illuminations,
+    InputModes,
     PanelLocks,
     ReceiverType,
     ReceiverURLs,
@@ -71,10 +78,7 @@ from .const import (
 )
 from .exceptions import (
     AvrCommandError,
-    AvrForbiddenError,
-    AvrIncompleteResponseError,
     AvrNetworkError,
-    AvrProcessingError,
     AvrRequestError,
     AvrTimoutError,
 )
@@ -130,6 +134,7 @@ class DenonAVRDeviceInfo:
     zone: str = attr.ib(
         validator=attr.validators.in_(VALID_ZONES), default=MAIN_ZONE, kw_only=True
     )
+    zones: int = attr.ib(converter=attr.converters.optional(int), default=0)
     friendly_name: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
@@ -152,11 +157,11 @@ class DenonAVRDeviceInfo:
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
     _dimmer: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(DIMMER_MODE_MAP.get), default=None
     )
     _dimmer_modes = get_args(DimmerModes)
     _auto_standby: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(AUTO_STANDBY_MAP.get), default=None
     )
     _auto_standbys = get_args(AutoStandbys)
     _sleep: Optional[Union[str, int]] = attr.ib(
@@ -166,11 +171,11 @@ class DenonAVRDeviceInfo:
         converter=attr.converters.optional(int), default=None
     )
     _eco_mode: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(ECO_MODE_MAP.get), default=None
     )
     _eco_modes = get_args(EcoModes)
     _hdmi_output: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(HDMI_OUTPUT_MAP.get), default=None
     )
     _hdmi_outputs = get_args(HDMIOutputs)
     _hdmi_audio_decode: Optional[str] = attr.ib(
@@ -178,7 +183,7 @@ class DenonAVRDeviceInfo:
     )
     _hdmi_audio_decodes = get_args(HDMIAudioDecodes)
     _video_processing_mode: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(VIDEO_PROCESSING_MODES_MAP.get), default=None
     )
     _video_processing_modes = get_args(VideoProcessingModes)
     _tactile_transducer: Optional[str] = attr.ib(
@@ -197,20 +202,20 @@ class DenonAVRDeviceInfo:
     _room_sizes = get_args(RoomSizes)
     _triggers: Optional[Dict[int, str]] = attr.ib(default=None)
     _speaker_preset: Optional[int] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(int), default=None
     )
     _bt_transmitter: Optional[bool] = attr.ib(
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
     _bt_output_mode: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(BLUETOOTH_OUTPUT_MODES_MAP.get), default=None
     )
     _bt_output_modes = get_args(BluetoothOutputModes)
     _delay_time: Optional[int] = attr.ib(
         converter=attr.converters.optional(int), default=None
     )
     _audio_restorer: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(AUDIO_RESTORER_MAP.get), default=None
     )
     _audio_restorers = get_args(AudioRestorers)
     _panel_locks = get_args(PanelLocks)
@@ -220,8 +225,15 @@ class DenonAVRDeviceInfo:
     _headphone_eq: Optional[bool] = attr.ib(
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
+    _illumination: Optional[str] = attr.ib(
+        converter=attr.converters.optional(ILLUMINATION_MAP.get), default=None
+    )
+    _illuminations = get_args(Illuminations)
+    _auto_lip_sync: Optional[bool] = attr.ib(
+        converter=attr.converters.optional(convert_on_off_bool), default=None
+    )
+    _input_modes = get_args(InputModes)
     _is_setup: bool = attr.ib(converter=bool, default=False, init=False)
-    _allow_recovery: bool = attr.ib(converter=bool, default=True, init=True)
     _setup_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
 
     def __attrs_post_init__(self) -> None:
@@ -239,66 +251,38 @@ class DenonAVRDeviceInfo:
         else:
             raise ValueError(f"Invalid zone {self.zone}")
 
-    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.zone == zone and parameter in POWER_STATES:
             self._power = parameter
 
-    async def _async_settings_menu_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _settings_menu_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a settings menu event."""
-        if (
-            event == "MN"
-            and parameter[0:3] == "MEN"
-            and parameter[4:] in SETTINGS_MENU_STATES
-        ):
+        if parameter[0:3] == "MEN" and parameter[4:] in SETTINGS_MENU_STATES:
             self._settings_menu = parameter[4:]
 
-    async def _async_dimmer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _dimmer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a dimmer change event."""
-        if event == "DIM" and parameter[1:] in DIMMER_MODE_MAP_LABELS:
-            self._dimmer = DIMMER_MODE_MAP_LABELS[parameter[1:]]
+        if parameter[1:] in DIMMER_MODE_MAP_TELNET:
+            self._dimmer = parameter[1:]
 
-    async def _async_auto_standby_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _auto_standby_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a auto standby change event."""
-        if zone == "Main" and event == "STBY":
+        if zone == self.zone:
             self._auto_standby = parameter
 
-    async def _async_auto_sleep_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _auto_sleep_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a sleep change event."""
-        if event != "SLP":
-            return
-
-        if parameter == "OFF":
+        if zone == self.zone:
             self._sleep = parameter
-        else:
-            self._sleep = int(parameter)
 
-    async def _async_room_size_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _room_size_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a room size change event."""
-        if parameter[:3] != "RSZ":
-            return
-
-        self._room_size = parameter[4:]
+        if zone == self.zone and parameter[:3] == "RSZ":
+            self._room_size = parameter[4:]
 
-    async def _async_trigger_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _trigger_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a trigger change event."""
-        if event != "TR":
-            return
-
         values = parameter.split()
         if len(values) != 2:
             return
@@ -308,44 +292,36 @@ class DenonAVRDeviceInfo:
 
         self._triggers[int(values[0])] = values[1]
 
-    async def _async_delay_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _delay_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a delay change event."""
-        if event == "PS" and parameter[0:5] == "DELAY":
-            self._delay = int(parameter[6:])
+        if zone == self.zone and parameter[0:5] == "DELAY":
+            self._delay = parameter[6:]
 
-    async def _async_eco_mode_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _eco_mode_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an Eco-mode change event."""
-        if event == "ECO" and parameter in ECO_MODE_MAP_LABELS:
-            self._eco_mode = ECO_MODE_MAP_LABELS[parameter]
+        if zone == self.zone and parameter in ECO_MODE_MAP_TELNET:
+            self._eco_mode = parameter
 
-    async def _async_hdmi_output_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _hdmi_output_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a HDMI output change event."""
-        if event == "VS" and parameter[0:4] == "MONI":
-            self._hdmi_output = HDMI_OUTPUT_MAP_LABELS[parameter]
+        if zone == self.zone and parameter[0:4] == "MONI":
+            self._hdmi_output = parameter
 
-    async def _async_hdmi_audio_decode_callback(
+    def _hdmi_audio_decode_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a HDMI Audio Decode mode change event."""
-        if event == "VS" and parameter[0:5] == "AUDIO":
+        if zone == self.zone and parameter[0:5] == "AUDIO":
             self._hdmi_audio_decode = parameter[6:]
 
-    async def _async_video_processing_mode_callback(
+    def _video_processing_mode_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a Video Processing Mode change event."""
-        if event == "VS" and parameter[0:3] == "VPM":
-            self._video_processing_mode = VIDEO_PROCESSING_MODES_MAP_LABELS[
-                parameter[3:]
-            ]
+        if zone == self.zone and parameter[0:3] == "VPM":
+            self._video_processing_mode = parameter[3:]
 
-    async def _async_tactile_transducer_callback(
+    def _tactile_transducer_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a tactile transducer change event."""
@@ -363,75 +339,70 @@ class DenonAVRDeviceInfo:
         elif key == "TTRLEV":
             self._tactile_transducer_level = CHANNEL_VOLUME_MAP[value]
         elif key == "TTRLPF":
-            self._tactile_transducer_lpf = f"{int(value)} Hz"
+            self._tactile_transducer_lpf = f"{value} Hz"
 
-    async def _async_speaker_preset_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _speaker_preset_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a speaker preset change event."""
-        if event != "SP":
-            return
-
         if parameter[0:2] == "PR":
-            self._speaker_preset = int(parameter[3:])
+            self._speaker_preset = parameter[3:]
 
-    async def _async_bt_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _bt_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Bluetooth change event."""
-        if event != "BT" or parameter[0:2] != "TX":
+        if parameter[0:2] != "TX":
             return
 
         if parameter[3:] in ("ON", "OFF"):
             self._bt_transmitter = parameter[3:]
         else:
-            self._bt_output_mode = BLUETOOTH_OUTPUT_MAP_LABELS[parameter[3:]]
+            self._bt_output_mode = parameter[3:]
 
-    async def _async_delay_time_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _delay_time_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a delay time change event."""
         # do not match "DELAY" as it's another event
-        if event != "PS" or parameter[0:3] != "DEL" or parameter[0:5] == "DELAY":
+        if parameter[0:3] != "DEL" or parameter[0:5] == "DELAY":
             return
 
         self._delay_time = int(parameter[4:])
 
-    async def _async_audio_restorer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _audio_restorer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an audio restorer change event."""
-        if event != "PS" or parameter[0:4] != "RSTR":
+        if parameter[0:4] != "RSTR":
             return
 
-        self._audio_restorer = AUDIO_RESTORER_MAP_LABELS[parameter[5:]]
+        self._audio_restorer = parameter[5:]
 
-    async def _async_graphic_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _graphic_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Graphic EQ change event."""
         if parameter[0:3] != "GEQ":
             return
 
         self._graphic_eq = parameter[4:]
 
-    async def _async_headphone_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _headphone_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Headphone EQ change event."""
         if parameter[0:3] != "HEQ":
             return
 
         self._headphone_eq = parameter[4:]
 
-    def get_own_zone(self) -> str:
-        """
-        Get zone from actual instance.
+    def _illumination_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle an illumination change event."""
+        if parameter[0:3] == "ILL":
+            self._illumination = parameter[4:]
 
-        These zone information are used to evaluate responses of HTTP POST
-        commands.
-        """
-        if self.zone == MAIN_ZONE:
-            return "zone1"
-        return self.zone.lower()
+    def _auto_lip_sync_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle a auto lip sync change event."""
+        if parameter[0:3] != "HOS":
+            return
+
+        if parameter[6:] == "HOSALS":
+            auto_lip_sync = parameter[5:]
+        elif parameter[3:] == "HOS":
+            auto_lip_sync = parameter[4:]
+        else:
+            return
+
+        self._auto_lip_sync = auto_lip_sync
 
     async def async_setup(self) -> None:
         """Ensure that configuration is loaded from receiver asynchronously."""
@@ -453,38 +424,48 @@ class DenonAVRDeviceInfo:
 
             # Add tags for a potential AppCommand.xml update
             self.api.add_appcommand_update_tag(AppCommands.GetAllZonePowerStatus)
+            self.api.add_appcommand_update_tag(AppCommands.GetAutoStandby)
+            self.api.add_appcommand_update_tag(AppCommands.GetDimmer)
+            self.api.add_appcommand_update_tag(AppCommands.GetECO)
 
             power_event = "ZM"
             if self.zone == ZONE2:
                 power_event = "Z2"
             elif self.zone == ZONE3:
                 power_event = "Z3"
-            self.telnet_api.register_callback(power_event, self._async_power_callback)
-
-            self.telnet_api.register_callback("MN", self._async_settings_menu_callback)
-            self.telnet_api.register_callback("DIM", self._async_dimmer_callback)
-            self.telnet_api.register_callback("PS", self._async_delay_callback)
-            self.telnet_api.register_callback("ECO", self._async_eco_mode_callback)
-            self.telnet_api.register_callback("VS", self._async_hdmi_output_callback)
-            self.telnet_api.register_callback(
-                "VS", self._async_hdmi_audio_decode_callback
-            )
-            self.telnet_api.register_callback(
-                "VS", self._async_video_processing_mode_callback
-            )
+            elif self.zones == 1:
+                # ZM events do not always work when the receiver has only one zone
+                # In this case it is safe to turn the entire device on and off
+                power_event = "PW"
+                self.telnet_commands = self.telnet_commands._replace(
+                    command_power_on="PWON", command_power_standby="PWSTANDBY"
+                )
+            self.telnet_api.register_callback(power_event, self._power_callback)
+
+            self.telnet_api.register_callback("MN", self._settings_menu_callback)
+            self.telnet_api.register_callback("DIM", self._dimmer_callback)
+            self.telnet_api.register_callback("PS", self._delay_callback)
+            self.telnet_api.register_callback("ECO", self._eco_mode_callback)
+            self.telnet_api.register_callback("VS", self._hdmi_output_callback)
+            self.telnet_api.register_callback("VS", self._hdmi_audio_decode_callback)
             self.telnet_api.register_callback(
-                "SS", self._async_tactile_transducer_callback
-            )
-            self.telnet_api.register_callback("STBY", self._async_auto_standby_callback)
-            self.telnet_api.register_callback("SLP", self._async_auto_sleep_callback)
-            self.telnet_api.register_callback("PS", self._async_room_size_callback)
-            self.telnet_api.register_callback("TR", self._async_trigger_callback)
-            self.telnet_api.register_callback("SP", self._async_speaker_preset_callback)
-            self.telnet_api.register_callback("BT", self._async_bt_callback)
-            self.telnet_api.register_callback("PS", self._async_delay_time_callback)
-            self.telnet_api.register_callback("PS", self._async_audio_restorer_callback)
-            self.telnet_api.register_callback("PS", self._async_graphic_eq_callback)
-            self.telnet_api.register_callback("PS", self._async_headphone_eq_callback)
+                "VS", self._video_processing_mode_callback
+            )
+            self.telnet_api.register_callback("SS", self._tactile_transducer_callback)
+            self.telnet_api.register_callback("STBY", self._auto_standby_callback)
+            self.telnet_api.register_callback("SLP", self._auto_sleep_callback)
+            self.telnet_api.register_callback("PS", self._room_size_callback)
+            self.telnet_api.register_callback("TR", self._trigger_callback)
+            self.telnet_api.register_callback("SP", self._speaker_preset_callback)
+            self.telnet_api.register_callback("BT", self._bt_callback)
+            self.telnet_api.register_callback("PS", self._delay_time_callback)
+            self.telnet_api.register_callback("PS", self._audio_restorer_callback)
+            self.telnet_api.register_callback("PS", self._graphic_eq_callback)
+            self.telnet_api.register_callback("PS", self._headphone_eq_callback)
+
+            if not self.is_denon:
+                self.telnet_api.register_callback("ILB", self._illumination_callback)
+                self.telnet_api.register_callback("SS", self._auto_lip_sync_callback)
 
             self._is_setup = True
             _LOGGER.debug("Finished device setup")
@@ -498,8 +479,13 @@ class DenonAVRDeviceInfo:
         if not self._is_setup:
             await self.async_setup()
 
-        # Update power status
-        await self.async_update_power(global_update=global_update, cache_id=cache_id)
+        if self.use_avr_2016_update:
+            await self.async_update_appcommand(
+                global_update=global_update, cache_id=cache_id
+            )
+        else:
+            await self.async_update_status_xml(cache_id=cache_id)
+
         _LOGGER.debug("Finished device update")
 
     async def async_identify_receiver(self) -> None:
@@ -541,6 +527,10 @@ class DenonAVRDeviceInfo:
                     err,
                 )
             else:
+                device_zones = xml.find("./DeviceZones")
+                if device_zones is not None:
+                    self.zones = device_zones.text
+
                 is_avr_x = self._is_avr_x(xml)
                 if is_avr_x:
                     self.receiver = r_type
@@ -567,7 +557,7 @@ class DenonAVRDeviceInfo:
         # First test by CommApiVers
         try:
             if bool(
-                DEVICEINFO_COMMAPI_PATTERN.search(deviceinfo.find("CommApiVers").text)
+                DEVICEINFO_COMMAPI_PATTERN.search(deviceinfo.find("./CommApiVers").text)
                 is not None
             ):
                 # receiver found , return True
@@ -580,7 +570,7 @@ class DenonAVRDeviceInfo:
         # if first test did not find AVR-X device, check by model name
         try:
             if bool(
-                DEVICEINFO_AVR_X_PATTERN.search(deviceinfo.find("ModelName").text)
+                DEVICEINFO_AVR_X_PATTERN.search(deviceinfo.find("./ModelName").text)
                 is not None
             ):
                 # receiver found , return True
@@ -640,49 +630,6 @@ class DenonAVRDeviceInfo:
             else:
                 self._set_friendly_name(xml)
 
-    async def async_verify_avr_2016_update_method(
-        self, *, cache_id: Hashable = None
-    ) -> None:
-        """Verify if avr 2016 update method is working."""
-        # Nothing to do if Appcommand.xml interface is not supported
-        if self._is_setup and not self.use_avr_2016_update:
-            return
-
-        try:
-            # Result is cached that it can be reused during update
-            await self.api.async_get_global_appcommand(cache_id=cache_id)
-        except (AvrTimoutError, AvrNetworkError) as err:
-            _LOGGER.debug("Connection error when verifying update method: %s", err)
-            raise
-        except AvrForbiddenError:
-            # Recovery in case receiver changes port from 80 to 8080 which
-            # might happen at Denon AVR-X 2016 receivers
-            if self._allow_recovery:
-                self._allow_recovery = False
-                _LOGGER.warning(
-                    "AppCommand.xml returns HTTP status 403. Running setup"
-                    " again once to check if receiver interface switched "
-                    "ports"
-                )
-                self._is_setup = False
-                await self.async_setup()
-                await self.async_verify_avr_2016_update_method(cache_id=cache_id)
-            else:
-                raise
-        except AvrIncompleteResponseError as err:
-            _LOGGER.debug("Request error when verifying update method: %s", err)
-            # Only AVR_X devices support both interfaces
-            if self.receiver == AVR_X:
-                _LOGGER.warning(
-                    "Error verifying Appcommand.xml update method, it returns "
-                    "an incomplete result set. Deactivating the interface"
-                )
-                self.use_avr_2016_update = False
-        else:
-            if not self._allow_recovery:
-                _LOGGER.info("AppCommand.xml recovered from HTTP status 403 error")
-            self._allow_recovery = True
-
     def _set_friendly_name(self, xml: ET.Element) -> None:
         """Set FriendlyName from result xml."""
         # friendlyname tag of AppCommand.xml, FriendlyName tag main zone xml
@@ -729,6 +676,7 @@ class DenonAVRDeviceInfo:
 
         if device_info is None:
             self.manufacturer = "Denon"
+            self.telnet_api.is_denon = self.is_denon
             self.model_name = "Unknown"
             self.serial_number = None
             _LOGGER.warning(
@@ -744,89 +692,101 @@ class DenonAVRDeviceInfo:
         if self.friendly_name is None and "friendlyName" in device_info:
             self.friendly_name = device_info["friendlyName"]
         self.manufacturer = device_info["manufacturer"]
+        self.telnet_api.is_denon = self.is_denon
         self.model_name = device_info["modelName"]
         self.serial_number = device_info["serialNumber"]
 
-    async def async_update_power(
-        self, global_update: bool = False, cache_id: Optional[Hashable] = None
-    ) -> None:
-        """Update power status of device."""
-        if self.use_avr_2016_update is None:
-            raise AvrProcessingError(
-                "Device is not setup correctly, update method not set"
-            )
-
-        if self.use_avr_2016_update:
-            await self.async_update_power_appcommand(
-                global_update=global_update, cache_id=cache_id
-            )
-        else:
-            await self.async_update_power_status_xml(cache_id=cache_id)
-
-    async def async_update_power_appcommand(
+    async def async_update_appcommand(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
-        """Update power status from AppCommand.xml."""
+        """Update status from AppCommand.xml."""
         power_appcommand = AppCommands.GetAllZonePowerStatus
+        dimmer_appcommand = AppCommands.GetDimmer
+        autostandby_appcommand = AppCommands.GetAutoStandby
+        eco_appcommand = AppCommands.GetECO
+        appcommands = (
+            power_appcommand,
+            autostandby_appcommand,
+            dimmer_appcommand,
+            eco_appcommand,
+        )
+
         try:
             if global_update:
                 xml = await self.api.async_get_global_appcommand(cache_id=cache_id)
             else:
                 xml = await self.api.async_post_appcommand(
-                    self.urls.appcommand, tuple(power_appcommand), cache_id=cache_id
+                    self.urls.appcommand, appcommands, cache_id=cache_id
                 )
         except AvrRequestError as err:
-            _LOGGER.debug("Error when getting power status: %s", err)
+            _LOGGER.debug("Error when getting device status: %s", err)
             raise
 
         # Extract relevant information
-        zone = self.get_own_zone()
-
-        # Search for power tag
-        power_tag = xml.find(
-            f"./cmd[@{APPCOMMAND_CMD_TEXT}='{power_appcommand.cmd_text}']/{zone}"
-        )
+        for appcommand in appcommands:
+            for i, item in enumerate(
+                create_appcommand_search_strings(appcommand, self.zone)
+            ):
+                tag = xml.find(item)
 
-        if power_tag is None:
-            raise AvrProcessingError(
-                f"Power attribute of zone {self.zone} not found on update"
-            )
+                if tag is None:
+                    _LOGGER.debug(
+                        "%s attribute of zone %s not found on update",
+                        appcommand.response_pattern[0].update_attribute,
+                        self.zone,
+                    )
+                    continue
 
-        self._power = power_tag.text
+                setattr(self, appcommand.response_pattern[i].update_attribute, tag.text)
 
-    async def async_update_power_status_xml(
+    async def async_update_status_xml(
         self, cache_id: Optional[Hashable] = None
     ) -> None:
-        """Update power status from status xml."""
+        """Update status from status xml."""
         # URLs to be scanned
         urls = [self.urls.status]
         if self.zone == MAIN_ZONE:
             urls.append(self.urls.mainzone)
         else:
             urls.append(f"{self.urls.mainzone}?ZoneName={self.zone}")
-        # Tags in XML which might contain information about zones power status
-        # ordered by their priority
-        tags = ["./ZonePower/value", "./Power/value"]
 
-        for tag in tags:
-            for url in urls:
-                try:
-                    xml = await self.api.async_get_xml(url, cache_id=cache_id)
-                except AvrRequestError as err:
-                    _LOGGER.debug(
-                        "Error when getting power status from url %s: %s", url, err
-                    )
-                    continue
+        # There are different XML tags which might contain information
+        # about zone status attributes.
+        attribute_searchstrings = {
+            "_power": ["./ZonePower/value", "./Power/value"],
+            "_eco_mode": ["./ECOMode/value"],
+        }
 
-                # Search for power tag
-                power_tag = xml.find(tag)
-                if power_tag is not None and power_tag.text is not None:
-                    self._power = power_tag.text
-                    return
+        for url in urls:
+            if len(attribute_searchstrings) == 0:
+                break
 
-        raise AvrProcessingError(
-            f"Power attribute of zone {self.zone} not found on update"
-        )
+            try:
+                xml = await self.api.async_get_xml(url, cache_id=cache_id)
+            except AvrRequestError as err:
+                _LOGGER.debug(
+                    "Error when getting device status from url %s: %s", url, err
+                )
+                continue
+
+            attributes_found = []
+            for attribute, searchstrings in attribute_searchstrings.items():
+                for searchstring in searchstrings:
+                    tag = xml.find(searchstring)
+                    if tag is not None and tag.text is not None:
+                        setattr(self, attribute, tag.text)
+                        attributes_found.append(attribute)
+                        break
+
+            for attribute in attributes_found:
+                attribute_searchstrings.pop(attribute)
+
+        if len(attribute_searchstrings) > 0:
+            _LOGGER.debug(
+                "%s attributes of zone %s not found on update",
+                attribute_searchstrings.keys(),
+                self.zone,
+            )
 
     ##############
     # Properties #
@@ -854,8 +814,6 @@ class DenonAVRDeviceInfo:
         """
         Returns the dimmer state of the device.
 
-        Only available if using Telnet.
-
         Possible values are: "Off", "Dark", "Dim" and "Bright"
         """
         return self._dimmer
@@ -865,9 +823,7 @@ class DenonAVRDeviceInfo:
         """
         Return the auto-standby state of the device.
 
-        Only available if using Telnet.
-
-        Possible values are: "OFF", "15M", "30M", "60M"
+        Possible values are: "OFF", "15M", "30M", "60M", "2H", "4H", "8H"
         """
         return self._auto_standby
 
@@ -896,8 +852,6 @@ class DenonAVRDeviceInfo:
         """
         Returns the eco-mode for the device.
 
-        Only available if using Telnet.
-
         Possible values are: "Off", "On", "Auto"
         """
         return self._eco_mode
@@ -974,7 +928,7 @@ class DenonAVRDeviceInfo:
         return self._room_size
 
     @property
-    def triggers(self) -> Dict[int, str]:
+    def triggers(self) -> Optional[Dict[int, str]]:
         """
         Return the triggers and their statuses for the device.
 
@@ -1051,11 +1005,38 @@ class DenonAVRDeviceInfo:
         """
         return self._headphone_eq
 
+    @property
+    def illumination(self) -> Optional[str]:
+        """
+        Return the illumination status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+
+        Possible values are: "Auto", "Bright", "Dim", "Dark", "Off"
+        """
+        return self._illumination
+
+    @property
+    def auto_lip_sync(self) -> Optional[bool]:
+        """
+        Return the auto lip sync status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        return self._auto_lip_sync
+
     @property
     def telnet_available(self) -> bool:
         """Return true if telnet is connected and healthy."""
         return self.telnet_api.connected and self.telnet_api.healthy
 
+    @property
+    def is_denon(self) -> bool:
+        """Return true if the receiver is a Denon device."""
+        if not self.manufacturer:
+            return True  # Fallback to Denon
+        return "denon" in self.manufacturer.lower()
+
     ##########
     # Getter #
     ##########
@@ -1080,7 +1061,7 @@ class DenonAVRDeviceInfo:
     ##########
 
     async def async_power_on(self) -> None:
-        """Turn on receiver via HTTP get command."""
+        """Turn on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_power_on
@@ -1089,7 +1070,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_power_on)
 
     async def async_power_off(self) -> None:
-        """Turn off receiver via HTTP get command."""
+        """Turn off receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_power_standby
@@ -1098,7 +1079,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_power_standby)
 
     async def async_cursor_up(self) -> None:
-        """Cursor Up on receiver via HTTP get command."""
+        """Cursor Up on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_cusor_up, skip_confirmation=True
@@ -1107,7 +1088,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_cusor_up)
 
     async def async_cursor_down(self) -> None:
-        """Cursor Down on receiver via HTTP get command."""
+        """Cursor Down on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_cusor_down, skip_confirmation=True
@@ -1116,7 +1097,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_cusor_down)
 
     async def async_cursor_left(self) -> None:
-        """Cursor Left on receiver via HTTP get command."""
+        """Cursor Left on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_cusor_left, skip_confirmation=True
@@ -1125,7 +1106,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_cusor_left)
 
     async def async_cursor_right(self) -> None:
-        """Cursor Right on receiver via HTTP get command."""
+        """Cursor Right on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_cusor_right, skip_confirmation=True
@@ -1134,7 +1115,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_cusor_right)
 
     async def async_cursor_enter(self) -> None:
-        """Cursor Enter on receiver via HTTP get command."""
+        """Cursor Enter on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_cusor_enter, skip_confirmation=True
@@ -1143,7 +1124,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_cusor_enter)
 
     async def async_back(self) -> None:
-        """Back command on receiver via HTTP get command."""
+        """Back command on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_back, skip_confirmation=True
@@ -1152,7 +1133,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_back)
 
     async def async_info(self) -> None:
-        """Info OSD on receiver via HTTP get command."""
+        """Info OSD on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_info, skip_confirmation=True
@@ -1161,7 +1142,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_info)
 
     async def async_options(self) -> None:
-        """Options menu on receiver via HTTP get command."""
+        """Options menu on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_options, skip_confirmation=True
@@ -1171,7 +1152,7 @@ class DenonAVRDeviceInfo:
 
     async def async_settings_menu(self) -> None:
         """
-        Options menu on receiver via HTTP get command.
+        Options menu on receiver.
 
         Only available if using Telnet.
         """
@@ -1185,7 +1166,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_channel_level_adjust(self) -> None:
-        """Toggle the channel level adjust menu on receiver via HTTP get command."""
+        """Toggle the channel level adjust menu on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_channel_level_adjust
@@ -1194,7 +1175,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_channel_level_adjust)
 
     async def async_dimmer_toggle(self) -> None:
-        """Toggle dimmer on receiver via HTTP get command."""
+        """Toggle dimmer on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_dimmer_toggle
@@ -1203,11 +1184,11 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_dimmer_toggle)
 
     async def async_dimmer(self, mode: DimmerModes) -> None:
-        """Set dimmer mode on receiver via HTTP get command."""
+        """Set dimmer mode on receiver."""
         if mode not in self._dimmer_modes:
             raise AvrCommandError("Invalid dimmer mode")
 
-        mapped_mode = DIMMER_MODE_MAP[mode]
+        mapped_mode = DIMMER_MODE_MAP_REVERSE[mode]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_dimmer_set.format(mode=mapped_mode)
@@ -1218,7 +1199,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_tactile_transducer_on(self) -> None:
-        """Turn on tactile transducer on receiver via HTTP get command."""
+        """Turn on tactile transducer on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_tactile_transducer.format(mode="ON")
@@ -1229,7 +1210,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_auto_standby(self, auto_standby: AutoStandbys) -> None:
-        """Set auto standby on receiver via HTTP get command."""
+        """Set auto standby on receiver."""
         if auto_standby not in self._auto_standbys:
             raise AvrCommandError("Invalid Auto Standby mode")
         if self.telnet_available:
@@ -1243,7 +1224,7 @@ class DenonAVRDeviceInfo:
 
     async def async_sleep(self, sleep: Union[Literal["OFF"], int]) -> None:
         """
-        Set auto standby on receiver via HTTP get command.
+        Set auto standby on receiver.
 
         Valid sleep values are "OFF" and 1-120 (in minutes)
         """
@@ -1261,7 +1242,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_tactile_transducer_off(self) -> None:
-        """Turn on tactile transducer on receiver via HTTP get command."""
+        """Turn on tactile transducer on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_tactile_transducer.format(mode="OFF")
@@ -1273,7 +1254,7 @@ class DenonAVRDeviceInfo:
 
     async def async_tactile_transducer_toggle(self) -> None:
         """
-        Turn on tactile transducer on receiver via HTTP get command.
+        Turn on tactile transducer on receiver.
 
         Only available if using Telnet.
         """
@@ -1283,7 +1264,7 @@ class DenonAVRDeviceInfo:
             await self.async_tactile_transducer_on()
 
     async def async_tactile_transducer_level_up(self) -> None:
-        """Increase the transducer level on receiver via HTTP get command."""
+        """Increase the transducer level on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_tactile_transducer_level.format(mode="UP")
@@ -1294,7 +1275,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_tactile_transducer_level_down(self) -> None:
-        """Decrease the transducer level on receiver via HTTP get command."""
+        """Decrease the transducer level on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_tactile_transducer_level.format(
@@ -1307,7 +1288,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_transducer_lpf(self, lpf: TransducerLPFs):
-        """Set transducer low pass filter on receiver via HTTP get command."""
+        """Set transducer low pass filter on receiver."""
         if lpf not in self._tactile_transducer_lpfs:
             raise AvrCommandError("Invalid tactile transducer low pass filter")
 
@@ -1326,7 +1307,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_room_size(self, room_size: RoomSizes) -> None:
-        """Set room size on receiver via HTTP get command."""
+        """Set room size on receiver."""
         if room_size not in self._room_sizes:
             raise AvrCommandError("Invalid room size")
 
@@ -1341,7 +1322,7 @@ class DenonAVRDeviceInfo:
 
     async def async_trigger_on(self, trigger: int) -> None:
         """
-        Set trigger to ON on receiver via HTTP get command.
+        Set trigger to ON on receiver.
 
         :param trigger: Trigger number to set to ON. Valid values are 1-3.
         """
@@ -1359,7 +1340,7 @@ class DenonAVRDeviceInfo:
 
     async def async_trigger_off(self, trigger: int) -> None:
         """
-        Set trigger to OFF on receiver via HTTP get command.
+        Set trigger to OFF on receiver.
 
         :param trigger: Trigger number to set to OFF. Valid values are 1-3.
         """
@@ -1377,7 +1358,7 @@ class DenonAVRDeviceInfo:
 
     async def async_trigger_toggle(self, trigger: int) -> None:
         """
-        Toggle trigger on receiver via HTTP get command.
+        Toggle trigger on receiver.
 
         Only available if using Telnet.
 
@@ -1394,7 +1375,7 @@ class DenonAVRDeviceInfo:
 
     async def async_quick_select_mode(self, quick_select_number: int) -> None:
         """
-        Set quick select mode on receiver via HTTP get command.
+        Set quick select mode on receiver.
 
         :param quick_select_number: Quick select number to set. Valid values are 1-5.
         """
@@ -1402,15 +1383,15 @@ class DenonAVRDeviceInfo:
             raise AvrCommandError("Quick select number must be between 1 and 5")
 
         if self.telnet_available:
-            if "denon" in self.manufacturer.lower():
-                command = self.telnet_commands.command_quick_select_memory
+            if self.is_denon:
+                command = self.telnet_commands.command_quick_select_mode
             else:
-                command = self.telnet_commands.command_smart_select_memory
+                command = self.telnet_commands.command_smart_select_mode
             await self.telnet_api.async_send_commands(
                 command.format(number=quick_select_number)
             )
         else:
-            if "denon" in self.manufacturer.lower():
+            if self.is_denon:
                 command = self.urls.command_quick_select_mode
             else:
                 command = self.urls.command_smart_select_mode
@@ -1418,7 +1399,7 @@ class DenonAVRDeviceInfo:
 
     async def async_quick_select_memory(self, quick_select_number: int) -> None:
         """
-        Set quick select memory on receiver via HTTP get command.
+        Set quick select memory on receiver.
 
         :param quick_select_number: Quick select number to set. Valid values are 1-5.
         """
@@ -1426,22 +1407,22 @@ class DenonAVRDeviceInfo:
             raise AvrCommandError("Quick select number must be between 1 and 5")
 
         if self.telnet_available:
-            if "denon" in self.manufacturer.lower():
-                command = self.telnet_commands.command_quick_select_mode
+            if self.is_denon:
+                command = self.telnet_commands.command_quick_select_memory
             else:
-                command = self.telnet_commands.command_smart_select_mode
+                command = self.telnet_commands.command_smart_select_memory
             await self.telnet_api.async_send_commands(
                 command.format(number=quick_select_number)
             )
         else:
-            if "denon" in self.manufacturer.lower():
+            if self.is_denon:
                 command = self.urls.command_quick_select_memory
             else:
                 command = self.urls.command_smart_select_memory
             await self.api.async_get_command(command.format(number=quick_select_number))
 
     async def async_delay_up(self) -> None:
-        """Delay up on receiver via HTTP get command."""
+        """Delay up on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_delay_up
@@ -1450,7 +1431,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_delay_up)
 
     async def async_delay_down(self) -> None:
-        """Delay down on receiver via HTTP get command."""
+        """Delay down on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_delay_down
@@ -1463,7 +1444,7 @@ class DenonAVRDeviceInfo:
         if mode not in self._eco_modes:
             raise AvrCommandError("Invalid Eco mode")
 
-        mapped_mode = ECO_MODE_MAP[mode]
+        mapped_mode = ECO_MODE_MAP_REVERSE[mode]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_eco_mode.format(mode=mapped_mode)
@@ -1478,7 +1459,7 @@ class DenonAVRDeviceInfo:
         if output not in self._hdmi_outputs:
             raise AvrCommandError("Invalid HDMI output mode")
 
-        mapped_output = HDMI_OUTPUT_MAP[output]
+        mapped_output = HDMI_OUTPUT_MAP_REVERSE[output]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_hdmi_output.format(output=mapped_output)
@@ -1489,7 +1470,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_hdmi_audio_decode(self, mode: HDMIAudioDecodes) -> None:
-        """Set HDMI Audio Decode mode on receiver via HTTP get command."""
+        """Set HDMI Audio Decode mode on receiver."""
         if mode not in self._hdmi_audio_decodes:
             raise AvrCommandError("Invalid HDMI Audio Decode mode")
 
@@ -1503,10 +1484,10 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_video_processing_mode(self, mode: VideoProcessingModes) -> None:
-        """Set video processing mode on receiver via HTTP get command."""
+        """Set video processing mode on receiver."""
         if mode not in self._video_processing_modes:
             raise AvrCommandError("Invalid video processing mode")
-        processing_mode = VIDEO_PROCESSING_MODES_MAP[mode]
+        processing_mode = VIDEO_PROCESSING_MODES_MAP_REVERSE[mode]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_video_processing_mode.format(
@@ -1518,14 +1499,20 @@ class DenonAVRDeviceInfo:
                 self.urls.command_video_processing_mode.format(mode=processing_mode)
             )
 
-    async def async_status(self) -> str:
-        """Get status of receiver via HTTP get command."""
-        if "denon" not in self.manufacturer.lower():
+    async def async_status(self) -> None:
+        """Get status of receiver."""
+        if not self.is_denon:
             raise AvrCommandError("Status command is only supported for Denon devices")
-        return await self.api.async_get_command(self.urls.command_status)
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_status
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_status)
 
     async def async_system_reset(self) -> None:
-        """DANGER! Reset the receiver via HTTP get command."""
+        """DANGER! Reset the receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_system_reset
@@ -1534,7 +1521,7 @@ class DenonAVRDeviceInfo:
             await self.api.async_get_command(self.urls.command_system_reset)
 
     async def async_network_restart(self) -> None:
-        """Restart the network on the receiver via HTTP get command."""
+        """Restart the network on the receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_network_restart
@@ -1544,7 +1531,7 @@ class DenonAVRDeviceInfo:
 
     async def async_speaker_preset(self, preset: int) -> None:
         """
-        Set speaker preset on receiver via HTTP get command.
+        Set speaker preset on receiver.
 
         Valid preset values are 1-2.
         """
@@ -1562,7 +1549,7 @@ class DenonAVRDeviceInfo:
 
     async def async_speaker_preset_toggle(self) -> None:
         """
-        Toggle speaker preset on receiver via HTTP get command.
+        Toggle speaker preset on receiver.
 
         Only available if using Telnet.
         """
@@ -1572,7 +1559,7 @@ class DenonAVRDeviceInfo:
     async def async_bt_transmitter_on(
         self,
     ) -> None:
-        """Turn on Bluetooth transmitter on receiver via HTTP get command."""
+        """Turn on Bluetooth transmitter on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_bluetooth_transmitter.format(mode="ON")
@@ -1585,7 +1572,7 @@ class DenonAVRDeviceInfo:
     async def async_bt_transmitter_off(
         self,
     ) -> None:
-        """Turn off Bluetooth transmitter on receiver via HTTP get command."""
+        """Turn off Bluetooth transmitter on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_bluetooth_transmitter.format(mode="OFF")
@@ -1597,7 +1584,7 @@ class DenonAVRDeviceInfo:
 
     async def async_bt_transmitter_toggle(self) -> None:
         """
-        Toggle Bluetooth transmitter mode on receiver via HTTP get command.
+        Toggle Bluetooth transmitter mode on receiver.
 
         Only available if using Telnet.
         """
@@ -1607,11 +1594,11 @@ class DenonAVRDeviceInfo:
             await self.async_bt_transmitter_on()
 
     async def async_bt_output_mode(self, mode: BluetoothOutputModes) -> None:
-        """Set Bluetooth transmitter mode on receiver via HTTP get command."""
+        """Set Bluetooth transmitter mode on receiver."""
         if mode not in self._bt_output_modes:
             raise AvrCommandError("Invalid Bluetooth output mode")
 
-        mapped_mode = BLUETOOTH_OUTPUT_MODES_MAP[mode]
+        mapped_mode = BLUETOOTH_OUTPUT_MODES_MAP_REVERSE[mode]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_bluetooth_transmitter.format(
@@ -1625,7 +1612,7 @@ class DenonAVRDeviceInfo:
 
     async def async_bt_output_mode_toggle(self) -> None:
         """
-        Toggle Bluetooth output mode on receiver via HTTP get command.
+        Toggle Bluetooth output mode on receiver.
 
         Only available if using Telnet.
         """
@@ -1635,7 +1622,7 @@ class DenonAVRDeviceInfo:
             await self.async_bt_output_mode("Bluetooth + Speakers")
 
     async def async_delay_time_up(self) -> None:
-        """Delay time up on receiver via HTTP get command."""
+        """Delay time up on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_delay_time.format(value="UP")
@@ -1646,7 +1633,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_delay_time_down(self) -> None:
-        """Delay time up on receiver via HTTP get command."""
+        """Delay time up on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_delay_time.format(value="DOWN")
@@ -1658,7 +1645,7 @@ class DenonAVRDeviceInfo:
 
     async def async_delay_time(self, delay_time: int) -> None:
         """
-        Set delay time on receiver via HTTP get command.
+        Set delay time on receiver.
 
         :param delay_time: Delay time in ms. Valid values are 0-999.
         """
@@ -1675,11 +1662,11 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_audio_restorer(self, mode: AudioRestorers):
-        """Set audio restorer on receiver via HTTP get command."""
+        """Set audio restorer on receiver."""
         if mode not in self._audio_restorers:
             raise AvrCommandError("Invalid audio restorer mode")
 
-        mapped_mode = AUDIO_RESTORER_MAP[mode]
+        mapped_mode = AUDIO_RESTORER_MAP_REVERSE[mode]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_audio_restorer.format(mode=mapped_mode)
@@ -1690,7 +1677,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_remote_control_lock(self):
-        """Set remote control lock on receiver via HTTP get command."""
+        """Set remote control lock on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_remote_control_lock.format(mode="ON")
@@ -1701,7 +1688,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_remote_control_unlock(self):
-        """Set remote control unlock on receiver via HTTP get command."""
+        """Set remote control unlock on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_remote_control_lock.format(mode="OFF")
@@ -1712,7 +1699,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_panel_lock(self, panel_lock_mode: PanelLocks):
-        """Set panel lock on receiver via HTTP get command."""
+        """Set panel lock on receiver."""
         if panel_lock_mode not in self._panel_locks:
             raise AvrCommandError("Invalid panel lock mode")
 
@@ -1736,7 +1723,7 @@ class DenonAVRDeviceInfo:
                 )
 
     async def async_panel_unlock(self):
-        """Set panel unlock on receiver via HTTP get command."""
+        """Set panel unlock on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_panel_lock.format(mode="OFF")
@@ -1747,7 +1734,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_graphic_eq_on(self) -> None:
-        """Turn on Graphic EQ on receiver via HTTP get command."""
+        """Turn on Graphic EQ on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_graphic_eq.format(mode="ON")
@@ -1758,7 +1745,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_graphic_eq_off(self) -> None:
-        """Turn off Graphic EQ on receiver via HTTP get command."""
+        """Turn off Graphic EQ on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_graphic_eq.format(mode="OFF")
@@ -1770,7 +1757,7 @@ class DenonAVRDeviceInfo:
 
     async def async_graphic_eq_toggle(self) -> None:
         """
-        Toggle Graphic EQ on receiver via HTTP get command.
+        Toggle Graphic EQ on receiver.
 
         Only available if using Telnet.
         """
@@ -1780,7 +1767,7 @@ class DenonAVRDeviceInfo:
             await self.async_graphic_eq_on()
 
     async def async_headphone_eq_on(self) -> None:
-        """Turn on Headphone EQ on receiver via HTTP get command."""
+        """Turn on Headphone EQ on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_headphone_eq.format(mode="ON")
@@ -1791,7 +1778,7 @@ class DenonAVRDeviceInfo:
             )
 
     async def async_headphone_eq_off(self) -> None:
-        """Turn off Headphone EQ on receiver via HTTP get command."""
+        """Turn off Headphone EQ on receiver."""
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_headphone_eq.format(mode="OFF")
@@ -1803,7 +1790,7 @@ class DenonAVRDeviceInfo:
 
     async def async_headphone_eq_toggle(self) -> None:
         """
-        Toggle Headphone EQ on receiver via HTTP get command.
+        Toggle Headphone EQ on receiver.
 
         Only available if using Telnet.
         """
@@ -1812,6 +1799,223 @@ class DenonAVRDeviceInfo:
         else:
             await self.async_headphone_eq_on()
 
+    async def async_hdmi_cec_on(self) -> None:
+        """Turn on HDMI CEC on receiver."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_denon_hdmi_cec_on
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_on
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_denon_hdmi_cec_on
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_on
+            )
+
+    async def async_hdmi_cec_off(self) -> None:
+        """Turn off HDMI CEC on receiver."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_denon_hdmi_cec_off
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_off
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_denon_hdmi_cec_off
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_off
+            )
+
+    async def async_illumination(self, mode: Illuminations):
+        """
+        Set illumination mode on receiver.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Illumination is only available for Marantz devices")
+
+        if mode not in self._illuminations:
+            raise AvrCommandError("Invalid illumination mode")
+
+        mapped_mode = ILLUMINATION_MAP_REVERSE[mode]
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_illumination.format(mode=mapped_mode)
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_illumination.format(mode=mapped_mode)
+            )
+
+    async def async_auto_lip_sync_on(self) -> None:
+        """
+        Turn on auto lip sync on receiver.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_auto_lip_sync.format(mode="ON")
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_auto_lip_sync.format(mode="ON")
+            )
+
+    async def async_auto_lip_sync_off(self) -> None:
+        """
+        Turn off auto lip sync on receiver.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_auto_lip_sync.format(mode="OFF")
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_auto_lip_sync.format(mode="OFF")
+            )
+
+    async def async_auto_lip_sync_toggle(self) -> None:
+        """
+        Toggle auto lip sync on receiver.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self._auto_lip_sync:
+            await self.async_auto_lip_sync_off()
+        else:
+            await self.async_auto_lip_sync_on()
+
+    async def async_page_up(self) -> None:
+        """Page Up on receiver."""
+        if self.telnet_available:
+            command = (
+                self.telnet_commands.command_page_up_denon
+                if self.is_denon
+                else self.telnet_commands.command_page_up_marantz
+            )
+            await self.telnet_api.async_send_commands(command)
+        else:
+            command = (
+                self.urls.command_page_up_denon
+                if self.is_denon
+                else self.urls.command_page_up_marantz
+            )
+            await self.api.async_get_command(command)
+
+    async def async_page_down(self) -> None:
+        """Page Down on receiver."""
+        if self.telnet_available:
+            command = (
+                self.telnet_commands.command_page_down_denon
+                if self.is_denon
+                else self.telnet_commands.command_page_down_marantz
+            )
+            await self.telnet_api.async_send_commands(command)
+        else:
+            command = (
+                self.urls.command_page_down_denon
+                if self.is_denon
+                else self.urls.command_page_down_marantz
+            )
+            await self.api.async_get_command(command)
+
+    async def async_input_mode(self, mode: InputModes):
+        """Set input mode on receiver."""
+        if mode not in self._input_modes:
+            raise AvrCommandError("Invalid input mode")
+
+        if mode == "Select":
+            command = (
+                self.telnet_commands.command_input_mode_select_denon
+                if self.telnet_available
+                else (
+                    self.urls.command_input_mode_select_denon
+                    if self.is_denon
+                    else (
+                        self.telnet_commands.command_input_mode_select_marantz
+                        if self.telnet_available
+                        else self.urls.command_input_mode_select_marantz
+                    )
+                )
+            )
+        elif mode == "Auto":
+            command = (
+                self.telnet_commands.command_input_mode_auto_denon
+                if self.telnet_available
+                else (
+                    self.urls.command_input_mode_auto_denon
+                    if self.is_denon
+                    else (
+                        self.telnet_commands.command_input_mode_auto_marantz
+                        if self.telnet_available
+                        else self.urls.command_input_mode_auto_marantz
+                    )
+                )
+            )
+        elif mode == "HDMI":
+            command = (
+                self.telnet_commands.command_input_mode_hdmi_denon
+                if self.telnet_available
+                else (
+                    self.urls.command_input_mode_hdmi_denon
+                    if self.is_denon
+                    else (
+                        self.telnet_commands.command_input_mode_hdmi_marantz
+                        if self.telnet_available
+                        else self.urls.command_input_mode_hdmi_marantz
+                    )
+                )
+            )
+        elif mode == "Digital":
+            command = (
+                self.telnet_commands.command_input_mode_digital_denon
+                if self.telnet_available
+                else (
+                    self.urls.command_input_mode_digital_denon
+                    if self.is_denon
+                    else (
+                        self.telnet_commands.command_input_mode_digital_marantz
+                        if self.telnet_available
+                        else self.urls.command_input_mode_digital_marantz
+                    )
+                )
+            )
+        else:
+            command = (
+                self.telnet_commands.command_input_mode_analog_denon
+                if self.telnet_available
+                else (
+                    self.urls.command_input_mode_analog_denon
+                    if self.is_denon
+                    else (
+                        self.telnet_commands.command_input_mode_analog_marantz
+                        if self.telnet_available
+                        else self.urls.command_input_mode_analog_marantz
+                    )
+                )
+            )
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(command)
+        else:
+            await self.api.async_get_command(command)
+
 
 @attr.s(auto_attribs=True, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRFoundation:
@@ -1861,11 +2065,11 @@ class DenonAVRFoundation:
             raise
 
         # Extract relevant information
-        zone = self._device.get_own_zone()
-
         attrs = deepcopy(update_attrs)
         for app_command in attrs.keys():
-            search_strings = self.create_appcommand_search_strings(app_command, zone)
+            search_strings = create_appcommand_search_strings(
+                app_command, self._device.zone
+            )
             start = 0
             success = 0
             for i, pattern in enumerate(app_command.response_pattern):
@@ -1904,9 +2108,10 @@ class DenonAVRFoundation:
 
         # Check if each attribute was updated
         if update_attrs:
-            raise AvrProcessingError(
-                f"Some attributes of zone {self._device.zone} not found on update:"
-                f" {update_attrs}"
+            _LOGGER.debug(
+                "Some attributes of zone %s not found on update: %s",
+                self._device.zone,
+                update_attrs,
             )
 
     async def async_update_attrs_status_xml(
@@ -1964,39 +2169,58 @@ class DenonAVRFoundation:
 
         # Check if each attribute was updated
         if update_attrs:
-            raise AvrProcessingError(
-                f"Some attributes of zone {self._device.zone} not found on update:"
-                f" {update_attrs}"
-            )
-
-    @staticmethod
-    def create_appcommand_search_strings(
-        app_command_cmd: AppCommandCmd, zone: str
-    ) -> List[str]:
-        """Create search pattern for AppCommand(0300).xml response."""
-        result = []
-
-        for resp in app_command_cmd.response_pattern:
-            string = "./cmd"
-            # Text of cmd tag in query was added as attribute to response
-            if app_command_cmd.cmd_text:
-                string = (
-                    string + f"[@{APPCOMMAND_CMD_TEXT}='{app_command_cmd.cmd_text}']"
-                )
-            # Text of name tag in query was added as attribute to response
-            if app_command_cmd.name:
-                string = string + f"[@{APPCOMMAND_NAME}='{app_command_cmd.name}']"
-            # Some results include a zone tag
-            if resp.add_zone:
-                string = string + f"/{zone}"
-            # Suffix like /status, /volume
-            string = string + resp.suffix
-
-            # A complete search string with all strributes set looks like
-            # ./cmd[@cmd_text={cmd_text}][@name={name}]/zone1/volume
-            result.append(string)
+            _LOGGER.debug(
+                "Some attributes of zone %s not found on update: %s",
+                self._device.zone,
+                update_attrs,
+            )
+
+
+def create_appcommand_search_strings(
+    app_command_cmd: AppCommandCmd, zone: str
+) -> List[str]:
+    """Create search pattern for AppCommand(0300).xml response."""
+    result = []
+
+    zone_element = get_zone_element(zone)
+
+    for resp in app_command_cmd.response_pattern:
+        string = "./cmd"
+        # Text of cmd tag in query was added as attribute to response
+        if app_command_cmd.cmd_text:
+            string = string + f"[@{APPCOMMAND_CMD_TEXT}='{app_command_cmd.cmd_text}']"
+        # Text of name tag in query was added as attribute to response
+        if app_command_cmd.name:
+            string = string + f"[@{APPCOMMAND_NAME}='{app_command_cmd.name}']"
+        # Prefix like /list/listvalue/
+        if resp.prefix:
+            string = string + resp.prefix
+        # Some results include a zone element
+        if resp.add_zone:
+            string = string + f"/{zone_element}"
+        # If the result can be identified by a "zone" element in the same node
+        if resp.search_zone_text:
+            string = string + f"/zone[.='{zone}']/.."
+        # Suffix like /status, /volume
+        string = string + resp.suffix
+
+        # A complete search string with all attributes looks like
+        # ./cmd[@cmd_text={cmd_text}][@name={name}]/zone1/volume
+        result.append(string)
+
+    return result
+
+
+def get_zone_element(zone: str) -> str:
+    """
+    Get a zone element for evaluation of receiver XML responses.
 
-        return result
+    This zone element are used to evaluate XML responses of HTTP POST
+    commands.
+    """
+    if zone == MAIN_ZONE:
+        return "zone1"
+    return zone.lower()
 
 
 def set_api_host(
@@ -2023,7 +2247,7 @@ def set_api_timeout(
     return value
 
 
-def convert_string_int_bool(value: Union[str, bool]) -> bool:
+def convert_string_int_bool(value: Union[str, bool]) -> Optional[bool]:
     """Convert an integer from string format to bool."""
     if value is None:
         return None