fix: incorrect advertising interval calculation when scanner pauses for connections (#283)

Author: bdraco

src/habluetooth/advertisement_tracker.pxd

@@ -15,3 +15,5 @@ cdef class AdvertisementTracker:
     cpdef void async_collect(self, BluetoothServiceInfoBleak service_info)
 
     cpdef void async_remove_address(self, object address)
+
+    cpdef void async_scanner_paused(self, str source)

src/habluetooth/advertisement_tracker.py

@@ -80,3 +80,18 @@ def async_remove_source(self, source: str) -> None:
         for address, tracked_source in list(self.sources.items()):
             if tracked_source == source:
                 self.async_remove_address(address)
+
+    def async_scanner_paused(self, source: str) -> None:
+        """
+        Clear timing collection data when scanner is paused.
+
+        When a scanner pauses to establish a connection, it stops listening
+        for advertisements. If we don't clear the timing data, the next
+        advertisement after the connection attempt will create an incorrectly
+        large interval measurement (time_after_connection - time_before_connection)
+        which doesn't represent the actual advertising interval of the device.
+        """
+        # Only iterate through timing data (typically much smaller than sources)
+        for address in list(self._timings):
+            if self.sources.get(address) == source:
+                del self._timings[address]

src/habluetooth/base_scanner.py

@@ -134,6 +134,9 @@ def _add_connect_failure(self, address: str) -> None:
     def _add_connecting(self, address: str) -> None:
         """Add a connecting."""
         self._increase_count(self._connect_in_progress, address)
+        # Clear timing collection data when scanner pauses for connection
+        # to prevent collecting invalid advertising interval data
+        self._manager._advertisement_tracker.async_scanner_paused(self.source)
 
     def _remove_connecting(self, address: str) -> None:
         """Remove a connecting."""

tests/test_advertisement_tracker.py

@@ -0,0 +1,82 @@
+"""Test that advertising interval tracking is properly cleared when scanner pauses."""
+
+import pytest
+
+from habluetooth.advertisement_tracker import AdvertisementTracker
+from habluetooth.base_scanner import BaseHaScanner
+from habluetooth.central_manager import get_manager
+
+
+@pytest.mark.asyncio
+async def test_scanner_paused_clears_timing_data():
+    """Test timing data is cleared when scanner pauses but intervals are preserved."""
+    tracker = AdvertisementTracker()
+    source = "test_scanner"
+    address = "AA:BB:CC:DD:EE:FF"
+
+    # Simulate collecting timing data
+    tracker.sources[address] = source
+    tracker._timings[address] = [1.0, 2.0, 3.0]  # Some timing data
+    tracker.intervals[address] = 10.0  # Already learned interval
+
+    # Call async_scanner_paused
+    tracker.async_scanner_paused(source)
+
+    # Check that timing data is cleared but interval is preserved
+    assert address not in tracker._timings
+    assert tracker.intervals[address] == 10.0  # Interval should still be there
+    assert tracker.sources[address] == source  # Source mapping should still be there
+
+
+@pytest.mark.asyncio
+async def test_scanner_paused_only_affects_matching_source():
+    """Test that pausing only affects devices from the matching source."""
+    tracker = AdvertisementTracker()
+    source1 = "scanner1"
+    source2 = "scanner2"
+    address1 = "AA:BB:CC:DD:EE:01"
+    address2 = "AA:BB:CC:DD:EE:02"
+
+    # Set up data for two sources
+    tracker.sources[address1] = source1
+    tracker.sources[address2] = source2
+    tracker._timings[address1] = [1.0, 2.0]
+    tracker._timings[address2] = [1.0, 2.0]
+    tracker.intervals[address1] = 5.0
+    tracker.intervals[address2] = 6.0
+
+    # Pause only source1
+    tracker.async_scanner_paused(source1)
+
+    # Check that only source1 timing is cleared
+    assert address1 not in tracker._timings
+    assert address2 in tracker._timings  # source2 should still have timing data
+    assert tracker.intervals[address1] == 5.0  # Intervals preserved
+    assert tracker.intervals[address2] == 6.0
+
+
+@pytest.mark.asyncio
+async def test_connection_clears_timing_data():
+    """Test that timing data is cleared when a connection is initiated."""
+    # Get the manager that was set up by the fixture
+    test_manager = get_manager()
+
+    # Create actual BaseHaScanner to test the method
+    real_scanner = BaseHaScanner(
+        source="test_scanner", adapter="hci0", connectable=True
+    )
+    # BaseHaScanner gets the manager internally via get_manager()
+
+    # Set up some timing data
+    address = "AA:BB:CC:DD:EE:FF"
+    test_manager._advertisement_tracker.sources[address] = real_scanner.source
+    test_manager._advertisement_tracker._timings[address] = [1.0, 2.0, 3.0]
+    test_manager._advertisement_tracker.intervals[address] = 10.0
+
+    # Call _add_connecting which should clear timing data
+    real_scanner._add_connecting(address)
+
+    # Verify timing data was cleared but interval preserved
+    assert address not in test_manager._advertisement_tracker._timings
+    assert test_manager._advertisement_tracker.intervals.get(address) == 10.0
+    assert address in real_scanner._connect_in_progress

tests/test_scanner.py

@@ -24,8 +24,6 @@
     set_manager,
 )
 from habluetooth.channels.bluez import (
-    ADV_MONITOR_DEVICE_FOUND,
-    DEVICE_FOUND,
     BluetoothMGMTProtocol,
     MGMTBluetoothCtl,
 )
@@ -44,6 +42,8 @@
 )
 from .conftest import FakeBluetoothAdapters
 
+DEVICE_FOUND = 0x0012
+ADV_MONITOR_DEVICE_FOUND = 0x002F
 IS_WINDOWS = 'os.name == "nt"'
 IS_POSIX = 'os.name == "posix"'
 NOT_POSIX = 'os.name != "posix"'