Restore remote discovered devices between remote scanner restarts

homeassistant/components/bluetooth/__init__.py

@@ -71,9 +71,14 @@
 )
 from .manager import BluetoothManager
 from .match import BluetoothCallbackMatcher, IntegrationMatcher
-from .models import BluetoothCallback, BluetoothChange, BluetoothScanningMode
+from .models import (
+    BluetoothCallback,
+    BluetoothChange,
+    BluetoothScanningMode,
+    HaBluetoothConnector,
+)
 from .scanner import HaScanner, ScannerStartError
-from .wrappers import HaBluetoothConnector
+from .storage import BluetoothStorage
 
 if TYPE_CHECKING:
     from homeassistant.helpers.typing import ConfigType
@@ -158,7 +163,11 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     integration_matcher = IntegrationMatcher(await async_get_bluetooth(hass))
     integration_matcher.async_setup()
     bluetooth_adapters = get_adapters()
-    manager = BluetoothManager(hass, integration_matcher, bluetooth_adapters)
+    bluetooth_storage = BluetoothStorage(hass)
+    await bluetooth_storage.async_setup()
+    manager = BluetoothManager(
+        hass, integration_matcher, bluetooth_adapters, bluetooth_storage
+    )
     await manager.async_setup()
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, manager.async_stop)
     hass.data[DATA_MANAGER] = models.MANAGER = manager

homeassistant/components/bluetooth/base_scanner.py

@@ -14,28 +14,47 @@
 from bluetooth_adapters import adapter_human_name
 from home_assistant_bluetooth import BluetoothServiceInfoBleak
 
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback as hass_callback
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
+from homeassistant.core import (
+    CALLBACK_TYPE,
+    Event,
+    HomeAssistant,
+    callback as hass_callback,
+)
 from homeassistant.helpers.event import async_track_time_interval
+import homeassistant.util.dt as dt_util
 from homeassistant.util.dt import monotonic_time_coarse
 
+from . import models
 from .const import (
     CONNECTABLE_FALLBACK_MAXIMUM_STALE_ADVERTISEMENT_SECONDS,
     FALLBACK_MAXIMUM_STALE_ADVERTISEMENT_SECONDS,
 )
 from .models import HaBluetoothConnector
 
+REMOTE_SCANNER_STORAGE_VERSION = 1
 MONOTONIC_TIME: Final = monotonic_time_coarse
 
 
 class BaseHaScanner(ABC):
     """Base class for Ha Scanners."""
 
-    __slots__ = ("hass", "source", "_connecting", "name", "scanning")
+    __slots__ = (
+        "hass",
+        "connectable",
+        "source",
+        "connector",
+        "_connecting",
+        "name",
+        "scanning",
+    )
 
     def __init__(self, hass: HomeAssistant, source: str, adapter: str) -> None:
         """Initialize the scanner."""
         self.hass = hass
+        self.connectable = False
         self.source = source
+        self.connector: HaBluetoothConnector | None = None
         self._connecting = 0
         self.name = adapter_human_name(adapter, source) if adapter != source else source
         self.scanning = True
@@ -87,10 +106,9 @@ class BaseHaRemoteScanner(BaseHaScanner):
         "_new_info_callback",
         "_discovered_device_advertisement_datas",
         "_discovered_device_timestamps",
-        "_connector",
-        "_connectable",
         "_details",
         "_expire_seconds",
