evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplify requests in the Broadlink integration (#58850)

Browse source
This commit is contained in:
Felipe Martins Diel 2021-11-01 08:49:00 -03:00 • committed by GitHub
parent f0bd6acd48
commit 93bc88be16
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 50 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
homeassistant/components/broadlink/entity.py
View file

@ -53,11 +53,13 @@ class BroadlinkEntity(Entity):
@property
def device_info(self) -> DeviceInfo:
"""Return device info."""
device = self._device
return DeviceInfo(
connections={(dr.CONNECTION_NETWORK_MAC, self._device.mac_address)},
identifiers={(DOMAIN, self._device.unique_id)},
manufacturer=self._device.api.manufacturer,
model=self._device.api.model,
name=self._device.name,
sw_version=self._device.fw_version,
connections={(dr.CONNECTION_NETWORK_MAC, device.mac_address)},
identifiers={(DOMAIN, device.unique_id)},
manufacturer=device.api.manufacturer,
model=device.api.model,
name=device.name,
sw_version=device.fw_version,
)

6
homeassistant/components/broadlink/light.py
View file

@ -124,10 +124,10 @@ class BroadlinkLight(BroadlinkEntity, LightEntity):
async def _async_set_state(self, state):
"""Set the state of the light."""
device = self._device
try:
state = await self._device.async_request(
self._device.api.set_state, **state
)
state = await device.async_request(device.api.set_state, **state)
except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to set state: %s", err)
return

52
homeassistant/components/broadlink/remote.py
View file

@ -213,10 +213,11 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
kwargs[ATTR_COMMAND] = command
kwargs = SERVICE_SEND_SCHEMA(kwargs)
commands = kwargs[ATTR_COMMAND]
device = kwargs.get(ATTR_DEVICE)
subdevice = kwargs.get(ATTR_DEVICE)
repeat = kwargs[ATTR_NUM_REPEATS]
delay = kwargs[ATTR_DELAY_SECS]
service = f"{RM_DOMAIN}.{SERVICE_SEND_COMMAND}"
device = self._device
if not self._attr_is_on:
_LOGGER.warning(
@ -228,13 +229,13 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await self._async_load_storage()
try:
code_list = self._extract_codes(commands, device)
code_list = self._extract_codes(commands, subdevice)
except ValueError as err:
_LOGGER.error("Failed to call %s: %s", service, err)
raise
rf_flags = {0xB2, 0xD7}
if not hasattr(self._device.api, "sweep_frequency") and any(
if not hasattr(device.api, "sweep_frequency") and any(
c[0] in rf_flags for codes in code_list for c in codes
):
err_msg = f"{self.entity_id} doesn't support sending RF commands"
@ -247,18 +248,18 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await asyncio.sleep(delay)
if len(codes) > 1:
code = codes[self._flags[device]]
code = codes[self._flags[subdevice]]
else:
code = codes[0]
try:
await self._device.async_request(self._device.api.send_data, code)
await device.async_request(device.api.send_data, code)
except (BroadlinkException, OSError) as err:
_LOGGER.error("Error during %s: %s", service, err)
break
if len(codes) > 1:
self._flags[device] ^= 1
self._flags[subdevice] ^= 1
at_least_one_sent = True
if at_least_one_sent:
@ -269,9 +270,10 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
kwargs = SERVICE_LEARN_SCHEMA(kwargs)
commands = kwargs[ATTR_COMMAND]
command_type = kwargs[ATTR_COMMAND_TYPE]
device = kwargs[ATTR_DEVICE]
subdevice = kwargs[ATTR_DEVICE]
toggle = kwargs[ATTR_ALTERNATIVE]
service = f"{RM_DOMAIN}.{SERVICE_LEARN_COMMAND}"
device = self._device
if not self._attr_is_on:
_LOGGER.warning(
@ -286,7 +288,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
if command_type == COMMAND_TYPE_IR:
learn_command = self._async_learn_ir_command
elif hasattr(self._device.api, "sweep_frequency"):
elif hasattr(device.api, "sweep_frequency"):
learn_command = self._async_learn_rf_command
else:
@ -310,7 +312,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
_LOGGER.error("Failed to learn '%s': %s", command, err)
continue
self._codes.setdefault(device, {}).update({command: code})
self._codes.setdefault(subdevice, {}).update({command: code})
should_store = True
if should_store:
@ -318,8 +320,10 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
async def _async_learn_ir_command(self, command):
"""Learn an infrared command."""
device = self._device
try:
await self._device.async_request(self._device.api.enter_learning)
await device.async_request(device.api.enter_learning)
except (BroadlinkException, OSError) as err:
_LOGGER.debug("Failed to enter learning mode: %s", err)
@ -336,7 +340,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
while (dt.utcnow() - start_time) < LEARNING_TIMEOUT:
await asyncio.sleep(1)
try:
code = await self._device.async_request(self._device.api.check_data)
code = await device.async_request(device.api.check_data)
except (ReadError, StorageError):
continue
return b64encode(code).decode("utf8")
@ -353,8 +357,10 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
async def _async_learn_rf_command(self, command):
"""Learn a radiofrequency command."""
device = self._device
try:
await self._device.async_request(self._device.api.sweep_frequency)
await device.async_request(device.api.sweep_frequency)
except (BroadlinkException, OSError) as err:
_LOGGER.debug("Failed to sweep frequency: %s", err)
@ -370,15 +376,11 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
start_time = dt.utcnow()
while (dt.utcnow() - start_time) < LEARNING_TIMEOUT:
await asyncio.sleep(1)
found = await self._device.async_request(
self._device.api.check_frequency
)
found = await device.async_request(device.api.check_frequency)
if found:
break
else:
await self._device.async_request(
self._device.api.cancel_sweep_frequency
)
await device.async_request(device.api.cancel_sweep_frequency)
raise TimeoutError(
"No radiofrequency found within "
f"{LEARNING_TIMEOUT.total_seconds()} seconds"
@ -392,7 +394,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await asyncio.sleep(1)
try:
await self._device.async_request(self._device.api.find_rf_packet)
await device.async_request(device.api.find_rf_packet)
except (BroadlinkException, OSError) as err:
_LOGGER.debug("Failed to enter learning mode: %s", err)
@ -409,7 +411,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
while (dt.utcnow() - start_time) < LEARNING_TIMEOUT:
await asyncio.sleep(1)
try:
code = await self._device.async_request(self._device.api.check_data)
code = await device.async_request(device.api.check_data)
except (ReadError, StorageError):
continue
return b64encode(code).decode("utf8")
@ -428,7 +430,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
"""Delete a list of commands from a remote."""
kwargs = SERVICE_DELETE_SCHEMA(kwargs)
commands = kwargs[ATTR_COMMAND]
device = kwargs[ATTR_DEVICE]
subdevice = kwargs[ATTR_DEVICE]
service = f"{RM_DOMAIN}.{SERVICE_DELETE_COMMAND}"
if not self._attr_is_on:
@ -443,9 +445,9 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await self._async_load_storage()
try:
codes = self._codes[device]
codes = self._codes[subdevice]
except KeyError as err:
err_msg = f"Device not found: {repr(device)}"
err_msg = f"Device not found: {repr(subdevice)}"
_LOGGER.error("Failed to call %s. %s", service, err_msg)
raise ValueError(err_msg) from err
@ -470,8 +472,8 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
# Clean up
if not codes:
del self._codes[device]
if self._flags.pop(device, None) is not None:
del self._codes[subdevice]
if self._flags.pop(subdevice, None) is not None:
self._flag_storage.async_delay_save(self._get_flags, FLAG_SAVE_DELAY)
self._code_storage.async_delay_save(self._get_codes, CODE_SAVE_DELAY)

18
homeassistant/components/broadlink/switch.py
View file

@ -179,11 +179,13 @@ class BroadlinkRMSwitch(BroadlinkSwitch):
async def _async_send_packet(self, packet):
"""Send a packet to the device."""
device = self._device
if packet is None:
return True
try:
await self._device.async_request(self._device.api.send_data, packet)
await device.async_request(device.api.send_data, packet)
except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err)
return False
@ -200,8 +202,10 @@ class BroadlinkSP1Switch(BroadlinkSwitch):
async def _async_send_packet(self, packet):
"""Send a packet to the device."""
device = self._device
try:
await self._device.async_request(self._device.api.set_power, packet)
await device.async_request(device.api.set_power, packet)
except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err)
return False
@ -242,10 +246,10 @@ class BroadlinkMP1Slot(BroadlinkSwitch):
async def _async_send_packet(self, packet):
"""Send a packet to the device."""
device = self._device
try:
await self._device.async_request(
self._device.api.set_power, self._slot, packet
)
await device.async_request(device.api.set_power, self._slot, packet)
except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err)
return False
@ -273,9 +277,11 @@ class BroadlinkBG1Slot(BroadlinkSwitch):
async def _async_send_packet(self, packet):
"""Send a packet to the device."""
device = self._device
state = {f"pwr{self._slot}": packet}
try:
await self._device.async_request(self._device.api.set_state, **state)
await device.async_request(device.api.set_state, **state)
except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err)
return False