Reuse warm Eufy streams across reconnects

Author: SmartHardware

README.md

@@ -67,7 +67,7 @@ Trigger motion or ring a doorbell and verify that the matching
 
 | Component | Version/contract |
 | --- | --- |
-| Home Assistant custom integration | Baiamonte Eufy Security 9.6.35 |
+| Home Assistant custom integration | Baiamonte Eufy Security 9.6.36 |
 | WebSocket schema | 21 |
 | WebSocket server | `eufy-security-ws` 3.1.0 |
 | Client build | `eufy-security-client` 4.1.1-mega.38 (upstream 4.1.1) |

custom_components/eufy_security/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 9.6.36 — 2026-10-31
+
+- Reuse an explicitly opened P2P camera source for a short, configurable grace period when a phone,
+  dashboard, or TV reconnects, reducing repeated HomeBase handshakes without ever starting live
+  video automatically.
+- Bound the grace period to 0–30 seconds (8 seconds by default), cancel it immediately for an
+  explicit stop, and release any warm source when the integration unloads.
+
 ## 9.6.35 — 2026-10-26
 
 - Keep camera state rendering and product-event callbacks limited to bounded byte validation.

custom_components/eufy_security/README.md

@@ -2,7 +2,7 @@
 
 Home Assistant companion integration for **Baiamonte eufy Bridge**.
 
-Version 9.6.35 is an in-place successor to `fuatakgun/eufy_security` 8.2.4. It deliberately retains
+Version 9.6.36 is an in-place successor to `fuatakgun/eufy_security` 8.2.4. It deliberately retains
 the `eufy_security` domain and entity unique-ID format, while replacing the visible product name,
 documentation, diagnostics, and connection handling.
 

custom_components/eufy_security/camera.py

@@ -138,6 +138,9 @@ def __init__(
         self._last_image = product_snapshot_bytes(self.product)
         self.product.stream_stopped_listener = self._stop_hass_streaming
         self._scheduled_snapshot_lock = asyncio.Lock()
+        self._stream_stop_task: asyncio.Task | None = None
+        self._stream_stop_generation = 0
+        self._active_proxy_viewers = 0
         # ffmpeg entities
         self.ffmpeg = self.coordinator.hass.data[DATA_FFMPEG]
 
@@ -149,14 +152,71 @@ async def stream_source(self) -> str | None:
             return self.product.stream_url
         if self.is_streaming is False:
             return None
+        # A dashboard or phone can reconnect while the previous viewer is in
+        # the short linger window. Reuse that explicitly opened source instead
+        # of paying for another Eufy/HomeBase P2P handshake.
+        self._cancel_pending_stream_stop()
         return self.product.stream_url
 
+    @callback
+    def _cancel_pending_stream_stop(self) -> None:
+        """Cancel a delayed stop before a new viewer reuses the source."""
+        self._stream_stop_generation += 1
+        if self._stream_stop_task is not None:
+            self._stream_stop_task.cancel()
+            self._stream_stop_task = None
+
+    @callback
+    def _schedule_p2p_stream_stop(self) -> None:
+        """Release an explicitly opened P2P source after a bounded linger."""
+        self._cancel_pending_stream_stop()
+        generation = self._stream_stop_generation
+        delay = max(0, min(30, int(self.coordinator.config.stream_linger_seconds)))
+        self._stream_stop_task = self.hass.async_create_background_task(
+            self._async_stop_p2p_after_linger(generation, delay),
+            f"baiamonte_eufy_stream_linger_{self.entity_id or self.product.model}",
+        )
+
+    async def _async_stop_p2p_after_linger(
+        self, generation: int, delay: int
+    ) -> None:
+        """Stop one P2P source unless another viewer claimed it."""
+        try:
+            if delay:
+                await asyncio.sleep(delay)
+            if generation != self._stream_stop_generation:
+                return
+            if (
+                self.product.stream_provider != StreamProvider.P2P
+                or not self.is_streaming
+            ):
+                return
+            try:
+                async with asyncio.timeout(8):
+                    await self.product.stop_livestream()
+            except (
+                asyncio.TimeoutError,
+                FailedCommandException,
+                WebSocketConnectionException,
+            ):
+                self.product.stream_status = StreamStatus.IDLE
+                await self._stop_hass_streaming()
+                _LOGGER.warning(
+                    "Camera proxy cleanup was not acknowledged; source released locally"
+                )
+        except asyncio.CancelledError:
+            return
+        finally:
+            if generation == self._stream_stop_generation:
+                self._stream_stop_task = None
+
     async def handle_async_mjpeg_stream(self, request):
         """Proxy one bounded live session and always release its Eufy source."""
         stream_source = await self.stream_source()
         if stream_source is None:
             return await super().handle_async_mjpeg_stream(request)
         stream = CameraMjpeg(self.ffmpeg.binary)
+        self._active_proxy_viewers += 1
         try:
             async with asyncio.timeout(STREAM_TIMEOUT_SECONDS):
                 await stream.open_camera(stream_source)
@@ -172,23 +232,13 @@ async def handle_async_mjpeg_stream(self, request):
             ) from exc
         finally:
             await stream.close()