+        "_storage",
     )
 
     def __init__(
@@ -109,22 +127,52 @@ def __init__(
             str, tuple[BLEDevice, AdvertisementData]
         ] = {}
         self._discovered_device_timestamps: dict[str, float] = {}
-        self._connector = connector
-        self._connectable = connectable
+        self.connectable = connectable
+        self.connector = connector
         self._details: dict[str, str | HaBluetoothConnector] = {"source": scanner_id}
         self._expire_seconds = FALLBACK_MAXIMUM_STALE_ADVERTISEMENT_SECONDS
+        assert models.MANAGER is not None
+        self._storage = models.MANAGER.storage
         if connectable:
-            self._details["connector"] = connector
             self._expire_seconds = (
                 CONNECTABLE_FALLBACK_MAXIMUM_STALE_ADVERTISEMENT_SECONDS
             )
 
     @hass_callback
     def async_setup(self) -> CALLBACK_TYPE:
         """Set up the scanner."""
-        return async_track_time_interval(
+        if history := self._storage.async_get_advertisement_history(self.source):
+            self._discovered_device_advertisement_datas = (
+                history.discovered_device_advertisement_datas
+            )
+            self._discovered_device_timestamps = history.discovered_device_timestamps
+            # Expire anything that is too old
+            self._async_expire_devices(dt_util.utcnow())
+
+        cancel_track = async_track_time_interval(
             self.hass, self._async_expire_devices, timedelta(seconds=30)
         )
+        cancel_stop = self.hass.bus.async_listen(
+            EVENT_HOMEASSISTANT_STOP, self._save_history
+        )
+
+        @hass_callback
+        def _cancel() -> None:
+            self._save_history()
+            cancel_track()
+            cancel_stop()
+
+        return _cancel
+
+    def _save_history(self, event: Event | None = None) -> None:
+        """Save the history."""
+        self._storage.async_set_advertisement_history(
+            self.source,
+            self.connectable,
+            self._expire_seconds,
+            self._discovered_device_advertisement_datas,
+            self._discovered_device_timestamps,
+        )
 
     def _async_expire_devices(self, _datetime: datetime.datetime) -> None:
         """Expire old devices."""
@@ -222,7 +270,7 @@ def _async_on_advertisement(
                 source=self.source,
                 device=device,
                 advertisement=advertisement_data,
-                connectable=self._connectable,
+                connectable=self.connectable,
                 time=now,
             )
         )

homeassistant/components/bluetooth/manager.py

@@ -45,6 +45,7 @@
     ble_device_matches,
 )
 from .models import BluetoothCallback, BluetoothChange, BluetoothServiceInfoBleak
+from .storage import BluetoothStorage
 from .usage import install_multiple_bleak_catcher, uninstall_multiple_bleak_catcher
 from .util import async_load_history_from_system
 
@@ -102,6 +103,7 @@ def __init__(
         hass: HomeAssistant,
         integration_matcher: IntegrationMatcher,
         bluetooth_adapters: BluetoothAdapters,
+        storage: BluetoothStorage,
     ) -> None:
         """Init bluetooth manager."""
         self.hass = hass
@@ -128,6 +130,7 @@ def __init__(
         self._adapters: dict[str, AdapterDetails] = {}
         self._sources: dict[str, BaseHaScanner] = {}
         self._bluetooth_adapters = bluetooth_adapters
+        self.storage = storage
 
     @property
     def supports_passive_scan(self) -> bool:
@@ -196,12 +199,9 @@ async def async_setup(self) -> None:
         """Set up the bluetooth manager."""
         await self._bluetooth_adapters.refresh()
         install_multiple_bleak_catcher()
-        history = async_load_history_from_system(self._bluetooth_adapters)
-        # Everything is connectable so it fall into both
-        # buckets since the host system can only provide
-        # connectable devices
-        self._all_history = history.copy()
-        self._connectable_history = history.copy()
+        self._all_history, self._connectable_history = async_load_history_from_system(
+            self._bluetooth_adapters, self.storage
+        )
         self.async_setup_unavailable_tracking()
 
     @hass_callback

homeassistant/components/bluetooth/scanner.py

@@ -132,6 +132,7 @@ def __init__(
         """Init bluetooth discovery."""
         source = address if address != DEFAULT_ADDRESS else adapter or SOURCE_LOCAL
         super().__init__(hass, source, adapter)
+        self.connectable = True
         self.mode = mode
         self.adapter = adapter
         self._start_stop_lock = asyncio.Lock()