device.py 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656
  1. """Library to handle connection with Switchbot."""
  2. from __future__ import annotations
  3. import asyncio
  4. import binascii
  5. import logging
  6. import time
  7. from dataclasses import replace
  8. from enum import Enum
  9. from typing import Any, Callable, TypeVar, cast
  10. from uuid import UUID
  11. import async_timeout
  12. from bleak import BleakError
  13. from bleak.backends.device import BLEDevice
  14. from bleak.backends.service import BleakGATTCharacteristic, BleakGATTServiceCollection
  15. from bleak.exc import BleakDBusError
  16. from bleak_retry_connector import (
  17. BLEAK_RETRY_EXCEPTIONS,
  18. BleakClientWithServiceCache,
  19. BleakNotFoundError,
  20. ble_device_has_changed,
  21. establish_connection,
  22. )
  23. from ..const import DEFAULT_RETRY_COUNT, DEFAULT_SCAN_TIMEOUT
  24. from ..discovery import GetSwitchbotDevices
  25. from ..models import SwitchBotAdvertisement
  26. _LOGGER = logging.getLogger(__name__)
  27. REQ_HEADER = "570f"
  28. # Keys common to all device types
  29. DEVICE_GET_BASIC_SETTINGS_KEY = "5702"
  30. DEVICE_SET_MODE_KEY = "5703"
  31. DEVICE_SET_EXTENDED_KEY = REQ_HEADER
  32. # Base key when encryption is set
  33. KEY_PASSWORD_PREFIX = "571"
  34. # How long to hold the connection
  35. # to wait for additional commands for
  36. # disconnecting the device.
  37. DISCONNECT_DELAY = 8.5
  38. class ColorMode(Enum):
  39. OFF = 0
  40. COLOR_TEMP = 1
  41. RGB = 2
  42. EFFECT = 3
  43. # If the scanner is in passive mode, we
  44. # need to poll the device to get the
  45. # battery and a few rarely updating
  46. # values.
  47. PASSIVE_POLL_INTERVAL = 60 * 60 * 24
  48. class CharacteristicMissingError(Exception):
  49. """Raised when a characteristic is missing."""
  50. class SwitchbotOperationError(Exception):
  51. """Raised when an operation fails."""
  52. def _sb_uuid(comms_type: str = "service") -> UUID | str:
  53. """Return Switchbot UUID."""
  54. _uuid = {"tx": "002", "rx": "003", "service": "d00"}
  55. if comms_type in _uuid:
  56. return UUID(f"cba20{_uuid[comms_type]}-224d-11e6-9fb8-0002a5d5c51b")
  57. return "Incorrect type, choose between: tx, rx or service"
  58. READ_CHAR_UUID = _sb_uuid(comms_type="rx")
  59. WRITE_CHAR_UUID = _sb_uuid(comms_type="tx")
  60. WrapFuncType = TypeVar("WrapFuncType", bound=Callable[..., Any])
  61. def update_after_operation(func: WrapFuncType) -> WrapFuncType:
  62. """Define a wrapper to update after an operation."""
  63. async def _async_update_after_operation_wrap(
  64. self: SwitchbotBaseDevice, *args: Any, **kwargs: Any
  65. ) -> None:
  66. ret = await func(self, *args, **kwargs)
  67. await self.update()
  68. return ret
  69. return cast(WrapFuncType, _async_update_after_operation_wrap)
  70. def _merge_data(old_data: dict[str, Any], new_data: dict[str, Any]) -> dict[str, Any]:
  71. """Merge data but only add None keys if they are missing."""
  72. merged = old_data.copy()
  73. for key, value in new_data.items():
  74. if value is not None or key not in old_data:
  75. merged[key] = value
  76. return merged
  77. class SwitchbotBaseDevice:
  78. """Base Representation of a Switchbot Device."""
  79. def __init__(
  80. self,
  81. device: BLEDevice,
  82. password: str | None = None,
  83. interface: int = 0,
  84. **kwargs: Any,
  85. ) -> None:
  86. """Switchbot base class constructor."""
  87. self._interface = f"hci{interface}"
  88. self._device = device
  89. self._sb_adv_data: SwitchBotAdvertisement | None = None
  90. self._override_adv_data: dict[str, Any] | None = None
  91. self._scan_timeout: int = kwargs.pop("scan_timeout", DEFAULT_SCAN_TIMEOUT)
  92. self._retry_count: int = kwargs.pop("retry_count", DEFAULT_RETRY_COUNT)
  93. self._connect_lock = asyncio.Lock()
  94. self._operation_lock = asyncio.Lock()
  95. if password is None or password == "":
  96. self._password_encoded = None
  97. else:
  98. self._password_encoded = "%08x" % (
  99. binascii.crc32(password.encode("ascii")) & 0xFFFFFFFF
  100. )
  101. self._client: BleakClientWithServiceCache | None = None
  102. self._read_char: BleakGATTCharacteristic | None = None
  103. self._write_char: BleakGATTCharacteristic | None = None
  104. self._disconnect_timer: asyncio.TimerHandle | None = None
  105. self._expected_disconnect = False
  106. self.loop = asyncio.get_event_loop()
  107. self._callbacks: list[Callable[[], None]] = []
  108. self._notify_future: asyncio.Future[bytearray] | None = None
  109. self._last_full_update: float = -PASSIVE_POLL_INTERVAL
  110. def advertisement_changed(self, advertisement: SwitchBotAdvertisement) -> bool:
  111. """Check if the advertisement has changed."""
  112. return bool(
  113. not self._sb_adv_data
  114. or ble_device_has_changed(self._sb_adv_data.device, advertisement.device)
  115. or advertisement.data != self._sb_adv_data.data
  116. )
  117. def _commandkey(self, key: str) -> str:
  118. """Add password to key if set."""
  119. if self._password_encoded is None:
  120. return key
  121. key_action = key[3]
  122. key_suffix = key[4:]
  123. return KEY_PASSWORD_PREFIX + key_action + self._password_encoded + key_suffix
  124. async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
  125. """Send command to device and read response."""
  126. if retry is None:
  127. retry = self._retry_count
  128. command = bytearray.fromhex(self._commandkey(key))
  129. _LOGGER.debug("%s: Scheduling command %s", self.name, command.hex())
  130. max_attempts = retry + 1
  131. if self._operation_lock.locked():
  132. _LOGGER.debug(
  133. "%s: Operation already in progress, waiting for it to complete; RSSI: %s",
  134. self.name,
  135. self.rssi,
  136. )
  137. async with self._operation_lock:
  138. for attempt in range(max_attempts):
  139. try:
  140. return await self._send_command_locked(key, command)
  141. except BleakNotFoundError:
  142. _LOGGER.error(
  143. "%s: device not found, no longer in range, or poor RSSI: %s",
  144. self.name,
  145. self.rssi,
  146. exc_info=True,
  147. )
  148. raise
  149. except CharacteristicMissingError as ex:
  150. if attempt == retry:
  151. _LOGGER.error(
  152. "%s: characteristic missing: %s; Stopping trying; RSSI: %s",
  153. self.name,
  154. ex,
  155. self.rssi,
  156. exc_info=True,
  157. )
  158. raise
  159. _LOGGER.debug(
  160. "%s: characteristic missing: %s; RSSI: %s",
  161. self.name,
  162. ex,
  163. self.rssi,
  164. exc_info=True,
  165. )
  166. except BLEAK_RETRY_EXCEPTIONS:
  167. if attempt == retry:
  168. _LOGGER.error(
  169. "%s: communication failed; Stopping trying; RSSI: %s",
  170. self.name,
  171. self.rssi,
  172. exc_info=True,
  173. )
  174. raise
  175. _LOGGER.debug(
  176. "%s: communication failed with:", self.name, exc_info=True
  177. )
  178. raise RuntimeError("Unreachable")
  179. @property
  180. def name(self) -> str:
  181. """Return device name."""
  182. return f"{self._device.name} ({self._device.address})"
  183. @property
  184. def data(self) -> dict[str, Any]:
  185. """Return device data."""
  186. if self._sb_adv_data:
  187. return self._sb_adv_data.data
  188. return {}
  189. @property
  190. def parsed_data(self) -> dict[str, Any]:
  191. """Return parsed device data."""
  192. return self.data.get("data") or {}
  193. @property
  194. def rssi(self) -> int:
  195. """Return RSSI of device."""
  196. if self._sb_adv_data:
  197. return self._sb_adv_data.rssi
  198. return self._device.rssi
  199. async def _ensure_connected(self):
  200. """Ensure connection to device is established."""
  201. if self._connect_lock.locked():
  202. _LOGGER.debug(
  203. "%s: Connection already in progress, waiting for it to complete; RSSI: %s",
  204. self.name,
  205. self.rssi,
  206. )
  207. if self._client and self._client.is_connected:
  208. self._reset_disconnect_timer()
  209. return
  210. async with self._connect_lock:
  211. # Check again while holding the lock
  212. if self._client and self._client.is_connected:
  213. self._reset_disconnect_timer()
  214. return
  215. _LOGGER.debug("%s: Connecting; RSSI: %s", self.name, self.rssi)
  216. client: BleakClientWithServiceCache = await establish_connection(
  217. BleakClientWithServiceCache,
  218. self._device,
  219. self.name,
  220. self._disconnected,
  221. use_services_cache=True,
  222. ble_device_callback=lambda: self._device,
  223. )
  224. _LOGGER.debug("%s: Connected; RSSI: %s", self.name, self.rssi)
  225. self._client = client
  226. try:
  227. self._resolve_characteristics(client.services)
  228. except CharacteristicMissingError as ex:
  229. _LOGGER.debug(
  230. "%s: characteristic missing, clearing cache: %s; RSSI: %s",
  231. self.name,
  232. ex,
  233. self.rssi,
  234. exc_info=True,
  235. )
  236. await client.clear_cache()
  237. self._cancel_disconnect_timer()
  238. await self._execute_disconnect_with_lock()
  239. raise
  240. self._reset_disconnect_timer()
  241. await self._start_notify()
  242. def _resolve_characteristics(self, services: BleakGATTServiceCollection) -> None:
  243. """Resolve characteristics."""
  244. self._read_char = services.get_characteristic(READ_CHAR_UUID)
  245. if not self._read_char:
  246. raise CharacteristicMissingError(READ_CHAR_UUID)
  247. self._write_char = services.get_characteristic(WRITE_CHAR_UUID)
  248. if not self._write_char:
  249. raise CharacteristicMissingError(WRITE_CHAR_UUID)
  250. def _reset_disconnect_timer(self):
  251. """Reset disconnect timer."""
  252. self._cancel_disconnect_timer()
  253. self._expected_disconnect = False
  254. self._disconnect_timer = self.loop.call_later(
  255. DISCONNECT_DELAY, self._disconnect_from_timer
  256. )
  257. def _disconnected(self, client: BleakClientWithServiceCache) -> None:
  258. """Disconnected callback."""
  259. if self._expected_disconnect:
  260. _LOGGER.debug(
  261. "%s: Disconnected from device; RSSI: %s", self.name, self.rssi
  262. )
  263. return
  264. _LOGGER.warning(
  265. "%s: Device unexpectedly disconnected; RSSI: %s",
  266. self.name,
  267. self.rssi,
  268. )
  269. def _disconnect_from_timer(self):
  270. """Disconnect from device."""
  271. if self._operation_lock.locked() and self._client.is_connected:
  272. _LOGGER.debug(
  273. "%s: Operation in progress, resetting disconnect timer; RSSI: %s",
  274. self.name,
  275. self.rssi,
  276. )
  277. self._reset_disconnect_timer()
  278. return
  279. self._cancel_disconnect_timer()
  280. asyncio.create_task(self._execute_timed_disconnect())
  281. def _cancel_disconnect_timer(self):
  282. """Cancel disconnect timer."""
  283. if self._disconnect_timer:
  284. self._disconnect_timer.cancel()
  285. self._disconnect_timer = None
  286. async def _execute_forced_disconnect(self) -> None:
  287. """Execute forced disconnection."""
  288. self._cancel_disconnect_timer()
  289. _LOGGER.debug(
  290. "%s: Executing forced disconnect",
  291. self.name,
  292. )
  293. await self._execute_disconnect()
  294. async def _execute_timed_disconnect(self) -> None:
  295. """Execute timed disconnection."""
  296. _LOGGER.debug(
  297. "%s: Executing timed disconnect after timeout of %s",
  298. self.name,
  299. DISCONNECT_DELAY,
  300. )
  301. await self._execute_disconnect()
  302. async def _execute_disconnect(self) -> None:
  303. """Execute disconnection."""
  304. _LOGGER.debug("%s: Executing disconnect", self.name)
  305. async with self._connect_lock:
  306. await self._execute_disconnect_with_lock()
  307. async def _execute_disconnect_with_lock(self) -> None:
  308. """Execute disconnection while holding the lock."""
  309. assert self._connect_lock.locked(), "Lock not held"
  310. _LOGGER.debug("%s: Executing disconnect with lock", self.name)
  311. if self._disconnect_timer: # If the timer was reset, don't disconnect
  312. _LOGGER.debug("%s: Skipping disconnect as timer reset", self.name)
  313. return
  314. client = self._client
  315. self._expected_disconnect = True
  316. self._client = None
  317. self._read_char = None
  318. self._write_char = None
  319. if client and client.is_connected:
  320. _LOGGER.debug("%s: Disconnecting", self.name)
  321. await client.disconnect()
  322. _LOGGER.debug("%s: Disconnect completed", self.name)
  323. else:
  324. _LOGGER.debug("%s: Already disconnected", self.name)
  325. async def _send_command_locked(self, key: str, command: bytes) -> bytes:
  326. """Send command to device and read response."""
  327. await self._ensure_connected()
  328. try:
  329. return await self._execute_command_locked(key, command)
  330. except BleakDBusError as ex:
  331. # Disconnect so we can reset state and try again
  332. await asyncio.sleep(0.25)
  333. _LOGGER.debug(
  334. "%s: RSSI: %s; Backing off %ss; Disconnecting due to error: %s",
  335. self.name,
  336. self.rssi,
  337. 0.25,
  338. ex,
  339. )
  340. await self._execute_forced_disconnect()
  341. raise
  342. except BleakError as ex:
  343. # Disconnect so we can reset state and try again
  344. _LOGGER.debug(
  345. "%s: RSSI: %s; Disconnecting due to error: %s", self.name, self.rssi, ex
  346. )
  347. await self._execute_forced_disconnect()
  348. raise
  349. def _notification_handler(self, _sender: int, data: bytearray) -> None:
  350. """Handle notification responses."""
  351. if self._notify_future and not self._notify_future.done():
  352. self._notify_future.set_result(data)
  353. return
  354. _LOGGER.debug("%s: Received unsolicited notification: %s", self.name, data)
  355. async def _start_notify(self) -> None:
  356. """Start notification."""
  357. _LOGGER.debug("%s: Subscribe to notifications; RSSI: %s", self.name, self.rssi)
  358. await self._client.start_notify(self._read_char, self._notification_handler)
  359. async def _execute_command_locked(self, key: str, command: bytes) -> bytes:
  360. """Execute command and read response."""
  361. assert self._client is not None
  362. assert self._read_char is not None
  363. assert self._write_char is not None
  364. self._notify_future = asyncio.Future()
  365. client = self._client
  366. _LOGGER.debug("%s: Sending command: %s", self.name, key)
  367. await client.write_gatt_char(self._write_char, command, False)
  368. async with async_timeout.timeout(5):
  369. notify_msg = await self._notify_future
  370. _LOGGER.debug("%s: Notification received: %s", self.name, notify_msg.hex())
  371. self._notify_future = None
  372. if notify_msg == b"\x07":
  373. _LOGGER.error("Password required")
  374. elif notify_msg == b"\t":
  375. _LOGGER.error("Password incorrect")
  376. return notify_msg
  377. def get_address(self) -> str:
  378. """Return address of device."""
  379. return self._device.address
  380. def _override_state(self, state: dict[str, Any]) -> None:
  381. """Override device state."""
  382. if self._override_adv_data is None:
  383. self._override_adv_data = {}
  384. self._override_adv_data.update(state)
  385. self._update_parsed_data(state)
  386. def _get_adv_value(self, key: str) -> Any:
  387. """Return value from advertisement data."""
  388. if self._override_adv_data and key in self._override_adv_data:
  389. _LOGGER.debug(
  390. "%s: Using override value for %s: %s",
  391. self.name,
  392. key,
  393. self._override_adv_data[key],
  394. )
  395. return self._override_adv_data[key]
  396. if not self._sb_adv_data:
  397. return None
  398. return self._sb_adv_data.data["data"].get(key)
  399. def get_battery_percent(self) -> Any:
  400. """Return device battery level in percent."""
  401. return self._get_adv_value("battery")
  402. def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
  403. """Update device data from advertisement."""
  404. # Only accept advertisements if the data is not missing
  405. # if we already have an advertisement with data
  406. self._device = advertisement.device
  407. async def get_device_data(
  408. self, retry: int | None = None, interface: int | None = None
  409. ) -> SwitchBotAdvertisement | None:
  410. """Find switchbot devices and their advertisement data."""
  411. if retry is None:
  412. retry = self._retry_count
  413. if interface:
  414. _interface: int = interface
  415. else:
  416. _interface = int(self._interface.replace("hci", ""))
  417. _data = await GetSwitchbotDevices(interface=_interface).discover(
  418. retry=retry, scan_timeout=self._scan_timeout
  419. )
  420. if self._device.address in _data:
  421. self._sb_adv_data = _data[self._device.address]
  422. return self._sb_adv_data
  423. async def _get_basic_info(self) -> bytes | None:
  424. """Return basic info of device."""
  425. _data = await self._send_command(
  426. key=DEVICE_GET_BASIC_SETTINGS_KEY, retry=self._retry_count
  427. )
  428. if _data in (b"\x07", b"\x00"):
  429. _LOGGER.error("Unsuccessful, please try again")
  430. return None
  431. return _data
  432. def _fire_callbacks(self) -> None:
  433. """Fire callbacks."""
  434. _LOGGER.debug("%s: Fire callbacks", self.name)
  435. for callback in self._callbacks:
  436. callback()
  437. def subscribe(self, callback: Callable[[], None]) -> Callable[[], None]:
  438. """Subscribe to device notifications."""
  439. self._callbacks.append(callback)
  440. def _unsub() -> None:
  441. """Unsubscribe from device notifications."""
  442. self._callbacks.remove(callback)
  443. return _unsub
  444. async def update(self, interface: int | None = None) -> None:
  445. """Update position, battery percent and light level of device."""
  446. if info := await self.get_basic_info():
  447. self._last_full_update = time.monotonic()
  448. self._update_parsed_data(info)
  449. self._fire_callbacks()
  450. async def get_basic_info(self) -> dict[str, Any] | None:
  451. """Get device basic settings."""
  452. if not (_data := await self._get_basic_info()):
  453. return None
  454. return {
  455. "battery": _data[1],
  456. "firmware": _data[2] / 10.0,
  457. }
  458. def _check_command_result(
  459. self, result: bytes | None, index: int, values: set[int]
  460. ) -> bool:
  461. """Check command result."""
  462. if not result or len(result) - 1 < index:
  463. result_hex = result.hex() if result else "None"
  464. raise SwitchbotOperationError(
  465. f"{self.name}: Sending command failed (result={result_hex} index={index} expected={values} rssi={self.rssi})"
  466. )
  467. return result[index] in values
  468. def _update_parsed_data(self, new_data: dict[str, Any]) -> None:
  469. """Update data."""
  470. if not self._sb_adv_data:
  471. _LOGGER.exception("No advertisement data to update")
  472. return
  473. self._set_parsed_data(
  474. self._sb_adv_data,
  475. _merge_data(self._sb_adv_data.data.get("data") or {}, new_data),
  476. )
  477. def _set_parsed_data(
  478. self, advertisement: SwitchBotAdvertisement, data: dict[str, Any]
  479. ) -> None:
  480. """Set data."""
  481. self._sb_adv_data = replace(
  482. advertisement, data=self._sb_adv_data.data | {"data": data}
  483. )
  484. def _set_advertisement_data(self, advertisement: SwitchBotAdvertisement) -> None:
  485. """Set advertisement data."""
  486. new_data = advertisement.data.get("data") or {}
  487. if advertisement.active:
  488. # If we are getting active data, we can assume we are
  489. # getting active scans and we do not need to poll
  490. self._last_full_update = time.monotonic()
  491. if not self._sb_adv_data:
  492. self._sb_adv_data = advertisement
  493. elif new_data:
  494. self._update_parsed_data(new_data)
  495. self._override_adv_data = None
  496. def switch_mode(self) -> bool | None:
  497. """Return true or false from cache."""
  498. # To get actual position call update() first.
  499. return self._get_adv_value("switchMode")
  500. def poll_needed(self, seconds_since_last_poll: float | None) -> bool:
  501. """Return if device needs polling."""
  502. if (
  503. seconds_since_last_poll is not None
  504. and seconds_since_last_poll < PASSIVE_POLL_INTERVAL
  505. ):
  506. return False
  507. time_since_last_full_update = time.monotonic() - self._last_full_update
  508. if time_since_last_full_update < PASSIVE_POLL_INTERVAL:
  509. return False
  510. return True
  511. class SwitchbotDevice(SwitchbotBaseDevice):
  512. """Base Representation of a Switchbot Device.
  513. This base class consumes the advertisement data during connection. If the device
  514. sends stale advertisement data while connected, use
  515. SwitchbotDeviceOverrideStateDuringConnection instead.
  516. """
  517. def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
  518. """Update device data from advertisement."""
  519. super().update_from_advertisement(advertisement)
  520. self._set_advertisement_data(advertisement)
  521. class SwitchbotDeviceOverrideStateDuringConnection(SwitchbotBaseDevice):
  522. """Base Representation of a Switchbot Device.
  523. This base class ignores the advertisement data during connection and uses the
  524. data from the device instead.
  525. """
  526. def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
  527. super().update_from_advertisement(advertisement)
  528. if self._client and self._client.is_connected:
  529. # We do not consume the advertisement data if we are connected
  530. # to the device. This is because the advertisement data is not
  531. # updated when the device is connected for some devices.
  532. _LOGGER.debug("%s: Ignore advertisement data during connection", self.name)
  533. return
  534. self._set_advertisement_data(advertisement)
  535. class SwitchbotSequenceDevice(SwitchbotDevice):
  536. """A Switchbot sequence device.
  537. This class must not use SwitchbotDeviceOverrideStateDuringConnection because
  538. it needs to know when the sequence_number has changed.
  539. """
  540. def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
  541. """Update device data from advertisement."""
  542. current_state = self._get_adv_value("sequence_number")
  543. super().update_from_advertisement(advertisement)
  544. new_state = self._get_adv_value("sequence_number")
  545. _LOGGER.debug(
  546. "%s: update advertisement: %s (seq before: %s) (seq after: %s)",
  547. self.name,
  548. advertisement,
  549. current_state,
  550. new_state,
  551. )
  552. if current_state != new_state:
  553. asyncio.ensure_future(self.update())