+            self._active_proxy_viewers = max(0, self._active_proxy_viewers - 1)
             if (
                 self.product.stream_provider == StreamProvider.P2P
                 and self.is_streaming
+                and self._active_proxy_viewers == 0
             ):
-                try:
-                    async with asyncio.timeout(8):
-                        await self.product.stop_livestream()
-                except (
-                    asyncio.TimeoutError,
-                    FailedCommandException,
-                    WebSocketConnectionException,
-                ):
-                    self.product.stream_status = StreamStatus.IDLE
-                    await self._stop_hass_streaming()
-                    _LOGGER.warning(
-                        "Camera proxy cleanup was not acknowledged; source released locally"
-                    )
+                self._schedule_p2p_stream_stop()
 
     async def async_create_stream(self):
         """Create HA playback only for a source the user already started."""
@@ -398,6 +448,10 @@ async def async_refresh_stale_snapshot(self, *, force: bool = False) -> bool:
 
     async def _start_livestream(self) -> None:
         """Start a P2P source for the bounded camera proxy request."""
+        self._cancel_pending_stream_stop()
+        if self.is_streaming:
+            self.async_write_ha_state()
+            return
         if await self.product.start_livestream() is False:
             raise ServiceValidationError(
                 f"{self.product.model} opened P2P but delivered no media"
@@ -406,10 +460,27 @@ async def _start_livestream(self) -> None:
 
     async def _stop_livestream(self) -> None:
         """stop byte based livestream on camera"""
+        self._cancel_pending_stream_stop()
         await self._stop_hass_streaming()
         await self.product.stop_livestream()
         self.async_write_ha_state()
 
+    async def async_will_remove_from_hass(self) -> None:
+        """Release any warm P2P source when the entity unloads."""
+        self._cancel_pending_stream_stop()
+        if (
+            self.product.stream_provider == StreamProvider.P2P
+            and self.is_streaming
+        ):
+            with contextlib.suppress(
+                asyncio.TimeoutError,
+                FailedCommandException,
+                WebSocketConnectionException,
+            ):
+                async with asyncio.timeout(8):
+                    await self.product.stop_livestream()
+        await super().async_will_remove_from_hass()
+
     async def _start_rtsp_livestream(self) -> None:
         """Start the device RTSP source without creating an orphan HA worker."""
         if await self.product.start_rtsp_livestream() is False:

custom_components/eufy_security/config_flow.py

@@ -41,6 +41,10 @@ def __init__(self, config_entry: ConfigEntry) -> None:
                     ConfigField.no_stream_in_hass.name,
                     default=self.config.no_stream_in_hass,
                 ): bool,
