Daniel Moindrot
9047b75ce6
- Add TransferResult enum (SUCCESS, SENT, SERVER_ERROR, NETWORK_ERROR) to distinguish network errors from server errors - Only mark entities as unavailable on NETWORK_ERROR (addon unreachable) - HTTP 401, 405, 500 no longer trigger unavailable state, logged instead - Add RestoreEntity to cover, switch and light to restore last known state after HA restart
302 lines
10 KiB
Python
302 lines
10 KiB
Python
"""AirSend device."""
|
|
import logging
|
|
import json
|
|
import hashlib
|
|
import aiohttp
|
|
from . import DOMAIN
|
|
|
|
_LOGGER = logging.getLogger(DOMAIN)
|
|
|
|
RTYPE_LABELS = {
|
|
0: "AirSend",
|
|
1: "AirSend Sensor",
|
|
4096: "AirSend Button",
|
|
4097: "AirSend Switch",
|
|
4098: "AirSend Cover",
|
|
4099: "AirSend Cover (position)",
|
|
4100: "AirSend Light",
|
|
}
|
|
|
|
|
|
from enum import Enum
|
|
|
|
|
|
class TransferResult(Enum):
|
|
"""Result of an async_transfer call."""
|
|
SUCCESS = "success" # Command sent and confirmed
|
|
SENT = "sent" # Command sent, no confirmation (wait=True + 500)
|
|
SERVER_ERROR = "server_error" # Server responded with error (command may have been sent)
|
|
NETWORK_ERROR = "network_error" # Addon unreachable (timeout, connection refused)
|
|
|
|
|
|
class Device:
|
|
"""Representation of a Device."""
|
|
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
options,
|
|
serviceurl: str,
|
|
) -> None:
|
|
"""Initialize a device."""
|
|
self._name = name
|
|
self._serviceurl = serviceurl
|
|
self._uid = None
|
|
self._rtype = None
|
|
self._apikey = None
|
|
self._spurl = None
|
|
self._wait = False
|
|
self._channel = {}
|
|
self._note = None
|
|
self._bind = None
|
|
self._refresh = 5 * 60
|
|
try:
|
|
self._uid = options["id"]
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._rtype = options["type"]
|
|
except KeyError:
|
|
pass
|
|
if self._rtype == 0:
|
|
self._channel = {"id": 1}
|
|
try:
|
|
self._apikey = options["apiKey"]
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._spurl = options["spurl"]
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._wait = eval(str(options["wait"]))
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._channel = options["channel"]
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._note = options["note"]
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._bind = int(options["bind"])
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
self._refresh = int(options["refresh"])
|
|
except KeyError:
|
|
pass
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Return the name."""
|
|
return self._name
|
|
|
|
@property
|
|
def unique_channel_name(self) -> str:
|
|
if self._uid:
|
|
return str(self._uid)
|
|
if self._channel:
|
|
result = str(self._channel['id'])
|
|
if result:
|
|
uniquefield = ['source', 'mac', 'seed']
|
|
for field in uniquefield:
|
|
if field in self._channel:
|
|
result += "_"
|
|
result += str(self._channel[field])
|
|
return result
|
|
return self._name
|
|
|
|
@property
|
|
def device_info(self) -> dict:
|
|
"""Return device info for Home Assistant device registry."""
|
|
return {
|
|
"identifiers": {(DOMAIN, self.unique_channel_name)},
|
|
"name": self._name,
|
|
"manufacturer": "AirSend",
|
|
"model": RTYPE_LABELS.get(self._rtype, "AirSend"),
|
|
}
|
|
|
|
@property
|
|
def extra_state_attributes(self):
|
|
if self._channel:
|
|
return {"channel": self._channel}
|
|
return None
|
|
|
|
@property
|
|
def is_async(self) -> bool:
|
|
"""Return if asynchronous state."""
|
|
return self._wait == False
|
|
|
|
@property
|
|
def is_airsend(self) -> bool:
|
|
return self._rtype == 0
|
|
|
|
@property
|
|
def is_sensor(self) -> bool:
|
|
return self._rtype == 1
|
|
|
|
@property
|
|
def is_button(self) -> bool:
|
|
return self._rtype == 4096
|
|
|
|
@property
|
|
def is_cover(self) -> bool:
|
|
return self._rtype in (4098, 4099)
|
|
|
|
@property
|
|
def is_cover_with_position(self) -> bool:
|
|
return self._rtype == 4099
|
|
|
|
@property
|
|
def is_switch(self) -> bool:
|
|
return self._rtype == 4097
|
|
|
|
@property
|
|
def is_light(self) -> bool:
|
|
return self._rtype == 4100
|
|
|
|
@property
|
|
def refresh_value(self) -> int:
|
|
"""Return refresh value in seconds."""
|
|
if isinstance(self._refresh, int) and self._refresh > 0:
|
|
return self._refresh
|
|
return 5 * 60
|
|
|
|
async def async_bind(self) -> bool:
|
|
"""Bind a channel to listen (async)."""
|
|
if not (self._serviceurl and self._spurl and isinstance(self._bind, int) and self._bind > 0):
|
|
return False
|
|
payload = json.dumps({
|
|
"channel": {"id": self._bind},
|
|
"duration": 0,
|
|
"callback": "http://127.0.0.1/"
|
|
})
|
|
headers = {
|
|
"Authorization": "Bearer " + self._spurl,
|
|
"content-type": "application/json",
|
|
"User-Agent": "hass_airsend",
|
|
}
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post(
|
|
self._serviceurl + "airsend/bind",
|
|
headers=headers,
|
|
data=payload,
|
|
timeout=aiohttp.ClientTimeout(total=6),
|
|
) as response:
|
|
return response.status == 200
|
|
except aiohttp.ClientError as err:
|
|
_LOGGER.debug("Bind error '%s': %s", self._name, err)
|
|
return False
|
|
|
|
async def async_transfer(self, note, entity_id=None) -> "TransferResult":
|
|
"""Send a command (async)."""
|
|
status_code = 404
|
|
ret = False
|
|
wait = 'false, "callback":"http://127.0.0.1/"'
|
|
if self._wait:
|
|
wait = 'true'
|
|
|
|
if self._serviceurl and self._spurl and entity_id is not None:
|
|
uid = hashlib.sha256(entity_id.encode('utf-8')).hexdigest()[:12]
|
|
jnote = json.dumps(note)
|
|
if (
|
|
self._note is not None
|
|
and all(k in self._note for k in ("method", "type", "value"))
|
|
and all(k in note for k in ("method", "type", "value"))
|
|
and note["method"] == 1 and note["type"] == 0
|
|
and note["value"] in ("TOGGLE", 6)
|
|
):
|
|
jnote = json.dumps(self._note)
|
|
|
|
payload = (
|
|
'{"wait": ' + wait + ', "channel":'
|
|
+ json.dumps(self._channel)
|
|
+ ', "thingnotes":{"uid":"0x' + uid + '", "notes":['
|
|
+ jnote
|
|
+ "]}}"
|
|
)
|
|
headers = {
|
|
"Authorization": "Bearer " + self._spurl,
|
|
"content-type": "application/json",
|
|
"User-Agent": "hass_airsend",
|
|
}
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post(
|
|
self._serviceurl + "airsend/transfer",
|
|
headers=headers,
|
|
data=payload,
|
|
timeout=aiohttp.ClientTimeout(total=6),
|
|
) as response:
|
|
if self._wait:
|
|
ret = True
|
|
status_code = 500
|
|
try:
|
|
jdata = await response.json(content_type=None)
|
|
if jdata.get("type", 0x100) < 0x100:
|
|
status_code = response.status
|
|
except Exception:
|
|
pass
|
|
else:
|
|
ret = None
|
|
status_code = response.status
|
|
except aiohttp.ClientError as err:
|
|
_LOGGER.debug("Transfer local error '%s': %s", self._name, err)
|
|
return TransferResult.NETWORK_ERROR
|
|
|
|
# Fallback to cloud API if local failed
|
|
if status_code != 200 and self._apikey:
|
|
action = "command"
|
|
value = 6
|
|
if all(k in note for k in ("method", "type", "value")):
|
|
if note["method"] == 1 and note["type"] == 0:
|
|
value = {
|
|
"OFF": 0, "ON": 1, "STOP": 3, "DOWN": 4, "UP": 5
|
|
}.get(note["value"], 6)
|
|
elif note["method"] == 1 and note["type"] == 9:
|
|
action = "level"
|
|
value = int(note["value"])
|
|
|
|
cloud_url = (
|
|
"https://airsend.cloud/device/"
|
|
+ str(self._uid) + "/" + action + "/" + str(value) + "/"
|
|
)
|
|
headers = {
|
|
"Authorization": "Bearer " + self._apikey,
|
|
"content-type": "application/json",
|
|
"User-Agent": "hass_airsend",
|
|
}
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.get(
|
|
cloud_url,
|
|
headers=headers,
|
|
timeout=aiohttp.ClientTimeout(total=10),
|
|
) as response:
|
|
status_code = response.status
|
|
ret = True
|
|
except aiohttp.ClientError as err:
|
|
_LOGGER.warning("Transfer cloud error '%s': %s — both local and cloud failed", self._name, err)
|
|
return TransferResult.NETWORK_ERROR
|
|
|
|
if status_code == 200:
|
|
return TransferResult.SUCCESS
|
|
if status_code == 401:
|
|
_LOGGER.error("Transfer '%s' : invalid locator (401) — check spurl in airsend.yaml", self.name)
|
|
return TransferResult.SERVER_ERROR
|
|
if status_code == 405:
|
|
_LOGGER.error("Transfer '%s' : invalid input (405) — check channel configuration", self.name)
|
|
return TransferResult.SERVER_ERROR
|
|
if status_code == 500:
|
|
if self._wait:
|
|
_LOGGER.warning("Transfer '%s' : no RF confirmation (500), command may have been sent", self.name)
|
|
return TransferResult.SENT
|
|
_LOGGER.warning("Transfer '%s' : server error (500), command may have been sent", self.name)
|
|
return TransferResult.SERVER_ERROR
|
|
_LOGGER.warning("Transfer '%s' : unexpected status %s", self.name, status_code)
|
|
return TransferResult.SERVER_ERROR
|