device.py 19 KB

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