Unifiprotect Prevent duplicate vehicle detection events from firing (home-assistant#157278)

Co-authored-by: J. Nick Koston <[email protected]>

Author: RaHehl

homeassistant/components/unifiprotect/event.py

@@ -201,6 +201,8 @@ class ProtectDeviceVehicleEventEntity(
     _latest_event_id: str | None = None
     _latest_thumbnails: list[EventDetectedThumbnail] | None = None
     _thumbnail_timer_due: float = 0.0  # Loop time when timer should fire
+    _fired_event_id: str | None = None  # Track last fired event to prevent duplicates
+    _fired_event_data: dict[str, Any] | None = None  # Track event data when fired
 
     async def async_added_to_hass(self) -> None:
         """Register cleanup callback when entity is added."""
@@ -239,28 +241,11 @@ def _get_vehicle_thumbnails(event: Event) -> list[EventDetectedThumbnail]:
             ]
         return []
 
-    @callback
-    def _fire_vehicle_event(
-        self, event_id: str, thumbnails: list[EventDetectedThumbnail] | None = None
-    ) -> None:
-        """Fire the vehicle detection event with best available thumbnail.
-
-        Args:
-            event_id: The event ID to include in the fired event data.
-            thumbnails: Pre-stored thumbnails to use. If None, fetches from
-                the current event (used when event is still active).
-        """
-        if thumbnails is None:
-            # No stored thumbnails; try to get from current event
-            event = self.entity_description.get_event_obj(self.device)
-            if not event or event.id != event_id:
-                return
-            thumbnails = self._get_vehicle_thumbnails(event)
-
-        if not thumbnails:
-            return
-
-        # Start with just the event ID
+    @staticmethod
+    def _build_event_data(
+        event_id: str, thumbnails: list[EventDetectedThumbnail]
+    ) -> dict[str, Any]:
+        """Build event data dictionary from thumbnails."""
         event_data: dict[str, Any] = {
             ATTR_EVENT_ID: event_id,
             "thumbnail_count": len(thumbnails),
@@ -286,6 +271,39 @@ def _fire_vehicle_event(
         if thumbnail.attributes:
             event_data["attributes"] = thumbnail.attributes.unifi_dict()
 
+        return event_data
+
+    @callback
+    def _fire_vehicle_event(
+        self, event_id: str, thumbnails: list[EventDetectedThumbnail] | None = None
+    ) -> None:
+        """Fire the vehicle detection event with best available thumbnail.
+
+        Args:
+            event_id: The event ID to include in the fired event data.
+            thumbnails: Pre-stored thumbnails to use. If None, fetches from
+                the current event (used when event is still active).
+        """
+        if thumbnails is None:
+            # No stored thumbnails; try to get from current event
+            event = self.entity_description.get_event_obj(self.device)
+            if not event or event.id != event_id:
+                return
+            thumbnails = self._get_vehicle_thumbnails(event)
+
+        if not thumbnails:
+            return
+
+        event_data = self._build_event_data(event_id, thumbnails)
+
+        # Prevent duplicate firing of same event with same data
+        if self._fired_event_id == event_id and self._fired_event_data == event_data:
+            return
+
+        # Mark this event as fired with its data
+        self._fired_event_id = event_id
+        self._fired_event_data = event_data
+
         self._trigger_event(EVENT_TYPE_VEHICLE_DETECTED, event_data)
         self.async_write_ha_state()
 
@@ -313,10 +331,20 @@ def _async_update_device_from_protect(self, device: ProtectDeviceType) -> None:
             and event.type is EventType.SMART_DETECT
             and (thumbnails := self._get_vehicle_thumbnails(event))
         ):
+            # Skip if same event with same data (no changes)
+            if (
+                self._fired_event_id == event.id
+                and self._fired_event_data
+                == self._build_event_data(event.id, thumbnails)
+            ):
+                return
+
             # New event arrived while timer pending for different event?
             # Fire the old event immediately since it has completed
             if self._latest_event_id and self._latest_event_id != event.id:
+                # Only fire if we haven't already (shouldn't happen, but defensive)
                 self._fire_vehicle_event(self._latest_event_id, self._latest_thumbnails)
+                self._cancel_thumbnail_timer()
 
             # Store event data and extend/start the timer
             # Timer extension allows better thumbnails (with LPR) to arrive

tests/components/unifiprotect/test_event.py

@@ -1395,3 +1395,198 @@ async def test_vehicle_detection_timer_cleanup_on_remove(
     # Entity should be gone and no event should have fired
     state = hass.states.get(entity_id)
     assert state is None
+
+
+async def test_vehicle_detection_refire_on_lpr_data(
+    hass: HomeAssistant,
+    ufp: MockUFPFixture,
+    doorbell: Camera,
+    unadopted_camera: Camera,
+    fixed_now: datetime,
+) -> None:
+    """Test that event refires when LPR data arrives after initial detection."""
+
+    await init_entry(hass, ufp, [doorbell, unadopted_camera])
+    assert_entity_counts(hass, Platform.EVENT, 4, 4)
+    events: list[HAEvent] = []
+
+    @callback
+    def _capture_event(event: HAEvent) -> None:
+        events.append(event)
+
+    _, entity_id = await ids_from_device_description(
+        hass, Platform.EVENT, doorbell, EVENT_DESCRIPTIONS[3]
+    )
+
+    unsub = async_track_state_change_event(hass, entity_id, _capture_event)
+
+    # Create event with vehicle thumbnail but NO LPR data
+    event = Event(
+        model=ModelType.EVENT,
+        id="test_refire_lpr_id",
+        type=EventType.SMART_DETECT,
+        start=fixed_now - timedelta(seconds=1),
+        end=None,
+        score=100,
+        smart_detect_types=[],
+        smart_detect_event_ids=[],
+        camera_id=doorbell.id,
+        api=ufp.api,
+        metadata={
+            "detected_thumbnails": [
+                {
+                    "type": "vehicle",
+                    "confidence": 85,
+                    "clock_best_wall": fixed_now,
+                    "cropped_id": "test_thumb_id",
+                }
+            ]
+        },
+    )
+
+    new_camera = doorbell.model_copy()
+    new_camera.last_smart_detect_event_id = "test_refire_lpr_id"
+    ufp.api.bootstrap.cameras = {new_camera.id: new_camera}
+    ufp.api.bootstrap.events = {event.id: event}
+
+    mock_msg = Mock()
+    mock_msg.changed_data = {}
+    mock_msg.new_obj = event
+    ufp.ws_msg(mock_msg)
+
+    # Wait for the timer to expire - first event should fire without LPR
+    await asyncio.sleep(TEST_VEHICLE_EVENT_DELAY * 2)
+    await hass.async_block_till_done()
+
+    # Should have received first event without LPR
+    assert len(events) == 1
+    state = events[0].data["new_state"]
+    assert state
+    assert state.attributes[ATTR_EVENT_ID] == "test_refire_lpr_id"
+    assert state.attributes["confidence"] == 85
+    assert "license_plate" not in state.attributes
+
+    # Now LPR data arrives for the same event
+    event.metadata = {
+        "detected_thumbnails": [
+            {
+                "type": "vehicle",
+                "confidence": 85,
+                "clock_best_wall": fixed_now,
+                "cropped_id": "test_thumb_id",
+            },
+            {
+                "type": "vehicle",
+                "confidence": 95,
+                "clock_best_wall": fixed_now + timedelta(seconds=1),
+                "cropped_id": "test_thumb_id_lpr",
+                "group": {
+                    "id": "lpr_group",
+                    "matched_name": "ABC123",
+                    "confidence": 95,
+                },
+            },
+        ]
+    }
+
+    ufp.api.bootstrap.events = {event.id: event}
+    mock_msg.new_obj = event
+    ufp.ws_msg(mock_msg)
+
+    # Wait for the new timer to expire
+    await asyncio.sleep(TEST_VEHICLE_EVENT_DELAY * 2)
+    await hass.async_block_till_done()
+
+    # Should have received second event WITH LPR data
+    assert len(events) == 2
+    state = events[1].data["new_state"]
+    assert state
+    assert state.attributes[ATTR_EVENT_ID] == "test_refire_lpr_id"
+    assert state.attributes["confidence"] == 95
+    assert state.attributes["license_plate"] == "ABC123"
+
+    unsub()
+
+
+async def test_vehicle_detection_no_refire_same_data(
+    hass: HomeAssistant,
+    ufp: MockUFPFixture,
+    doorbell: Camera,
+    unadopted_camera: Camera,
+    fixed_now: datetime,
+) -> None:
+    """Test that event does NOT refire when same data arrives again."""
+
+    await init_entry(hass, ufp, [doorbell, unadopted_camera])
+    assert_entity_counts(hass, Platform.EVENT, 4, 4)
+    events: list[HAEvent] = []
+
+    @callback
+    def _capture_event(event: HAEvent) -> None:
+        events.append(event)
+
+    _, entity_id = await ids_from_device_description(
+        hass, Platform.EVENT, doorbell, EVENT_DESCRIPTIONS[3]
+    )
+
+    unsub = async_track_state_change_event(hass, entity_id, _capture_event)
+
+    # Create event with vehicle thumbnail
+    event = Event(
+        model=ModelType.EVENT,
+        id="test_no_refire_id",
+        type=EventType.SMART_DETECT,
+        start=fixed_now - timedelta(seconds=1),
+        end=None,
+        score=100,
+        smart_detect_types=[],
+        smart_detect_event_ids=[],
+        camera_id=doorbell.id,
+        api=ufp.api,
+        metadata={
+            "detected_thumbnails": [
+                {
+                    "type": "vehicle",
+                    "confidence": 90,
+                    "clock_best_wall": fixed_now,
+                    "cropped_id": "test_thumb_id",
+                    "group": {
+                        "id": "lpr_group",
+                        "matched_name": "XYZ789",
+                        "confidence": 90,
+                    },
+                }
+            ]
+        },
+    )
+
+    new_camera = doorbell.model_copy()
+    new_camera.last_smart_detect_event_id = "test_no_refire_id"
+    ufp.api.bootstrap.cameras = {new_camera.id: new_camera}
+    ufp.api.bootstrap.events = {event.id: event}
+
+    mock_msg = Mock()
+    mock_msg.changed_data = {}
+    mock_msg.new_obj = event
+    ufp.ws_msg(mock_msg)
+
+    # Wait for the timer to expire
+    await asyncio.sleep(TEST_VEHICLE_EVENT_DELAY * 2)
+    await hass.async_block_till_done()
+
+    # Should have received one event
+    assert len(events) == 1
+    state = events[0].data["new_state"]
+    assert state
+    assert state.attributes[ATTR_EVENT_ID] == "test_no_refire_id"
+    assert state.attributes["license_plate"] == "XYZ789"
+
+    # Send the same event again with identical data
+    ufp.ws_msg(mock_msg)
+    await asyncio.sleep(TEST_VEHICLE_EVENT_DELAY * 2)
+    await hass.async_block_till_done()
+
+    # Should NOT have received another event (same data)
+    assert len(events) == 1
+
+    unsub()