+                vol.Optional(
+                    ConfigField.stream_linger_seconds.name,
+                    default=self.config.stream_linger_seconds,
+                ): vol.All(vol.Coerce(int), vol.Range(min=0, max=30)),
                 vol.Optional(
                     ConfigField.name_for_custom1.name,
                     default=self.config.name_for_custom1,

custom_components/eufy_security/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_push",
   "issue_tracker": "https://github.com/drahamin/baiamonte-eufy-bridge/issues",
   "requirements": [],
-  "version": "9.6.35"
+  "version": "9.6.36"
 }

custom_components/eufy_security/model.py

@@ -26,6 +26,7 @@ class ConfigField(Enum):
     dashboard_port = 8097
     show_sidebar_panel = True
     no_stream_in_hass = False
+    stream_linger_seconds = 8
     name_for_custom1 = "Custom 1"
     name_for_custom2 = "Custom 2"
     name_for_custom3 = "Custom 3"
@@ -48,6 +49,7 @@ class Config:
     dashboard_port: int = ConfigField.dashboard_port.value
     show_sidebar_panel: bool = ConfigField.show_sidebar_panel.value
     no_stream_in_hass: bool = ConfigField.no_stream_in_hass.value
+    stream_linger_seconds: int = ConfigField.stream_linger_seconds.value
     name_for_custom1: str = ConfigField.name_for_custom1.value
     name_for_custom2: str = ConfigField.name_for_custom2.value
     name_for_custom3: str = ConfigField.name_for_custom3.value

custom_components/eufy_security/translations/de.json

@@ -35,6 +35,7 @@
           "dashboard_port": "Baiamonte bridge diagnostics port",
           "show_sidebar_panel": "Baiamonte Eufy Security in der Seitenleiste anzeigen",
           "no_stream_in_hass": "Do not use STREAM module inside Home Assistant (if you do not watch the video inside Home Assistant native streaming or you are using WebRTC, enable this to decrease CPU usage",
+          "stream_linger_seconds": "Keep an explicitly opened P2P stream warm after the viewer disconnects (seconds, 0 disables)",
           "name_for_custom1": "Überschreibungsname für benutzerdefinierten Schutzmodus (1)",
           "name_for_custom2": "Überschreibungsname für benutzerdefinierten Schutzmodus (2)",
           "name_for_custom3": "Überschreibungsname für benutzerdefinierten Schutzmodus (3)"

custom_components/eufy_security/translations/en.json

@@ -35,6 +35,7 @@
           "dashboard_port": "Baiamonte bridge diagnostics port (default 8097)",
           "show_sidebar_panel": "Show Baiamonte Eufy Security in the sidebar",
           "no_stream_in_hass": "Do not use STREAM module inside Home Assistant (if you do not watch the video inside Home Assistant native streaming or you are using WebRTC, enable this to decrease CPU usage",
+          "stream_linger_seconds": "Keep an explicitly opened P2P stream warm after the viewer disconnects (seconds, 0 disables)",
           "name_for_custom1": "Override Name for Custom1 Guard Mode",
           "name_for_custom2": "Override Name for Custom2 Guard Mode",
           "name_for_custom3": "Override Name for Custom3 Guard Mode"

custom_components/eufy_security/translations/fr.json

@@ -35,6 +35,7 @@
           "dashboard_port": "Baiamonte bridge diagnostics port",
           "show_sidebar_panel": "Afficher Baiamonte Eufy Security dans la barre latérale",
           "no_stream_in_hass": "Do not use STREAM module inside Home Assistant (if you do not watch the video inside Home Assistant native streaming or you are using WebRTC, enable this to decrease CPU usage",
+          "stream_linger_seconds": "Keep an explicitly opened P2P stream warm after the viewer disconnects (seconds, 0 disables)",
           "name_for_custom1": "Remplacer le nom pour le mode de garde Personnalisé1",
           "name_for_custom2": "Remplacer le nom pour le mode de garde Personnalisé2",
           "name_for_custom3": "Remplacer le nom pour le mode de garde Personnalisé3"