add default icon, observe measure div, fix tests

docs/docs/configuration/advanced/reference.md

@@ -571,8 +571,6 @@ notifications:
   enabled: False
   # Optional: Email for push service to reach out to
   # NOTE: This is required to use notifications
-  # NOTE: Email can be specified with an environment variable or docker secrets that must begin with 'FRIGATE_'.
-  #       e.g. email: '{FRIGATE_NOTIFICATION_EMAIL}'
   email: "admin@example.com"
   # Optional: Cooldown time for notifications in seconds (default: shown below)
   cooldown: 0

frigate/api/app.py

@@ -311,12 +311,9 @@ def config(request: Request):
         mode="json", warnings="none", exclude_none=True
     )
 
-    is_admin = request.headers.get("remote-role") == "admin"
-
-    # hide environment_vars and the notification email from non-admin users
-    if not is_admin:
+    # remove environment_vars for non-admin users
+    if request.headers.get("remote-role") != "admin":
         config.pop("environment_vars", None)
-        redact_credential(config["notifications"], "email")
 
     # redact mqtt credentials
     redact_credential(config["mqtt"], "password")
@@ -373,15 +370,7 @@ def config(request: Request):
                 camera_name
             )
             if base_sections:
-                # copy so redaction below can't alter the profile manager's cache
-                camera_dict["base_config"] = copy.deepcopy(base_sections)
-
-        # cameras inherit the global notification email
-        if not is_admin:
-            redact_credential(camera_dict["notifications"], "email")
-            redact_credential(
-                camera_dict.get("base_config", {}).get("notifications", {}), "email"
-            )
+                camera_dict["base_config"] = base_sections
 
     # remove go2rtc stream passwords
     go2rtc: dict[str, Any] = config_obj.go2rtc.model_dump(

frigate/app.py

@@ -77,7 +77,7 @@ from frigate.notices.registry import NoticeRegistry
 from frigate.object_detection.base import ObjectDetectProcess
 from frigate.object_detection.util import detection_frame_size
 from frigate.output.output import OutputProcess
-from frigate.ptz.autotrack import PtzAutoTracker
+from frigate.ptz.autotrack import PtzAutoTrackerThread
 from frigate.ptz.onvif import OnvifController
 from frigate.record.cleanup import RecordingCleanup
 from frigate.record.export import migrate_exports
@@ -166,7 +166,11 @@ class FrigateApp:
         # create camera_metrics
         for camera_name in self.config.cameras.keys():
             self.camera_metrics[camera_name] = CameraMetrics(self.metrics_manager)
-            self.ptz_metrics[camera_name] = PTZMetrics()
+            self.ptz_metrics[camera_name] = PTZMetrics(
+                autotracker_enabled=self.config.cameras[
+                    camera_name
+                ].onvif.autotracking.enabled
+            )
 
     def init_queues(self) -> None:
         # Queue for cameras to push tracked objects to
@@ -439,7 +443,7 @@ class FrigateApp:
                 )
 
     def start_ptz_autotracker(self) -> None:
-        self.ptz_autotracker_thread = PtzAutoTracker(
+        self.ptz_autotracker_thread = PtzAutoTrackerThread(
             self.config,
             self.onvif_controller,
             self.ptz_metrics,

frigate/camera/__init__.py

@@ -43,6 +43,8 @@ class CameraMetrics:
 
 
 class PTZMetrics:
+    autotracker_enabled: Synchronized
+
     start_time: Synchronized
     stop_time: Synchronized
     frame_time: Synchronized
@@ -50,10 +52,13 @@ class PTZMetrics:
     max_zoom: Synchronized
     min_zoom: Synchronized
 
+    tracking_active: Event
     motor_stopped: Event
     reset: Event
 
-    def __init__(self) -> None:
+    def __init__(self, *, autotracker_enabled: bool):
+        self.autotracker_enabled = mp.Value("i", autotracker_enabled)  # type: ignore[assignment]
+
         self.start_time = mp.Value("d", 0)  # type: ignore[assignment]
         self.stop_time = mp.Value("d", 0)  # type: ignore[assignment]
         self.frame_time = mp.Value("d", 0)  # type: ignore[assignment]
@@ -61,6 +66,7 @@ class PTZMetrics:
         self.max_zoom = mp.Value("d", 0)  # type: ignore[assignment]
         self.min_zoom = mp.Value("d", 0)  # type: ignore[assignment]
 
+        self.tracking_active = mp.Event()
         self.motor_stopped = mp.Event()
         self.reset = mp.Event()
 

frigate/camera/maintainer.py

@@ -120,7 +120,9 @@ class CameraMaintainer(threading.Thread):
 
         if runtime:
             self.camera_metrics[name] = CameraMetrics(self.metrics_manager)
-            self.ptz_metrics[name] = PTZMetrics()
+            self.ptz_metrics[name] = PTZMetrics(
+                autotracker_enabled=config.onvif.autotracking.enabled
+            )
             self.region_grids[name] = get_camera_regions_grid(
                 name,
                 config.detect,

frigate/camera/state.py

@@ -16,7 +16,7 @@ from frigate.config import (
     ZoomingModeEnum,
 )
 from frigate.const import CLIPS_DIR, THUMB_DIR
-from frigate.ptz.autotrack import PtzAutoTracker, calculate_max_target_box
+from frigate.ptz.autotrack import PtzAutoTrackerThread
 from frigate.track.tracked_object import TrackedObject
 from frigate.util.image import (
     SharedMemoryFrameManager,
@@ -35,7 +35,7 @@ class CameraState:
         name: str,
         config: FrigateConfig,
         frame_manager: SharedMemoryFrameManager,
-        ptz_autotracker_thread: PtzAutoTracker,
+        ptz_autotracker_thread: PtzAutoTrackerThread,
     ) -> None:
         self.name = name
         self.config = config
@@ -115,13 +115,17 @@ class CameraState:
                 # draw thicker box around ptz autotracked object
                 if (
                     self.camera_config.onvif.autotracking.enabled
-                    and self.ptz_autotracker_thread.autotracker_init.get(self.name)
-                    and self.ptz_autotracker_thread.tracked_object[self.name]
+                    and self.ptz_autotracker_thread.ptz_autotracker.autotracker_init.get(
+                        self.name
+                    )
+                    and self.ptz_autotracker_thread.ptz_autotracker.tracked_object[
+                        self.name
+                    ]
                     is not None
                     and obj["id"]
-                    == self.ptz_autotracker_thread.tracked_object[  # type: ignore[union-attr]
+                    == self.ptz_autotracker_thread.ptz_autotracker.tracked_object[
                         self.name
-                    ].obj_data["id"]
+                    ].obj_data["id"]  # type: ignore[attr-defined]
                     and obj["frame_time"] == frame_time
                 ):
                     thickness = 5
@@ -134,9 +138,9 @@ class CameraState:
                         and self.camera_config.detect.width is not None
                         and self.camera_config.detect.height is not None
                     ):
-                        max_target_box = calculate_max_target_box(
-                            self.camera_config.onvif.autotracking.zoom_factor
-                        )
+                        max_target_box = self.ptz_autotracker_thread.ptz_autotracker.tracked_object_metrics[
+                            self.name
+                        ]["max_target_box"]  # type: ignore[index]
                         side_length = max_target_box * (
                             max(
                                 self.camera_config.detect.width,

frigate/comms/dispatcher.py

@@ -759,13 +759,15 @@ class Dispatcher:
                     "Autotracking must be enabled in the config to be turned on via MQTT."
                 )
                 return
-            if not ptz_autotracker_settings.enabled:
+            if not self.ptz_metrics[camera_name].autotracker_enabled.value:
                 logger.info(f"Turning on ptz autotracker for {camera_name}")
+                self.ptz_metrics[camera_name].autotracker_enabled.value = True
                 self.ptz_metrics[camera_name].start_time.value = 0
                 ptz_autotracker_settings.enabled = True
         elif payload == "OFF":
-            if ptz_autotracker_settings.enabled:
+            if self.ptz_metrics[camera_name].autotracker_enabled.value:
                 logger.info(f"Turning off ptz autotracker for {camera_name}")
+                self.ptz_metrics[camera_name].autotracker_enabled.value = False
                 self.ptz_metrics[camera_name].start_time.value = 0
                 ptz_autotracker_settings.enabled = False
 

frigate/config/camera/notification.py

@@ -1,7 +1,6 @@
 from pydantic import Field
 
 from ..base import FrigateBaseModel
-from ..env import EnvString
 
 __all__ = ["NotificationConfig"]
 
@@ -12,7 +11,7 @@ class NotificationConfig(FrigateBaseModel):
         title="Enable notifications",
         description="Enable or disable notifications for all cameras; can be overridden per-camera.",
     )
-    email: EnvString | None = Field(
+    email: str | None = Field(
         default=None,
         title="Notification email",
         description="Email address used for push notifications or required by certain notification providers.",

frigate/detectors/detector_config.py

@@ -186,28 +186,15 @@ class ModelConfig(BaseModel):
 
         # download the model if it doesn't exist
         if not os.path.isfile(self.path):
-            try:
-                download_url = plus_api.get_model_download_url(model_id)
-                r = requests.get(download_url)
-            except requests.exceptions.ConnectionError as e:
-                raise ValueError(
-                    f"Unable to connect to Frigate+ to download model {model_id}"
-                ) from e
-
+            download_url = plus_api.get_model_download_url(model_id)
+            r = requests.get(download_url)
             with open(self.path, "wb") as f:
                 f.write(r.content)
 
         # download the model info if it doesn't exist
         if not os.path.isfile(model_info_path):
-            try:
-                model_info = plus_api.get_model_info(model_id)
-            except requests.exceptions.ConnectionError as e:
-                raise ValueError(
-                    f"Unable to connect to Frigate+ to download model info for {model_id}"
-                ) from e
-
             with open(model_info_path, "w") as f:
-                json.dump(model_info, f)
+                json.dump(plus_api.get_model_info(model_id), f)
 
         model_info = load_plus_model_info(model_id)
 

frigate/motion/improved_motion.py

@@ -19,7 +19,6 @@ class ImprovedMotionDetector(MotionDetector):
         config: RuntimeMotionConfig,
         fps: int,
         ptz_metrics: PTZMetrics | None = None,
-        autotracking_enabled: bool = False,
         name: str = "improved",
         blur_radius: int = 1,
         interpolation: int = cv2.INTER_NEAREST,
@@ -46,7 +45,6 @@ class ImprovedMotionDetector(MotionDetector):
         self.contrast_values[:, 1:2] = 255
         self.contrast_values_index = 0
         self.ptz_metrics = ptz_metrics
-        self.autotracking_enabled = autotracking_enabled
         self.last_stop_time: float | None = None
 
     def is_calibrating(self) -> bool:
@@ -61,7 +59,8 @@ class ImprovedMotionDetector(MotionDetector):
         # if ptz motor is moving from autotracking, quickly return
         # a single box that is 80% of the frame
         if self.ptz_metrics is not None and (
-            self.autotracking_enabled and not self.ptz_metrics.motor_stopped.is_set()
+            self.ptz_metrics.autotracker_enabled.value
+            and not self.ptz_metrics.motor_stopped.is_set()
         ):
             return [
                 (
@@ -163,7 +162,7 @@ class ImprovedMotionDetector(MotionDetector):
         # if so, reassign the average to the current frame so we begin with a new baseline
         if self.ptz_metrics is not None and (
             # ensure we only do this for cameras with autotracking enabled
-            self.autotracking_enabled
+            self.ptz_metrics.autotracker_enabled.value
             and self.ptz_metrics.motor_stopped.is_set()
             and (
                 self.last_stop_time is None

frigate/plus.py

@@ -9,9 +9,7 @@ from typing import Any
 import cv2
 import requests
 from numpy import ndarray
-from requests.adapters import HTTPAdapter
 from requests.models import Response
-from urllib3.util.retry import Retry
 
 from frigate.const import MODEL_CACHE_DIR, PLUS_API_HOST, PLUS_ENV_VAR
 
@@ -103,13 +101,6 @@ class PlusApi:
         self._is_active: bool = self.key is not None
         self._token_data: dict = {}
 
-        # Retry connection failures so a network that comes up late at startup
-        # doesn't fail the Frigate+ model download
-        self._session = requests.Session()
-        self._session.mount(
-            self.host, HTTPAdapter(max_retries=Retry(connect=5, backoff_factor=1))
-        )
-
     def _refresh_token_if_needed(self) -> None:
         if (
             self._token_data.get("expires") is None
@@ -120,9 +111,7 @@ class PlusApi:
                     "Plus API key not set. See https://docs.frigate.video/integrations/plus#set-your-api-key"
                 )
             parts = self.key.split(":")
-            r = self._session.get(
-                f"{self.host}/v1/auth/token", auth=(parts[0], parts[1])
-            )
+            r = requests.get(f"{self.host}/v1/auth/token", auth=(parts[0], parts[1]))
             if not r.ok:
                 raise Exception(f"Unable to refresh API token: {r.text}")
             self._token_data = r.json()
@@ -132,19 +121,19 @@ class PlusApi:
         return {"authorization": f"Bearer {self._token_data.get('accessToken')}"}
 
     def _get(self, path: str) -> Response:
-        return self._session.get(
+        return requests.get(
             f"{self.host}/v1/{path}", headers=self._get_authorization_header()
         )
 
     def _post(self, path: str, data: dict) -> Response:
-        return self._session.post(
+        return requests.post(
             f"{self.host}/v1/{path}",
             headers=self._get_authorization_header(),
             json=data,
         )
 
     def _put(self, path: str, data: dict) -> Response:
-        return self._session.put(
+        return requests.put(
             f"{self.host}/v1/{path}",
             headers=self._get_authorization_header(),
             json=data,

frigate/ptz/autotrack.py

@@ -23,7 +23,6 @@ from frigate.config import CameraConfig, FrigateConfig, ZoomingModeEnum
 from frigate.config.camera.updater import (
     CameraConfigUpdateEnum,
     CameraConfigUpdateSubscriber,
-    CameraConfigUpdateTopic,
 )
 from frigate.const import (
     AUTOTRACKING_MAX_AREA_RATIO,
@@ -43,11 +42,6 @@ from frigate.util.image import SharedMemoryFrameManager, intersection_over_union
 logger = logging.getLogger(__name__)
 
 
-def calculate_max_target_box(zoom_factor: float) -> float:
-    """Return the largest target box ratio allowed for a zoom factor."""
-    return AUTOTRACKING_MAX_AREA_RATIO ** (1 / zoom_factor)
-
-
 def ptz_moving_at_frame_time(frame_time, ptz_start_time, ptz_stop_time):
     # Determine if the PTZ was in motion at the set frame time
     # for non ptz/autotracking cameras, this will always return False
@@ -186,7 +180,7 @@ class PtzMotionEstimator:
         return self.coord_transformations
 
 
-class PtzAutoTracker(threading.Thread):
+class PtzAutoTrackerThread(threading.Thread):
     def __init__(
         self,
         config: FrigateConfig,
@@ -196,14 +190,56 @@ class PtzAutoTracker(threading.Thread):
         stop_event: MpEvent,
     ) -> None:
         super().__init__(name="ptz_autotracker")
+        self.ptz_autotracker = PtzAutoTracker(
+            config, onvif, ptz_metrics, dispatcher, stop_event
+        )
+        self.stop_event = stop_event
+        self.config = config
+
+    def run(self):
+        while not self.stop_event.wait(1):
+            self.ptz_autotracker.check_for_updates()
+
+            for camera, camera_config in list(self.config.cameras.items()):
+                if not camera_config.enabled:
+                    continue
+
+                if camera_config.onvif.autotracking.enabled:
+                    future = asyncio.run_coroutine_threadsafe(
+                        self.ptz_autotracker.camera_maintenance(camera),
+                        self.ptz_autotracker.onvif.loop,
+                    )
+                    # Wait for the coroutine to complete
+                    future.result()
+                else:
+                    # disabled dynamically by mqtt
+                    if self.ptz_autotracker.tracked_object.get(camera):
+                        self.ptz_autotracker.tracked_object[camera] = None
+                        self.ptz_autotracker.tracked_object_history[camera].clear()
+
+        self.ptz_autotracker.config_subscriber.stop()
+        logger.info("Exiting autotracker...")
+
+
+class PtzAutoTracker:
+    def __init__(
+        self,
+        config: FrigateConfig,
+        onvif: OnvifController,
+        ptz_metrics: PTZMetrics,
+        dispatcher: Dispatcher,
+        stop_event: MpEvent,
+    ) -> None:
         self.config = config
         self.onvif = onvif
         self.ptz_metrics = ptz_metrics
         self.dispatcher = dispatcher
         self.stop_event = stop_event
-        self.tracked_object: dict[str, TrackedObject | None] = {}
+        self.tracked_object: dict[str, object] = {}
         self.tracked_object_history: dict[str, object] = {}
-        self.tracked_object_metrics: dict[str, dict[str, Any]] = {}
+        self.tracked_object_metrics: dict[str, object] = {}
+        self.object_types: dict[str, object] = {}
+        self.required_zones: dict[str, object] = {}
         self.move_queues: dict[str, object] = {}
         self.move_queue_locks: dict[str, object] = {}
         self.move_threads: dict[str, object] = {}
@@ -213,6 +249,7 @@ class PtzAutoTracker(threading.Thread):
         self.intercept: dict[str, object] = {}
         self.move_coefficients: dict[str, object] = {}
         self.zoom_time: dict[str, float] = {}
+        self.zoom_factor: dict[str, object] = {}
 
         self.config_subscriber = CameraConfigUpdateSubscriber(
             self.config,
@@ -240,37 +277,44 @@ class PtzAutoTracker(threading.Thread):
                 # Wait for the coroutine to complete
                 future.result()
 
-    def run(self) -> None:
-        while not self.stop_event.wait(1):
-            self.config_subscriber.check_for_updates()
+    def check_for_updates(self) -> None:
+        """Apply camera config updates and mirror autotracking state to ptz metrics.
 
-            for camera, camera_config in list(self.config.cameras.items()):
-                if not camera_config.enabled:
+        The camera processes read autotracker_enabled rather than the config, so it
+        has to follow every path that can change autotracking, not just the mqtt
+        toggle that writes it directly.
+        """
+        updates = self.config_subscriber.check_for_updates()
+
+        for cameras in updates.values():
+            for camera in cameras:
+                camera_config = self.config.cameras.get(camera)
+                metrics = self.ptz_metrics.get(camera)
+
+                # a camera added at runtime gets its metrics from the maintainer on
+                # another thread, which seeds them from this same config value
+                if camera_config is None or metrics is None:
                     continue
 
-                if camera_config.onvif.autotracking.enabled:
-                    future = asyncio.run_coroutine_threadsafe(
-                        self.camera_maintenance(camera), self.onvif.loop
-                    )
-                    # Wait for the coroutine to complete
-                    future.result()
-                else:
-                    # disabled dynamically by mqtt
-                    if self.tracked_object.get(camera):
-                        self.tracked_object[camera] = None
-                        self.tracked_object_history[camera].clear()
-
-        self.config_subscriber.stop()
-        logger.info("Exiting autotracker...")
+                metrics.autotracker_enabled.value = (
+                    camera_config.onvif.autotracking.enabled
+                )
 
     async def _autotracker_setup(self, camera_config: CameraConfig, camera: str):
         logger.debug(f"{camera}: Autotracker init")
 
+        self.object_types[camera] = camera_config.onvif.autotracking.track
+        self.required_zones[camera] = camera_config.onvif.autotracking.required_zones
+        self.zoom_factor[camera] = camera_config.onvif.autotracking.zoom_factor
+
         self.tracked_object[camera] = None
         self.tracked_object_history[camera] = deque(
             maxlen=round(camera_config.detect.fps * 1.5)
         )
-        self._reset_tracked_object_metrics(camera)
+        self.tracked_object_metrics[camera] = {
+            "max_target_box": AUTOTRACKING_MAX_AREA_RATIO
+            ** (1 / self.zoom_factor[camera])
+        }
 
         self.calibrating[camera] = False
         self.move_metrics[camera] = []
@@ -282,22 +326,43 @@ class PtzAutoTracker(threading.Thread):
 
         # handle onvif constructor failing due to no connection
         if camera not in self.onvif.cams:
-            self._disable(camera, "onvif connection failed")
+            logger.warning(
+                f"Disabling autotracking for {camera}: onvif connection failed"
+            )
+            camera_config.onvif.autotracking.enabled = False
+            self.ptz_metrics[camera].autotracker_enabled.value = False
             return
 
         if not self.onvif.cams[camera]["init"]:
             if not await self.onvif._init_onvif(camera):
-                self._disable(camera, "Unable to initialize onvif")
+                logger.warning(
+                    f"Disabling autotracking for {camera}: Unable to initialize onvif"
+                )
+                camera_config.onvif.autotracking.enabled = False
+                self.ptz_metrics[camera].autotracker_enabled.value = False
                 return
 
             if "pt-r-fov" not in self.onvif.cams[camera]["features"]:
-                self._disable(camera, "FOV relative movement not supported")
+                logger.warning(
+                    f"Disabling autotracking for {camera}: FOV relative movement not supported"
+                )
+                camera_config.onvif.autotracking.enabled = False
+                self.ptz_metrics[camera].autotracker_enabled.value = False
                 return
 
             move_status_supported = await self.onvif.get_service_capabilities(camera)
 
-            if str(move_status_supported).lower() != "true":
-                self._disable(camera, "ONVIF MoveStatus not supported")
+            if not (
+                isinstance(move_status_supported, bool) and move_status_supported
+            ) and not (
+                isinstance(move_status_supported, str)
+                and move_status_supported.lower() == "true"
+            ):
+                logger.warning(
+                    f"Disabling autotracking for {camera}: ONVIF MoveStatus not supported"
+                )
+                camera_config.onvif.autotracking.enabled = False
+                self.ptz_metrics[camera].autotracker_enabled.value = False
                 return
 
         if self.onvif.cams[camera]["init"]:
@@ -309,41 +374,59 @@ class PtzAutoTracker(threading.Thread):
             )
 
             if camera_config.onvif.autotracking.movement_weights:
-                (
-                    self.ptz_metrics[camera].min_zoom.value,
-                    self.ptz_metrics[camera].max_zoom.value,
-                    self.intercept[camera],
-                    *self.move_coefficients[camera],
-                    self.zoom_time[camera],
-                ) = map(float, camera_config.onvif.autotracking.movement_weights)
+                if len(camera_config.onvif.autotracking.movement_weights) == 6:
+                    camera_config.onvif.autotracking.movement_weights = [
+                        float(val)
+                        for val in camera_config.onvif.autotracking.movement_weights
+                    ]
+                    self.ptz_metrics[
+                        camera
+                    ].min_zoom.value = (
+                        camera_config.onvif.autotracking.movement_weights[0]
+                    )
+                    self.ptz_metrics[
+                        camera
+                    ].max_zoom.value = (
+                        camera_config.onvif.autotracking.movement_weights[1]
+                    )
+                    self.intercept[camera] = (
+                        camera_config.onvif.autotracking.movement_weights[2]
+                    )
+                    self.move_coefficients[camera] = (
+                        camera_config.onvif.autotracking.movement_weights[3:5]
+                    )
+                    self.zoom_time[camera] = (
+                        camera_config.onvif.autotracking.movement_weights[5]
+                    )
+                else:
+                    camera_config.onvif.autotracking.enabled = False
+                    self.ptz_metrics[camera].autotracker_enabled.value = False
+                    logger.warning(
+                        f"Autotracker recalibration is required for {camera}. Disabling autotracking."
+                    )
 
             if camera_config.onvif.autotracking.calibrate_on_startup:
                 await self._calibrate_camera(camera)
 
+        self.ptz_metrics[camera].tracking_active.clear()
         self.dispatcher.publish(f"{camera}/ptz_autotracker/active", "OFF", retain=False)
         self.autotracker_init[camera] = True
 
-    def _disable(self, camera: str, reason: str) -> None:
-        logger.warning(f"Disabling autotracking for {camera}: {reason}")
-        autotracking_config = self.config.cameras[camera].onvif.autotracking
-        autotracking_config.enabled = False
+    def _write_config(self, camera):
+        config_file = find_config_file()
 
-        # the camera process holds its own copy of the config
-        self.dispatcher.config_updater.publish_update(
-            CameraConfigUpdateTopic(CameraConfigUpdateEnum.autotracking, camera),
-            autotracking_config,
+        logger.debug(
+            f"{camera}: Writing new config with autotracker motion coefficients: {self.config.cameras[camera].onvif.autotracking.movement_weights}"
         )
 
-    def _reset_tracked_object_metrics(self, camera: str) -> None:
-        self.tracked_object_metrics[camera] = {}
-
-    async def _wait_until_stopped(
-        self, camera: str, metrics: PTZMetrics | None = None
-    ) -> None:
-        metrics = metrics or self.ptz_metrics[camera]
-
-        while not metrics.motor_stopped.is_set():
-            await self.onvif.get_camera_status(camera)
+        update_yaml_file_bulk(
+            config_file,
+            {
+                f"cameras.{camera}.onvif.autotracking.movement_weights": self.config.cameras[
+                    camera
+                ].onvif.autotracking.movement_weights
+            },
+        )
 
     async def _calibrate_camera(self, camera):
         # move the camera from the preset in steps and measure the time it takes to move that amount
@@ -376,7 +459,8 @@ class PtzAutoTracker(threading.Thread):
                     1,
                 )
 
-                await self._wait_until_stopped(camera)
+                while not self.ptz_metrics[camera].motor_stopped.is_set():
+                    await self.onvif.get_camera_status(camera)
 
                 zoom_out_values.append(self.ptz_metrics[camera].zoom_level.value)
 
@@ -386,7 +470,8 @@ class PtzAutoTracker(threading.Thread):
                     1,
                 )
 
-                await self._wait_until_stopped(camera)
+                while not self.ptz_metrics[camera].motor_stopped.is_set():
+                    await self.onvif.get_camera_status(camera)
 
                 zoom_in_values.append(self.ptz_metrics[camera].zoom_level.value)
 
@@ -403,7 +488,8 @@ class PtzAutoTracker(threading.Thread):
                         1,
                     )
 
-                    await self._wait_until_stopped(camera)
+                    while not self.ptz_metrics[camera].motor_stopped.is_set():
+                        await self.onvif.get_camera_status(camera)
 
                     zoom_out_values.append(self.ptz_metrics[camera].zoom_level.value)
 
@@ -417,7 +503,8 @@ class PtzAutoTracker(threading.Thread):
                         1,
                     )
 
-                    await self._wait_until_stopped(camera)
+                    while not self.ptz_metrics[camera].motor_stopped.is_set():
+                        await self.onvif.get_camera_status(camera)
 
                     zoom_stop_time = time.time()
 
@@ -431,7 +518,8 @@ class PtzAutoTracker(threading.Thread):
                         1,
                     )
 
-                    await self._wait_until_stopped(camera)
+                    while not self.ptz_metrics[camera].motor_stopped.is_set():
+                        await self.onvif.get_camera_status(camera)
 
                     full_relative_stop_time = time.time()
 
@@ -443,7 +531,8 @@ class PtzAutoTracker(threading.Thread):
                         1,
                     )
 
-                    await self._wait_until_stopped(camera)
+                    while not self.ptz_metrics[camera].motor_stopped.is_set():
+                        await self.onvif.get_camera_status(camera)
 
                     self.zoom_time[camera] = (
                         full_relative_stop_time - full_relative_start_time
@@ -469,7 +558,9 @@ class PtzAutoTracker(threading.Thread):
         self.ptz_metrics[camera].reset.set()
         self.ptz_metrics[camera].motor_stopped.clear()
 
-        await self._wait_until_stopped(camera)
+        # Wait until the camera finishes moving
+        while not self.ptz_metrics[camera].motor_stopped.is_set():
+            await self.onvif.get_camera_status(camera)
 
         for step in range(num_steps):
             pan = step_sizes[step]
@@ -478,7 +569,9 @@ class PtzAutoTracker(threading.Thread):
             start_time = time.time()
             await self.onvif._move_relative(camera, pan, tilt, 0, 1)
 
-            await self._wait_until_stopped(camera)
+            # Wait until the camera finishes moving
+            while not self.ptz_metrics[camera].motor_stopped.is_set():
+                await self.onvif.get_camera_status(camera)
             stop_time = time.time()
 
             self.move_metrics[camera].append(
@@ -497,7 +590,9 @@ class PtzAutoTracker(threading.Thread):
             self.ptz_metrics[camera].reset.set()
             self.ptz_metrics[camera].motor_stopped.clear()
 
-            await self._wait_until_stopped(camera)
+            # Wait until the camera finishes moving
+            while not self.ptz_metrics[camera].motor_stopped.is_set():
+                await self.onvif.get_camera_status(camera)
 
             logger.info(
                 f"Calibration for {camera} in progress: {round((step / num_steps) * 100)}% complete"
@@ -573,14 +668,7 @@ class PtzAutoTracker(threading.Thread):
                 f"{camera}: New regression parameters - intercept: {self.intercept[camera]}, coefficients: {self.move_coefficients[camera]}"
             )
 
-            update_yaml_file_bulk(
-                find_config_file(),
-                {
-                    f"cameras.{camera}.onvif.autotracking.movement_weights": self.config.cameras[
-                        camera
-                    ].onvif.autotracking.movement_weights
-                },
-            )
+            self._write_config(camera)
 
     def _predict_movement_time(self, camera, pan, tilt):
         combined_movement = abs(pan) + abs(tilt)
@@ -594,18 +682,6 @@ class PtzAutoTracker(threading.Thread):
             [self.tracked_object_history[camera][-1]["frame_time"] + time],
         )
 
-    def _predict_target_box(self, camera, predicted_time):
-        target_box = self.tracked_object_metrics[camera]["target_box"]
-
-        if not predicted_time:
-            return target_box
-
-        frame_shape = self.config.cameras[camera].frame_shape
-
-        return target_box + self._predict_area_after_time(camera, predicted_time) / (
-            frame_shape[0] * frame_shape[1]
-        )
-
     def _calculate_tracked_object_metrics(self, camera, obj):
         def remove_outliers(data):
             areas = [item["area"] for item in data]
@@ -627,20 +703,19 @@ class PtzAutoTracker(threading.Thread):
             return filtered_data
 
         camera_config = self.config.cameras[camera]
-        tom = self.tracked_object_metrics[camera]
-        zoom_factor = camera_config.onvif.autotracking.zoom_factor
         camera_width = camera_config.frame_shape[1]
         camera_height = camera_config.frame_shape[0]
 
         # Extract areas and calculate weighted average
         # grab the largest dimension of the bounding box and create a square from that
-        # Use a recent time window
+        # Filter out the initial frame and use a recent time window
         current_time = obj.obj_data["frame_time"]
         time_window = 1.5  # seconds
         history = [
             entry
             for entry in self.tracked_object_history[camera]
-            if current_time - entry["frame_time"] <= time_window
+            if not entry.get("is_initial_frame", False)
+            and current_time - entry["frame_time"] <= time_window
         ]
         if not history:  # Fallback to latest if no recent entries
             history = [self.tracked_object_history[camera][-1]]
@@ -673,29 +748,33 @@ class PtzAutoTracker(threading.Thread):
             )
             y = np.array([item["area"] for item in filtered_areas_not_touching_edge])
 
-            tom["area_coefficients"] = np.linalg.lstsq(X.reshape(-1, 1), y, rcond=None)[
-                0
-            ]
+            self.tracked_object_metrics[camera]["area_coefficients"] = np.linalg.lstsq(
+                X.reshape(-1, 1), y, rcond=None
+            )[0]
         else:
-            tom["area_coefficients"] = np.array([0])
+            self.tracked_object_metrics[camera]["area_coefficients"] = np.array([0])
 
         weights = np.arange(1, len(filtered_areas) + 1)
         weighted_area = np.average(
             [item["area"] for item in filtered_areas], weights=weights
         )
 
-        tom["target_box"] = (
+        self.tracked_object_metrics[camera]["target_box"] = (
             weighted_area / (camera_width * camera_height)
-        ) ** zoom_factor
+        ) ** self.zoom_factor[camera]
 
-        if "original_target_box" not in tom:
-            tom["original_target_box"] = tom["target_box"]
+        if "original_target_box" not in self.tracked_object_metrics[camera]:
+            self.tracked_object_metrics[camera]["original_target_box"] = (
+                self.tracked_object_metrics[camera]["target_box"]
+            )
 
         (
-            tom["valid_velocity"],
-            tom["velocity"],
+            self.tracked_object_metrics[camera]["valid_velocity"],
+            self.tracked_object_metrics[camera]["velocity"],
         ) = self._get_valid_velocity(camera, obj)
-        tom["distance"] = self._get_distance_threshold(camera, obj)
+        self.tracked_object_metrics[camera]["distance"] = self._get_distance_threshold(
+            camera, obj
+        )
 
         centroid_distance = np.linalg.norm(
             [
@@ -706,7 +785,9 @@ class PtzAutoTracker(threading.Thread):
 
         logger.debug(f"{camera}: Centroid distance: {centroid_distance}")
 
-        tom["below_distance_threshold"] = centroid_distance < tom["distance"]
+        self.tracked_object_metrics[camera]["below_distance_threshold"] = (
+            centroid_distance < self.tracked_object_metrics[camera]["distance"]
+        )
 
     async def _process_move_queue(self, camera):
         move_queue = self.move_queues[camera]
@@ -752,12 +833,16 @@ class PtzAutoTracker(threading.Thread):
                         if pan != 0 or tilt != 0:
                             await self.onvif._move_relative(camera, pan, tilt, 0, 1)
 
-                            await self._wait_until_stopped(camera, metrics)
+                            # Wait until the camera finishes moving
+                            while not metrics.motor_stopped.is_set():
+                                await self.onvif.get_camera_status(camera)
 
                         if zoom > 0 and metrics.zoom_level.value != zoom:
                             await self.onvif._zoom_absolute(camera, zoom, 1)
 
-                    await self._wait_until_stopped(camera, metrics)
+                    # Wait until the camera finishes moving
+                    while not metrics.motor_stopped.is_set():
+                        await self.onvif.get_camera_status(camera)
 
                     if camera_config.onvif.autotracking.movement_weights:
                         logger.debug(
@@ -793,20 +878,41 @@ class PtzAutoTracker(threading.Thread):
             await move_queue.get()
 
     def _enqueue_move(self, camera, frame_time, pan, tilt, zoom):
-        pan, tilt, zoom = (np.clip(value, -1, 1) for value in (pan, tilt, zoom))
+        def split_value(value, suppress_diff=True):
+            clipped = np.clip(value, -1, 1)
+
+            # don't make small movements
+            if -0.05 < clipped < 0.05 and suppress_diff:
+                diff = 0.0
+            else:
+                diff = value - clipped
+
+            return clipped, diff
 
         if (
-            (pan != 0 or tilt != 0 or zoom != 0)
-            and frame_time > self.ptz_metrics[camera].start_time.value
+            frame_time > self.ptz_metrics[camera].start_time.value
             and frame_time > self.ptz_metrics[camera].stop_time.value
             and not self.move_queue_locks[camera].locked()
         ):
-            logger.debug(
-                f"{camera}: Enqueue movement for frame time: {frame_time} pan: {pan}, tilt: {tilt}, zoom: {zoom}"
-            )
-            self.onvif.loop.call_soon_threadsafe(
-                self.move_queues[camera].put_nowait, (frame_time, pan, tilt, zoom)
-            )
+            # we can split up any large moves caused by velocity estimated movements if necessary
+            # get an excess amount and assign it instead of 0 below
+            while pan != 0 or tilt != 0 or zoom != 0:
+                pan, _ = split_value(pan)
+                tilt, _ = split_value(tilt)
+                zoom, _ = split_value(zoom, False)
+
+                logger.debug(
+                    f"{camera}: Enqueue movement for frame time: {frame_time} pan: {pan}, tilt: {tilt}, zoom: {zoom}"
+                )
+                move_data = (frame_time, pan, tilt, zoom)
+                self.onvif.loop.call_soon_threadsafe(
+                    self.move_queues[camera].put_nowait, move_data
+                )
+
+                # reset values to not split up large movements
+                pan = 0
+                tilt = 0
+                zoom = 0
 
     def _touching_frame_edges(self, camera, box):
         camera_config = self.config.cameras[camera]
@@ -940,17 +1046,16 @@ class PtzAutoTracker(threading.Thread):
 
         return distance_threshold
 
-    def _should_zoom_in(self, camera: str, box, predicted_time):
+    def _should_zoom_in(
+        self, camera: str, obj: TrackedObject, box, predicted_time, debug_zooming=False
+    ):
         # returns True if we should zoom in, False if we should zoom out, None to do nothing
         camera_config = self.config.cameras[camera]
-        tom = self.tracked_object_metrics[camera]
-        zoom_factor = camera_config.onvif.autotracking.zoom_factor
-        max_target_box = calculate_max_target_box(zoom_factor)
         camera_width = camera_config.frame_shape[1]
         camera_height = camera_config.frame_shape[0]
         camera_fps = camera_config.detect.fps
 
-        average_velocity = tom["velocity"]
+        average_velocity = self.tracked_object_metrics[camera]["velocity"]
 
         bb_left, bb_top, bb_right, bb_bottom = box
 
@@ -968,11 +1073,13 @@ class PtzAutoTracker(threading.Thread):
         touching_frame_edges = self._touching_frame_edges(camera, box)
 
         # make sure object is centered in the frame
-        below_distance_threshold = tom["below_distance_threshold"]
+        below_distance_threshold = self.tracked_object_metrics[camera][
+            "below_distance_threshold"
+        ]
 
         below_dimension_threshold = (bb_right - bb_left) <= camera_width * (
-            zoom_factor + 0.1
-        ) and (bb_bottom - bb_top) <= camera_height * (zoom_factor + 0.1)
+            self.zoom_factor[camera] + 0.1
+        ) and (bb_bottom - bb_top) <= camera_height * (self.zoom_factor[camera] + 0.1)
 
         # ensure object is not moving quickly
         below_velocity_threshold = np.all(
@@ -980,16 +1087,30 @@ class PtzAutoTracker(threading.Thread):
             < np.tile([velocity_threshold_x, velocity_threshold_y], 2)
         ) or np.all(average_velocity == 0)
 
-        calculated_target_box = self._predict_target_box(camera, predicted_time)
+        if not predicted_time:
+            calculated_target_box = self.tracked_object_metrics[camera]["target_box"]
+        else:
+            calculated_target_box = self.tracked_object_metrics[camera][
+                "target_box"
+            ] + self._predict_area_after_time(camera, predicted_time) / (
+                camera_width * camera_height
+            )
 
-        below_area_threshold = calculated_target_box < max_target_box
+        below_area_threshold = (
+            calculated_target_box
+            < self.tracked_object_metrics[camera]["max_target_box"]
+        )
 
         # introduce some hysteresis to prevent a yo-yo zooming effect
         zoom_out_hysteresis = (
-            calculated_target_box > max_target_box * AUTOTRACKING_ZOOM_OUT_HYSTERESIS
+            calculated_target_box
+            > self.tracked_object_metrics[camera]["max_target_box"]
+            * AUTOTRACKING_ZOOM_OUT_HYSTERESIS
         )
         zoom_in_hysteresis = (
-            calculated_target_box < max_target_box * AUTOTRACKING_ZOOM_IN_HYSTERESIS
+            calculated_target_box
+            < self.tracked_object_metrics[camera]["max_target_box"]
+            * AUTOTRACKING_ZOOM_IN_HYSTERESIS
         )
 
         at_max_zoom = (
@@ -1001,29 +1122,31 @@ class PtzAutoTracker(threading.Thread):
             == self.ptz_metrics[camera].min_zoom.value
         )
 
-        logger.debug(
-            f"{camera}: Zoom test: touching edges: count: {touching_frame_edges} left: {bb_left < AUTOTRACKING_ZOOM_EDGE_THRESHOLD * camera_width}, right: {bb_right > (1 - AUTOTRACKING_ZOOM_EDGE_THRESHOLD) * camera_width}, top: {bb_top < AUTOTRACKING_ZOOM_EDGE_THRESHOLD * camera_height}, bottom: {bb_bottom > (1 - AUTOTRACKING_ZOOM_EDGE_THRESHOLD) * camera_height}"
-        )
-        logger.debug(
-            f"{camera}: Zoom test: below distance threshold: {(below_distance_threshold)}"
-        )
-        logger.debug(
-            f"{camera}: Zoom test: below area threshold: {(below_area_threshold)} target: {tom['target_box']}, calculated: {calculated_target_box}, max: {max_target_box}"
-        )
-        logger.debug(
-            f"{camera}: Zoom test: below dimension threshold: {below_dimension_threshold} width: {bb_right - bb_left}, max width: {camera_width * (zoom_factor + 0.1)}, height: {bb_bottom - bb_top}, max height: {camera_height * (zoom_factor + 0.1)}"
-        )
-        logger.debug(
-            f"{camera}: Zoom test: below velocity threshold: {below_velocity_threshold} velocity x: {abs(average_velocity[0])}, x threshold: {velocity_threshold_x}, velocity y: {abs(average_velocity[1])}, y threshold: {velocity_threshold_y}"
-        )
-        logger.debug(f"{camera}: Zoom test: at max zoom: {at_max_zoom}")
-        logger.debug(f"{camera}: Zoom test: at min zoom: {at_min_zoom}")
-        logger.debug(
-            f"{camera}: Zoom test: zoom in hysteresis limit: {zoom_in_hysteresis} value: {AUTOTRACKING_ZOOM_IN_HYSTERESIS} original: {tom['original_target_box']} max: {max_target_box} target: {calculated_target_box if calculated_target_box else tom['target_box']}"
-        )
-        logger.debug(
-            f"{camera}: Zoom test: zoom out hysteresis limit: {zoom_out_hysteresis} value: {AUTOTRACKING_ZOOM_OUT_HYSTERESIS} original: {tom['original_target_box']} max: {max_target_box} target: {calculated_target_box if calculated_target_box else tom['target_box']}"
-        )
+        # debug zooming
+        if debug_zooming:
+            logger.debug(
+                f"{camera}: Zoom test: touching edges: count: {touching_frame_edges} left: {bb_left < AUTOTRACKING_ZOOM_EDGE_THRESHOLD * camera_width}, right: {bb_right > (1 - AUTOTRACKING_ZOOM_EDGE_THRESHOLD) * camera_width}, top: {bb_top < AUTOTRACKING_ZOOM_EDGE_THRESHOLD * camera_height}, bottom: {bb_bottom > (1 - AUTOTRACKING_ZOOM_EDGE_THRESHOLD) * camera_height}"
+            )
+            logger.debug(
+                f"{camera}: Zoom test: below distance threshold: {(below_distance_threshold)}"
+            )
+            logger.debug(
+                f"{camera}: Zoom test: below area threshold: {(below_area_threshold)} target: {self.tracked_object_metrics[camera]['target_box']}, calculated: {calculated_target_box}, max: {self.tracked_object_metrics[camera]['max_target_box']}"
+            )
+            logger.debug(
+                f"{camera}: Zoom test: below dimension threshold: {below_dimension_threshold} width: {bb_right - bb_left}, max width: {camera_width * (self.zoom_factor[camera] + 0.1)}, height: {bb_bottom - bb_top}, max height: {camera_height * (self.zoom_factor[camera] + 0.1)}"
+            )
+            logger.debug(
+                f"{camera}: Zoom test: below velocity threshold: {below_velocity_threshold} velocity x: {abs(average_velocity[0])}, x threshold: {velocity_threshold_x}, velocity y: {abs(average_velocity[1])}, y threshold: {velocity_threshold_y}"
+            )
+            logger.debug(f"{camera}: Zoom test: at max zoom: {at_max_zoom}")
+            logger.debug(f"{camera}: Zoom test: at min zoom: {at_min_zoom}")
+            logger.debug(
+                f"{camera}: Zoom test: zoom in hysteresis limit: {zoom_in_hysteresis} value: {AUTOTRACKING_ZOOM_IN_HYSTERESIS} original: {self.tracked_object_metrics[camera]['original_target_box']} max: {self.tracked_object_metrics[camera]['max_target_box']} target: {calculated_target_box if calculated_target_box else self.tracked_object_metrics[camera]['target_box']}"
+            )
+            logger.debug(
+                f"{camera}: Zoom test: zoom out hysteresis limit: {zoom_out_hysteresis} value: {AUTOTRACKING_ZOOM_OUT_HYSTERESIS} original: {self.tracked_object_metrics[camera]['original_target_box']} max: {self.tracked_object_metrics[camera]['max_target_box']} target: {calculated_target_box if calculated_target_box else self.tracked_object_metrics[camera]['target_box']}"
+            )
 
         # Zoom in conditions (and)
         if (
@@ -1114,7 +1237,7 @@ class PtzAutoTracker(threading.Thread):
             )
 
         zoom = self._get_zoom_amount(
-            camera, obj, predicted_box, predicted_movement_time
+            camera, obj, predicted_box, predicted_movement_time, debug_zoom=True
         )
 
         if (
@@ -1175,11 +1298,9 @@ class PtzAutoTracker(threading.Thread):
         obj: TrackedObject,
         predicted_box,
         predicted_movement_time,
+        debug_zoom=True,
     ):
         camera_config = self.config.cameras[camera]
-        tom = self.tracked_object_metrics[camera]
-        zoom_factor = camera_config.onvif.autotracking.zoom_factor
-        max_target_box = calculate_max_target_box(zoom_factor)
 
         # frame width and height
         camera_width = camera_config.frame_shape[1]
@@ -1196,12 +1317,16 @@ class PtzAutoTracker(threading.Thread):
         # absolute zooming separately from pan/tilt
         if camera_config.onvif.autotracking.zooming == ZoomingModeEnum.absolute:
             # don't zoom on initial move
-            if "target_box" not in tom:
+            if "target_box" not in self.tracked_object_metrics[camera]:
                 zoom = current_zoom_level
             else:
                 if (
                     result := self._should_zoom_in(
-                        camera, obj.obj_data["box"], predicted_movement_time
+                        camera,
+                        obj,
+                        obj.obj_data["box"],
+                        predicted_movement_time,
+                        debug_zoom,
                     )
                 ) is not None:
                     # divide zoom in 10 increments and always zoom out more than in
@@ -1217,35 +1342,46 @@ class PtzAutoTracker(threading.Thread):
         # relative zooming concurrently with pan/tilt
         if camera_config.onvif.autotracking.zooming == ZoomingModeEnum.relative:
             # this is our initial zoom in on a new object
-            if "target_box" not in tom:
-                zoom = target_box**zoom_factor
-                if zoom > max_target_box:
+            if "target_box" not in self.tracked_object_metrics[camera]:
+                zoom = target_box ** self.zoom_factor[camera]
+                if zoom > self.tracked_object_metrics[camera]["max_target_box"]:
                     zoom = -(1 - zoom)
                 logger.debug(
-                    f"{camera}: target box: {target_box}, max: {max_target_box}, calc zoom: {zoom}"
+                    f"{camera}: target box: {target_box}, max: {self.tracked_object_metrics[camera]['max_target_box']}, calc zoom: {zoom}"
                 )
             else:
                 if (
                     result := self._should_zoom_in(
                         camera,
+                        obj,
                         predicted_box
                         if camera_config.onvif.autotracking.movement_weights
                         else obj.obj_data["box"],
                         predicted_movement_time,
+                        debug_zoom,
                     )
                 ) is not None:
-                    calculated_target_box = self._predict_target_box(
-                        camera, predicted_movement_time
-                    )
                     if predicted_movement_time:
+                        calculated_target_box = self.tracked_object_metrics[camera][
+                            "target_box"
+                        ] + self._predict_area_after_time(
+                            camera, predicted_movement_time
+                        ) / (camera_width * camera_height)
                         logger.debug(
-                            f"{camera}: Zooming prediction: predicted movement time: {predicted_movement_time}, original box: {tom['target_box']}, calculated box: {calculated_target_box}"
+                            f"{camera}: Zooming prediction: predicted movement time: {predicted_movement_time}, original box: {self.tracked_object_metrics[camera]['target_box']}, calculated box: {calculated_target_box}"
                         )
+                    else:
+                        calculated_target_box = self.tracked_object_metrics[camera][
+                            "target_box"
+                        ]
                     # zoom value
-                    ratio = max_target_box / calculated_target_box
+                    ratio = (
+                        self.tracked_object_metrics[camera]["max_target_box"]
+                        / calculated_target_box
+                    )
                     zoom = (ratio - 1) / (ratio + 1)
                     logger.debug(
-                        f"{camera}: limit: {max_target_box}, ratio: {ratio} zoom calculation: {zoom}"
+                        f"{camera}: limit: {self.tracked_object_metrics[camera]['max_target_box']}, ratio: {ratio} zoom calculation: {zoom}"
                     )
                     if not result:
                         # zoom out with special condition if zooming out because of velocity, edges, etc.
@@ -1258,6 +1394,9 @@ class PtzAutoTracker(threading.Thread):
 
         return zoom
 
+    def is_autotracking(self, camera: str):
+        return self.tracked_object[camera] is not None
+
     def autotrack_object(self, camera: str, obj: TrackedObject):
         if camera not in self.config.cameras:
             return
@@ -1281,9 +1420,8 @@ class PtzAutoTracker(threading.Thread):
                 # new object
                 self.tracked_object[camera] is None
                 and obj.camera_config.name == camera
-                and obj.obj_data["label"] in camera_config.onvif.autotracking.track
-                and set(obj.entered_zones)
-                & set(camera_config.onvif.autotracking.required_zones)
+                and obj.obj_data["label"] in self.object_types[camera]
+                and set(obj.entered_zones) & set(self.required_zones[camera])
                 and not obj.previous["false_positive"]
                 and not obj.false_positive
                 and not self.tracked_object_history[camera]
@@ -1292,6 +1430,7 @@ class PtzAutoTracker(threading.Thread):
                 logger.debug(
                     f"{camera}: New object: {obj.obj_data['id']} {obj.obj_data['box']} {obj.obj_data['frame_time']}"
                 )
+                self.ptz_metrics[camera].tracking_active.set()
                 self.dispatcher.publish(
                     f"{camera}/ptz_autotracker/active", "ON", retain=False
                 )
@@ -1340,7 +1479,7 @@ class PtzAutoTracker(threading.Thread):
                 # Should we check region (maybe too broad) or expand the previous object's box a bit and check that?
                 self.tracked_object[camera] is None
                 and obj.camera_config.name == camera
-                and obj.obj_data["label"] in camera_config.onvif.autotracking.track
+                and obj.obj_data["label"] in self.object_types[camera]
                 and not obj.previous["false_positive"]
                 and not obj.false_positive
                 and self.tracked_object_history[camera]
@@ -1376,7 +1515,10 @@ class PtzAutoTracker(threading.Thread):
                     f"{camera}: End object: {obj.obj_data['id']} {obj.obj_data['box']}"
                 )
                 self.tracked_object[camera] = None
-                self._reset_tracked_object_metrics(camera)
+                self.tracked_object_metrics[camera] = {
+                    "max_target_box": AUTOTRACKING_MAX_AREA_RATIO
+                    ** (1 / self.zoom_factor[camera])
+                }
 
     async def camera_maintenance(self, camera):
         # bail and don't check anything if we're not set up yet, calibrating, or
@@ -1413,7 +1555,8 @@ class PtzAutoTracker(threading.Thread):
             self.tracked_object[camera] = None
             self.tracked_object_history[camera].clear()
 
-            await self._wait_until_stopped(camera)
+            while not self.ptz_metrics[camera].motor_stopped.is_set():
+                await self.onvif.get_camera_status(camera)
             logger.debug(
                 f"{camera}: Time is {self.ptz_metrics[camera].frame_time.value}, returning to preset: {autotracker_config.return_preset}"
             )
@@ -1423,8 +1566,10 @@ class PtzAutoTracker(threading.Thread):
             )
 
             # update stored zoom level from preset
-            await self._wait_until_stopped(camera)
+            while not self.ptz_metrics[camera].motor_stopped.is_set():
+                await self.onvif.get_camera_status(camera)
 
+            self.ptz_metrics[camera].tracking_active.clear()
             self.dispatcher.publish(
                 f"{camera}/ptz_autotracker/active", "OFF", retain=False
             )

frigate/ptz/onvif.py

@@ -10,7 +10,8 @@ from pathlib import Path
 from typing import Any
 
 import numpy
-from onvif import ONVIFCamera, ONVIFService
+from onvif import ONVIFCamera, ONVIFError, ONVIFService
+from zeep.exceptions import Fault, TransportError
 
 from frigate.camera import PTZMetrics
 from frigate.config import FrigateConfig, ZoomingModeEnum
@@ -40,14 +41,6 @@ class OnvifCommandEnum(str, Enum):
     focus_out = "focus_out"
 
 
-PAN_TILT_VELOCITY = {
-    OnvifCommandEnum.move_left: (-0.5, 0),
-    OnvifCommandEnum.move_right: (0.5, 0),
-    OnvifCommandEnum.move_up: (0, 0.5),
-    OnvifCommandEnum.move_down: (0, -0.5),
-}
-
-
 class OnvifController:
     ptz_metrics: dict[str, PTZMetrics]
 
@@ -68,6 +61,14 @@ class OnvifController:
         self.loop_thread = threading.Thread(target=self._run_event_loop, daemon=True)
         self.loop_thread.start()
 
+        self.camera_configs = {}
+        for cam_name, cam in config.cameras.items():
+            if not cam.enabled:
+                continue
+            if cam.onvif.host:
+                self.camera_configs[cam_name] = cam
+                self.status_locks[cam_name] = asyncio.Lock()
+
         self.config_subscriber = CameraConfigUpdateSubscriber(
             self.config,
             self.config.cameras,
@@ -91,9 +92,8 @@ class OnvifController:
 
     async def _init_cameras(self) -> None:
         """Initialize all configured cameras."""
-        for cam_name, cam in list(self.config.cameras.items()):
-            if cam.enabled and cam.onvif.host:
-                await self._init_single_camera(cam_name)
+        for cam_name in self.camera_configs:
+            await self._init_single_camera(cam_name)
 
     async def _poll_config_updates(self) -> None:
         """Poll for ONVIF config updates and re-initialize cameras as needed."""
@@ -129,9 +129,13 @@ class OnvifController:
 
     async def _remove_camera(self, cam_name: str) -> None:
         """Tear down the ONVIF session for a camera removed at runtime."""
+        if cam_name not in self.cams and cam_name not in self.camera_configs:
+            return
+
         logger.debug(f"Tearing down ONVIF for {cam_name} after camera removal")
         await self._close_camera(cam_name)
         self.cams.pop(cam_name, None)
+        self.camera_configs.pop(cam_name, None)
         self.failed_cams.pop(cam_name, None)
         self.status_locks.pop(cam_name, None)
 
@@ -139,14 +143,25 @@ class OnvifController:
         """Re-initialize a camera after config change."""
         logger.info(f"Re-initializing ONVIF for {cam_name} due to config change")
 
-        # close existing session and reset state before re-init
+        # close existing session before re-init
         await self._close_camera(cam_name)
+
+        cam = self.config.cameras.get(cam_name)
+        if not cam or not cam.onvif.host:
+            # ONVIF removed from config, clean up
+            self.cams.pop(cam_name, None)
+            self.camera_configs.pop(cam_name, None)
+            self.failed_cams.pop(cam_name, None)
+            return
+
+        # update stored config and reset state
+        self.camera_configs[cam_name] = cam
+        if cam_name not in self.status_locks:
+            self.status_locks[cam_name] = asyncio.Lock()
         self.cams.pop(cam_name, None)
         self.failed_cams.pop(cam_name, None)
 
-        cam = self.config.cameras.get(cam_name)
-        if cam and cam.onvif.host:
-            await self._init_single_camera(cam_name)
+        await self._init_single_camera(cam_name)
 
     async def _init_single_camera(self, cam_name: str) -> bool:
         """Initialize a single camera by name.
@@ -157,12 +172,11 @@ class OnvifController:
         Returns:
             bool: True if initialization succeeded, False otherwise
         """
-        cam = self.config.cameras.get(cam_name)
-        if cam is None:
+        if cam_name not in self.camera_configs:
             logger.error(f"No configuration found for camera {cam_name}")
             return False
 
-        self.status_locks.setdefault(cam_name, asyncio.Lock())
+        cam = self.camera_configs[cam_name]
         try:
             self.cams[cam_name] = {
                 "onvif": ONVIFCamera(
@@ -181,11 +195,12 @@ class OnvifController:
                 "profiles": [],
             }
             return True
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.error(f"Failed to create ONVIF camera instance for {cam_name}: {e}")
             # track initial failures
             self.failed_cams[cam_name] = {
                 "retry_attempts": 0,
+                "last_error": str(e),
                 "last_attempt": time.time(),
             }
             return False
@@ -196,8 +211,7 @@ class OnvifController:
         if camera_config is None:
             return False
 
-        cam = self.cams[camera_name]
-        onvif: ONVIFCamera = cam["onvif"]
+        onvif: ONVIFCamera = self.cams[camera_name]["onvif"]
         try:
             await onvif.update_xaddrs()
         except Exception as e:
@@ -212,7 +226,7 @@ class OnvifController:
             # this will fire an exception if camera is not a ptz
             capabilities = onvif.get_definition("ptz")
             logger.debug(f"Onvif capabilities for {camera_name}: {capabilities}")
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.error(
                 f"Unable to get Onvif capabilities for camera: {camera_name}: {e}"
             )
@@ -221,7 +235,7 @@ class OnvifController:
         try:
             profiles = await media.GetProfiles()
             logger.debug(f"Onvif profiles for {camera_name}: {profiles}")
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.error(
                 f"Unable to get Onvif media profiles for camera: {camera_name}: {e}"
             )
@@ -240,7 +254,7 @@ class OnvifController:
         ]
 
         # store available profiles for API response and log for debugging
-        cam["profiles"] = [
+        self.cams[camera_name]["profiles"] = [
             {"name": getattr(p, "Name", None) or p.token, "token": p.token}
             for p in valid_profiles
         ]
@@ -253,18 +267,19 @@ class OnvifController:
             )
 
         configured_profile = camera_config.onvif.profile
+        profile = None
 
         if configured_profile is not None:
             # match by exact token first, then by name
-            profile = next(
-                (
-                    p
-                    for key in ("token", "Name")
-                    for p in valid_profiles
-                    if getattr(p, key, None) == configured_profile
-                ),
-                None,
-            )
+            for p in valid_profiles:
+                if p.token == configured_profile:
+                    profile = p
+                    break
+            if profile is None:
+                for p in valid_profiles:
+                    if getattr(p, "Name", None) == configured_profile:
+                        profile = p
+                        break
             if profile is None:
                 available = [
                     f"name='{getattr(p, 'Name', None)}', token='{p.token}'"
@@ -289,30 +304,39 @@ class OnvifController:
 
         logger.debug(f"Selected Onvif profile for {camera_name}: {profile}")
 
-        configs = profile.PTZConfiguration
-        logger.debug(f"Onvif ptz config for media profile in {camera_name}: {configs}")
+        # get the PTZ config for the profile
+        try:
+            configs = profile.PTZConfiguration
+            logger.debug(
+                f"Onvif ptz config for media profile in {camera_name}: {configs}"
+            )
+        except Exception as e:
+            logger.error(
+                f"Invalid Onvif PTZ configuration for camera: {camera_name}: {e}"
+            )
+            return False
 
         ptz: ONVIFService = await onvif.create_ptz_service()
-        cam["ptz"] = ptz
+        self.cams[camera_name]["ptz"] = ptz
 
         try:
             imaging: ONVIFService = await onvif.create_imaging_service()
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.debug(f"Imaging service not supported for {camera_name}: {e}")
             imaging = None
-        cam["imaging"] = imaging
+        self.cams[camera_name]["imaging"] = imaging
         try:
             video_sources = await media.GetVideoSources()
             if video_sources and len(video_sources) > 0:
-                cam["video_source_token"] = video_sources[0].token
-        except Exception as e:
+                self.cams[camera_name]["video_source_token"] = video_sources[0].token
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.debug(f"Unable to get video sources for {camera_name}: {e}")
-            cam["video_source_token"] = None
+            self.cams[camera_name]["video_source_token"] = None
 
         # setup continuous moving request
         move_request = ptz.create_type("ContinuousMove")
         move_request.ProfileToken = profile.token
-        cam["move_request"] = move_request
+        self.cams[camera_name]["move_request"] = move_request
 
         # get PTZ configuration options for feature detection and relative movement
         ptz_config = None
@@ -325,7 +349,7 @@ class OnvifController:
             logger.debug(
                 f"Onvif PTZ configuration options for {camera_name}: {ptz_config}"
             )
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.debug(
                 f"Unable to get PTZ configuration options for {camera_name}: {e}"
             )
@@ -351,6 +375,18 @@ class OnvifController:
             autotracking_config.enabled_in_config and autotracking_config.enabled
         )
 
+        # these are local and cost nothing to build, and autotracking can be enabled
+        # after a camera is initialized, so always create them rather than baking the
+        # current config value into init state
+        status_request = ptz.create_type("GetStatus")
+        status_request.ProfileToken = profile.token
+        self.cams[camera_name]["status_request"] = status_request
+
+        service_capabilities_request = ptz.create_type("GetServiceCapabilities")
+        self.cams[camera_name]["service_capabilities_request"] = (
+            service_capabilities_request
+        )
+
         # setup relative move request when FOV relative movement is supported
         if (
             fov_space_id is not None
@@ -359,7 +395,9 @@ class OnvifController:
             # one-off GetStatus to seed Translation field
             status = None
             try:
-                status = await ptz.GetStatus({"ProfileToken": profile.token})
+                one_off_status_request = ptz.create_type("GetStatus")
+                one_off_status_request.ProfileToken = profile.token
+                status = await ptz.GetStatus(one_off_status_request)
                 logger.debug(f"Onvif status for {camera_name}: {status}")
             except Exception as e:
                 logger.warning(f"Unable to get status from camera {camera_name}: {e}")
@@ -386,7 +424,7 @@ class OnvifController:
             # configure zoom on relative move request
             if (
                 autotracking_enabled
-                and autotracking_config.zooming == ZoomingModeEnum.relative
+                and autotracking_config.zooming != ZoomingModeEnum.disabled
             ):
                 zoom_space_id = next(
                     (
@@ -425,16 +463,21 @@ class OnvifController:
                 )
 
             if rel_move_request.Speed is None:
-                rel_move_request.Speed = configs.DefaultPTZSpeed
+                rel_move_request.Speed = configs.DefaultPTZSpeed if configs else None
             logger.debug(
                 f"{camera_name}: Relative move request after setup: {rel_move_request}"
             )
-            cam["relative_move_request"] = rel_move_request
+            self.cams[camera_name]["relative_move_request"] = rel_move_request
+
+        # setup absolute move request
+        abs_move_request = ptz.create_type("AbsoluteMove")
+        abs_move_request.ProfileToken = profile.token
+        self.cams[camera_name]["absolute_move_request"] = abs_move_request
 
         # setup existing presets
         try:
             presets: list[dict] = await ptz.GetPresets({"ProfileToken": profile.token})
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.warning(f"Unable to get presets from camera: {camera_name}: {e}")
             presets = []
 
@@ -447,7 +490,7 @@ class OnvifController:
                 preset_name = preset_name.encode("latin-1").decode("utf-8")
             except (UnicodeEncodeError, UnicodeDecodeError):
                 pass
-            cam["presets"][preset_name.lower()] = preset["token"]
+            self.cams[camera_name]["presets"][preset_name.lower()] = preset["token"]
 
         # get list of supported features
         supported_features = []
@@ -461,40 +504,64 @@ class OnvifController:
         if configs.DefaultRelativePanTiltTranslationSpace:
             supported_features.append("pt-r")
 
-        spaces = getattr(ptz_config, "Spaces", None)
-
         if configs.DefaultRelativeZoomTranslationSpace:
             supported_features.append("zoom-r")
-            if getattr(spaces, "RelativeZoomTranslationSpace", None):
-                cam["relative_zoom_range"] = spaces.RelativeZoomTranslationSpace[0]
+            if ptz_config is not None:
+                try:
+                    self.cams[camera_name]["relative_zoom_range"] = (
+                        ptz_config.Spaces.RelativeZoomTranslationSpace[0]
+                    )
+                except Exception as e:
+                    if autotracking_config.zooming == ZoomingModeEnum.relative:
+                        autotracking_config.zooming = ZoomingModeEnum.disabled
+                        logger.warning(
+                            f"Disabling autotracking zooming for {camera_name}: Relative zoom not supported. Exception: {e}"
+                        )
 
         if configs.DefaultAbsoluteZoomPositionSpace:
             supported_features.append("zoom-a")
-            if getattr(spaces, "AbsoluteZoomPositionSpace", None):
-                cam["absolute_zoom_range"] = spaces.AbsoluteZoomPositionSpace[0]
+            if ptz_config is not None:
+                try:
+                    self.cams[camera_name]["absolute_zoom_range"] = (
+                        ptz_config.Spaces.AbsoluteZoomPositionSpace[0]
+                    )
+                    self.cams[camera_name]["zoom_limits"] = configs.ZoomLimits
+                except Exception as e:
+                    if autotracking_config.zooming != ZoomingModeEnum.disabled:
+                        autotracking_config.zooming = ZoomingModeEnum.disabled
+                        logger.warning(
+                            f"Disabling autotracking zooming for {camera_name}: Absolute zoom not supported. Exception: {e}"
+                        )
 
-        # autotracking zoom needs the range for its mode, and get_camera_status
-        # reads the absolute range in both modes
-        zooming = autotracking_config.zooming
-        if zooming != ZoomingModeEnum.disabled and (
-            "absolute_zoom_range" not in cam or f"{zooming.value}_zoom_range" not in cam
+        # disable autotracking zoom if required ranges are unavailable
+        if autotracking_config.zooming != ZoomingModeEnum.disabled:
+            if autotracking_config.zooming == ZoomingModeEnum.relative:
+                if "relative_zoom_range" not in self.cams[camera_name]:
+                    autotracking_config.zooming = ZoomingModeEnum.disabled
+                    logger.warning(
+                        f"Disabling autotracking zooming for {camera_name}: Relative zoom range unavailable"
+                    )
+            if autotracking_config.zooming == ZoomingModeEnum.absolute:
+                if "absolute_zoom_range" not in self.cams[camera_name]:
+                    autotracking_config.zooming = ZoomingModeEnum.disabled
+                    logger.warning(
+                        f"Disabling autotracking zooming for {camera_name}: Absolute zoom range unavailable"
+                    )
+
+        if (
+            self.cams[camera_name]["video_source_token"] is not None
+            and imaging is not None
         ):
-            autotracking_config.zooming = ZoomingModeEnum.disabled
-            logger.warning(
-                f"Disabling autotracking zooming for {camera_name}: {zooming.value} zoom range unavailable"
-            )
-
-        if cam["video_source_token"] is not None and imaging is not None:
             try:
                 imaging_capabilities = await imaging.GetImagingSettings(
-                    {"VideoSourceToken": cam["video_source_token"]}
+                    {"VideoSourceToken": self.cams[camera_name]["video_source_token"]}
                 )
                 if (
                     hasattr(imaging_capabilities, "Focus")
                     and imaging_capabilities.Focus
                 ):
                     supported_features.append("focus")
-            except Exception as e:
+            except (Fault, ONVIFError, TransportError, Exception) as e:
                 logger.debug(f"Focus not supported for {camera_name}: {e}")
 
         # detect FOV relative movement support
@@ -503,18 +570,17 @@ class OnvifController:
             and configs.DefaultRelativePanTiltTranslationSpace is not None
         ):
             supported_features.append("pt-r-fov")
-            cam["relative_fov_range"] = (
+            self.cams[camera_name]["relative_fov_range"] = (
                 ptz_config.Spaces.RelativePanTiltTranslationSpace[fov_space_id]
             )
 
-        cam["features"] = supported_features
-        cam["init"] = True
+        self.cams[camera_name]["features"] = supported_features
+        self.cams[camera_name]["init"] = True
         return True
 
     async def _stop(self, camera_name: str) -> None:
-        cam = self.cams[camera_name]
-        move_request = cam["move_request"]
-        await cam["ptz"].Stop(
+        move_request = self.cams[camera_name]["move_request"]
+        await self.cams[camera_name]["ptz"].Stop(
             {
                 "ProfileToken": move_request.ProfileToken,
                 "PanTilt": True,
@@ -522,75 +588,88 @@ class OnvifController:
             }
         )
         if (
-            "focus" in cam["features"]
-            and cam["video_source_token"]
-            and cam["imaging"] is not None
+            "focus" in self.cams[camera_name]["features"]
+            and self.cams[camera_name]["video_source_token"]
+            and self.cams[camera_name]["imaging"] is not None
         ):
             try:
-                stop_request = cam["imaging"].create_type("Stop")
-                stop_request.VideoSourceToken = cam["video_source_token"]
-                await cam["imaging"].Stop(stop_request)
-            except Exception as e:
+                stop_request = self.cams[camera_name]["imaging"].create_type("Stop")
+                stop_request.VideoSourceToken = self.cams[camera_name][
+                    "video_source_token"
+                ]
+                await self.cams[camera_name]["imaging"].Stop(stop_request)
+            except (Fault, ONVIFError, TransportError, Exception) as e:
                 logger.warning(f"Failed to stop focus for {camera_name}: {e}")
-        cam["active"] = False
+        self.cams[camera_name]["active"] = False
 
     async def _move(self, camera_name: str, command: OnvifCommandEnum) -> None:
-        cam = self.cams[camera_name]
-
-        if cam["active"]:
+        if self.cams[camera_name]["active"]:
             logger.warning(
                 f"{camera_name} is already performing an action, stopping..."
             )
             await self._stop(camera_name)
 
-        if "pt" not in cam["features"]:
+        if "pt" not in self.cams[camera_name]["features"]:
             logger.error(f"{camera_name} does not support ONVIF pan/tilt movement.")
             return
 
-        cam["active"] = True
-        move_request = cam["move_request"]
+        self.cams[camera_name]["active"] = True
+        move_request = self.cams[camera_name]["move_request"]
 
-        x, y = PAN_TILT_VELOCITY[command]
-        move_request.Velocity = {"PanTilt": {"x": x, "y": y}}
+        if command == OnvifCommandEnum.move_left:
+            move_request.Velocity = {"PanTilt": {"x": -0.5, "y": 0}}
+        elif command == OnvifCommandEnum.move_right:
+            move_request.Velocity = {"PanTilt": {"x": 0.5, "y": 0}}
+        elif command == OnvifCommandEnum.move_up:
+            move_request.Velocity = {
+                "PanTilt": {
+                    "x": 0,
+                    "y": 0.5,
+                }
+            }
+        elif command == OnvifCommandEnum.move_down:
+            move_request.Velocity = {
+                "PanTilt": {
+                    "x": 0,
+                    "y": -0.5,
+                }
+            }
 
         try:
-            await cam["ptz"].ContinuousMove(move_request)
-        except Exception as e:
+            await self.cams[camera_name]["ptz"].ContinuousMove(move_request)
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.warning(f"Onvif sending move request to {camera_name} failed: {e}")
 
     async def _move_relative(self, camera_name: str, pan, tilt, zoom, speed) -> None:
-        cam = self.cams[camera_name]
-
-        if "pt-r-fov" not in cam["features"]:
+        if "pt-r-fov" not in self.cams[camera_name]["features"]:
             logger.error(f"{camera_name} does not support ONVIF RelativeMove (FOV).")
             return
 
         metrics = self.ptz_metrics.get(camera_name)
-        camera_config = self.config.cameras.get(camera_name)
 
-        if metrics is None or camera_config is None:
+        if metrics is None:
             return
 
         logger.debug(
             f"{camera_name} called RelativeMove: pan: {pan} tilt: {tilt} zoom: {zoom}"
         )
 
-        if cam["active"]:
+        if self.cams[camera_name]["active"]:
             logger.warning(
                 f"{camera_name} is already performing an action, not moving..."
             )
             return
 
-        cam["active"] = True
+        self.cams[camera_name]["active"] = True
 
         # only track start_time for autotracking
-        if camera_config.onvif.autotracking.enabled:
+        if metrics.autotracker_enabled.value:
             metrics.motor_stopped.clear()
             logger.debug(f"{camera_name}: PTZ start time: {metrics.frame_time.value}")
             metrics.start_time.value = metrics.frame_time.value
             metrics.stop_time.value = 0
 
-        move_request = cam["relative_move_request"]
+        move_request = self.cams[camera_name]["relative_move_request"]
 
         # function takes in -1 to 1 for pan and tilt, interpolate to the values of the camera.
         # The onvif spec says this can report as +INF and -INF, so this may need to be modified
@@ -598,49 +677,55 @@ class OnvifController:
             pan,
             [-1, 1],
             [
-                cam["relative_fov_range"]["XRange"]["Min"],
-                cam["relative_fov_range"]["XRange"]["Max"],
+                self.cams[camera_name]["relative_fov_range"]["XRange"]["Min"],
+                self.cams[camera_name]["relative_fov_range"]["XRange"]["Max"],
             ],
         )
         tilt = numpy.interp(
             tilt,
             [-1, 1],
             [
-                cam["relative_fov_range"]["YRange"]["Min"],
-                cam["relative_fov_range"]["YRange"]["Max"],
+                self.cams[camera_name]["relative_fov_range"]["YRange"]["Min"],
+                self.cams[camera_name]["relative_fov_range"]["YRange"]["Max"],
             ],
         )
 
-        move_speed = {"PanTilt": {"x": speed, "y": speed}}
+        move_request.Speed = {
+            "PanTilt": {
+                "x": speed,
+                "y": speed,
+            },
+        }
 
         move_request.Translation.PanTilt.x = pan
         move_request.Translation.PanTilt.y = tilt
 
         # include zoom if requested and camera supports relative zoom
-        include_zoom = zoom != 0 and "zoom-r" in cam["features"]
-
-        if include_zoom:
-            move_speed["Zoom"] = {"x": speed}
+        if zoom != 0 and "zoom-r" in self.cams[camera_name]["features"]:
+            move_request.Speed = {
+                "PanTilt": {
+                    "x": speed,
+                    "y": speed,
+                },
+                "Zoom": {"x": speed},
+            }
             move_request["Translation"]["Zoom"] = {"x": zoom}
 
-        move_request.Speed = move_speed
-
-        await cam["ptz"].RelativeMove(move_request)
+        await self.cams[camera_name]["ptz"].RelativeMove(move_request)
 
         # reset after the move request
         move_request.Translation.PanTilt.x = 0
         move_request.Translation.PanTilt.y = 0
 
-        if include_zoom:
+        if zoom != 0 and "zoom-r" in self.cams[camera_name]["features"]:
             del move_request["Translation"]["Zoom"]
 
-        cam["active"] = False
+        self.cams[camera_name]["active"] = False
 
     async def _move_to_preset(self, camera_name: str, preset: str) -> None:
-        cam = self.cams[camera_name]
         preset = preset.lower()
 
-        if preset not in cam["presets"]:
+        if preset not in self.cams[camera_name]["presets"]:
             logger.error(f"{preset} is not a valid preset for {camera_name}")
             return
 
@@ -649,48 +734,44 @@ class OnvifController:
         if metrics is None:
             return
 
-        cam["active"] = True
+        self.cams[camera_name]["active"] = True
         metrics.start_time.value = 0
         metrics.stop_time.value = 0
-        move_request = cam["move_request"]
-        preset_token = cam["presets"][preset]
+        move_request = self.cams[camera_name]["move_request"]
+        preset_token = self.cams[camera_name]["presets"][preset]
 
-        await cam["ptz"].GotoPreset(
+        await self.cams[camera_name]["ptz"].GotoPreset(
             {
                 "ProfileToken": move_request.ProfileToken,
                 "PresetToken": preset_token,
             }
         )
 
-        cam["active"] = False
+        self.cams[camera_name]["active"] = False
 
     async def _zoom(self, camera_name: str, command: OnvifCommandEnum) -> None:
-        cam = self.cams[camera_name]
-
-        if cam["active"]:
+        if self.cams[camera_name]["active"]:
             logger.warning(
                 f"{camera_name} is already performing an action, stopping..."
             )
             await self._stop(camera_name)
 
-        if "zoom" not in cam["features"]:
+        if "zoom" not in self.cams[camera_name]["features"]:
             logger.error(f"{camera_name} does not support ONVIF zooming.")
             return
 
-        cam["active"] = True
-        move_request = cam["move_request"]
+        self.cams[camera_name]["active"] = True
+        move_request = self.cams[camera_name]["move_request"]
 
         if command == OnvifCommandEnum.zoom_in:
             move_request.Velocity = {"Zoom": {"x": 0.5}}
         elif command == OnvifCommandEnum.zoom_out:
             move_request.Velocity = {"Zoom": {"x": -0.5}}
 
-        await cam["ptz"].ContinuousMove(move_request)
+        await self.cams[camera_name]["ptz"].ContinuousMove(move_request)
 
     async def _zoom_absolute(self, camera_name: str, zoom, speed) -> None:
-        cam = self.cams[camera_name]
-
-        if "zoom-a" not in cam["features"]:
+        if "zoom-a" not in self.cams[camera_name]["features"]:
             logger.error(f"{camera_name} does not support ONVIF AbsoluteMove zooming.")
             return
 
@@ -701,59 +782,56 @@ class OnvifController:
 
         logger.debug(f"{camera_name} called AbsoluteMove: zoom: {zoom}")
 
-        if cam["active"]:
+        if self.cams[camera_name]["active"]:
             logger.warning(
                 f"{camera_name} is already performing an action, not moving..."
             )
             return
 
-        cam["active"] = True
+        self.cams[camera_name]["active"] = True
         metrics.motor_stopped.clear()
         logger.debug(f"{camera_name}: PTZ start time: {metrics.frame_time.value}")
         metrics.start_time.value = metrics.frame_time.value
         metrics.stop_time.value = 0
+        move_request = self.cams[camera_name]["absolute_move_request"]
+
         # function takes in 0 to 1 for zoom, interpolate to the values of the camera.
         zoom = numpy.interp(
             zoom,
             [0, 1],
             [
-                cam["absolute_zoom_range"]["XRange"]["Min"],
-                cam["absolute_zoom_range"]["XRange"]["Max"],
+                self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Min"],
+                self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Max"],
             ],
         )
 
+        move_request.Speed = {"Zoom": speed}
+        move_request.Position = {"Zoom": zoom}
+
         logger.debug(f"{camera_name}: Absolute zoom: {zoom}")
 
-        await cam["ptz"].AbsoluteMove(
-            {
-                "ProfileToken": cam["move_request"].ProfileToken,
-                "Position": {"Zoom": zoom},
-                "Speed": {"Zoom": speed},
-            }
-        )
+        await self.cams[camera_name]["ptz"].AbsoluteMove(move_request)
 
-        cam["active"] = False
+        self.cams[camera_name]["active"] = False
 
     async def _focus(self, camera_name: str, command: OnvifCommandEnum) -> None:
-        cam = self.cams[camera_name]
-
-        if cam["active"]:
+        if self.cams[camera_name]["active"]:
             logger.warning(
                 f"{camera_name} is already performing an action, not moving..."
             )
             await self._stop(camera_name)
 
         if (
-            "focus" not in cam["features"]
-            or not cam["video_source_token"]
-            or cam["imaging"] is None
+            "focus" not in self.cams[camera_name]["features"]
+            or not self.cams[camera_name]["video_source_token"]
+            or self.cams[camera_name]["imaging"] is None
         ):
             logger.error(f"{camera_name} does not support ONVIF continuous focus.")
             return
 
-        cam["active"] = True
-        move_request = cam["imaging"].create_type("Move")
-        move_request.VideoSourceToken = cam["video_source_token"]
+        self.cams[camera_name]["active"] = True
+        move_request = self.cams[camera_name]["imaging"].create_type("Move")
+        move_request.VideoSourceToken = self.cams[camera_name]["video_source_token"]
         move_request.Focus = {
             "Continuous": {
                 "Speed": 0.5 if command == OnvifCommandEnum.focus_in else -0.5
@@ -761,10 +839,10 @@ class OnvifController:
         }
 
         try:
-            await cam["imaging"].Move(move_request)
-        except Exception as e:
+            await self.cams[camera_name]["imaging"].Move(move_request)
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.warning(f"Onvif sending focus request to {camera_name} failed: {e}")
-            cam["active"] = False
+            self.cams[camera_name]["active"] = False
 
     async def handle_command_async(
         self, camera_name: str, command: OnvifCommandEnum, param: str = ""
@@ -805,7 +883,7 @@ class OnvifController:
                 await self._focus(camera_name, command)
             else:
                 await self._move(camera_name, command)
-        except Exception as e:
+        except (Fault, ONVIFError, TransportError, Exception) as e:
             logger.error(f"Unable to handle onvif command: {e}")
 
     def handle_command(
@@ -828,15 +906,6 @@ class OnvifController:
                 f"Error executing command {command} for camera {camera_name}: {e}"
             )
 
-    def _camera_info(self, camera_name: str) -> dict[str, Any]:
-        cam = self.cams[camera_name]
-        return {
-            "name": camera_name,
-            "features": cam["features"],
-            "presets": list(cam["presets"]),
-            "profiles": cam["profiles"],
-        }
-
     async def get_camera_info(self, camera_name: str) -> dict[str, Any]:
         """
         Get ptz capabilities and presets, attempting to reconnect if ONVIF is configured
@@ -860,21 +929,60 @@ class OnvifController:
             return {}
 
         if camera_name in self.cams.keys() and self.cams[camera_name]["init"]:
-            return self._camera_info(camera_name)
+            return {
+                "name": camera_name,
+                "features": self.cams[camera_name]["features"],
+                "presets": list(self.cams[camera_name]["presets"].keys()),
+                "profiles": self.cams[camera_name].get("profiles", []),
+            }
 
         if camera_name not in self.cams.keys() and camera_name in self.config.cameras:
             success = await self._init_single_camera(camera_name)
             if not success:
                 return {}
 
-        failed = self.failed_cams.get(camera_name, {})
-        attempts = failed.get("retry_attempts", 0)
-        last_attempt = failed.get("last_attempt", 0)
-
         # Reset retry count after timeout
+        attempts = self.failed_cams.get(camera_name, {}).get("retry_attempts", 0)
+        last_attempt = self.failed_cams.get(camera_name, {}).get("last_attempt", 0)
+
         if last_attempt and (time.time() - last_attempt) > self.reset_timeout:
             logger.debug(f"Resetting retry count for {camera_name} after timeout")
             attempts = 0
+            self.failed_cams[camera_name]["retry_attempts"] = 0
+
+        # Attempt initialization/reconnection
+        if attempts < self.max_retries:
+            logger.info(
+                f"Attempting ONVIF initialization for {camera_name} (retry {attempts + 1}/{self.max_retries})"
+            )
+            try:
+                if await self._init_onvif(camera_name):
+                    if camera_name in self.failed_cams:
+                        del self.failed_cams[camera_name]
+                    return {
+                        "name": camera_name,
+                        "features": self.cams[camera_name]["features"],
+                        "presets": list(self.cams[camera_name]["presets"].keys()),
+                    }
+                else:
+                    logger.warning(f"ONVIF initialization failed for {camera_name}")
+                    self.failed_cams[camera_name] = {
+                        "retry_attempts": attempts + 1,
+                        "last_attempt": time.time(),
+                    }
+            except Exception as e:
+                logger.error(
+                    f"Error during ONVIF initialization for {camera_name}: {e}"
+                )
+                if camera_name not in self.failed_cams:
+                    self.failed_cams[camera_name] = {"retry_attempts": 0}
+                self.failed_cams[camera_name].update(
+                    {
+                        "retry_attempts": attempts + 1,
+                        "last_error": str(e),
+                        "last_attempt": time.time(),
+                    }
+                )
 
         if attempts >= self.max_retries:
             remaining_time = max(
@@ -883,24 +991,8 @@ class OnvifController:
             logger.error(
                 f"Too many ONVIF initialization attempts for {camera_name}, retry in {remaining_time} minute{'s' if remaining_time != 1 else ''}"
             )
-            return {}
 
-        logger.info(
-            f"Attempting ONVIF initialization for {camera_name} (retry {attempts + 1}/{self.max_retries})"
-        )
-        try:
-            if await self._init_onvif(camera_name):
-                self.failed_cams.pop(camera_name, None)
-                return self._camera_info(camera_name)
-
-            logger.warning(f"ONVIF initialization failed for {camera_name}")
-        except Exception as e:
-            logger.error(f"Error during ONVIF initialization for {camera_name}: {e}")
-
-        self.failed_cams[camera_name] = {
-            "retry_attempts": attempts + 1,
-            "last_attempt": time.time(),
-        }
+        logger.debug(f"Could not initialize ONVIF for {camera_name}")
         return {}
 
     async def get_service_capabilities(self, camera_name: str) -> None:
@@ -908,13 +1000,16 @@ class OnvifController:
             logger.error(f"ONVIF is not configured for {camera_name}")
             return {}
 
-        cam = self.cams[camera_name]
-
-        if not cam["init"]:
+        if not self.cams[camera_name]["init"]:
             await self._init_onvif(camera_name)
 
+        service_capabilities_request = self.cams[camera_name][
+            "service_capabilities_request"
+        ]
         try:
-            service_capabilities = await cam["ptz"].GetServiceCapabilities()
+            service_capabilities = await self.cams[camera_name][
+                "ptz"
+            ].GetServiceCapabilities(service_capabilities_request)
 
             logger.debug(
                 f"Onvif service capabilities for {camera_name}: {service_capabilities}"
@@ -940,16 +1035,13 @@ class OnvifController:
             if metrics is None or camera_config is None:
                 return
 
-            cam = self.cams[camera_name]
-
-            if not cam["init"]:
+            if not self.cams[camera_name]["init"]:
                 if not await self._init_onvif(camera_name):
                     return
 
+            status_request = self.cams[camera_name]["status_request"]
             try:
-                status = await cam["ptz"].GetStatus(
-                    {"ProfileToken": cam["move_request"].ProfileToken}
-                )
+                status = await self.cams[camera_name]["ptz"].GetStatus(status_request)
             except Exception:
                 pass  # We're unsupported, that'll be reported in the next check.
 
@@ -980,7 +1072,7 @@ class OnvifController:
             if pan_tilt_status == "IDLE" and (
                 zoom_status is None or zoom_status == "IDLE"
             ):
-                cam["active"] = False
+                self.cams[camera_name]["active"] = False
                 if not metrics.motor_stopped.is_set():
                     metrics.motor_stopped.set()
 
@@ -990,7 +1082,7 @@ class OnvifController:
 
                     metrics.stop_time.value = metrics.frame_time.value
             else:
-                cam["active"] = True
+                self.cams[camera_name]["active"] = True
                 if metrics.motor_stopped.is_set():
                     metrics.motor_stopped.clear()
 
@@ -1006,8 +1098,8 @@ class OnvifController:
                 metrics.zoom_level.value = numpy.interp(
                     round(status.Position.Zoom.x, 2),
                     [
-                        cam["absolute_zoom_range"]["XRange"]["Min"],
-                        cam["absolute_zoom_range"]["XRange"]["Max"],
+                        self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Min"],
+                        self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Max"],
                     ],
                     [0, 1],
                 )
@@ -1046,7 +1138,7 @@ class OnvifController:
 
     def close(self) -> None:
         """Gracefully shut down the ONVIF controller."""
-        if self.loop.is_closed():
+        if not hasattr(self, "loop") or self.loop.is_closed():
             logger.debug("ONVIF controller already closed")
             return
 
@@ -1063,6 +1155,13 @@ class OnvifController:
 
         self.config_subscriber.stop()
 
-        self.loop.call_soon_threadsafe(self.loop.stop)
+        def stop_and_cleanup():
+            try:
+                self.loop.stop()
+            except Exception as e:
+                logger.error(f"Error during loop cleanup: {e}")
+
+        # Schedule stop and cleanup in the loop thread
+        self.loop.call_soon_threadsafe(stop_and_cleanup)
 
         self.loop_thread.join()

frigate/stats/util.py

@@ -236,15 +236,6 @@ def skipped_percent(skipped_fps: float, camera_fps: float, enabled: bool) -> flo
     return round(skipped_fps / camera_fps * 100, 1)
 
 
-def get_go2rtc_pid(cpu_usages: dict[str, dict[str, Any]]) -> int | None:
-    """Find the pid of the running go2rtc process in the cpu usages."""
-    for pid, usage in cpu_usages.items():
-        if usage.get("cmdline", "").split(" ")[0].endswith("/go2rtc"):
-            return int(pid)
-
-    return None
-
-
 def stats_snapshot(
     config: FrigateConfig,
     stats_tracking: StatsTrackingTypes,
@@ -365,14 +356,6 @@ def stats_snapshot(
 
     stats["service"]["storage"]["/dev/shm"] = calculate_shm_requirements(config)
 
-    cpu_usages = stats.get("cpu_usages", {})
-
-    # go2rtc is supervised by s6, so its pid changes when s6 restarts it
-    go2rtc_pid = get_go2rtc_pid(cpu_usages)
-
-    if go2rtc_pid is not None:
-        stats_tracking["processes"]["go2rtc"] = go2rtc_pid
-
     stats["processes"] = {}
     for name, pid in stats_tracking["processes"].items():
         stats["processes"][name] = {
@@ -381,6 +364,7 @@ def stats_snapshot(
 
     # Embed cpu/mem stats into detectors, cameras, and processes
     # so history consumers don't need the full cpu_usages dict
+    cpu_usages = stats.get("cpu_usages", {})
 
     for det_stats in stats["detectors"].values():
         pid_str = str(det_stats.get("pid", ""))

frigate/test/http_api/test_http_app.py

@@ -4,7 +4,6 @@ from unittest.mock import Mock, patch
 
 import frigate.genai
 from frigate.config import GenAIProviderEnum
-from frigate.config.env import FRIGATE_ENV_VARS
 from frigate.const import MODEL_CACHE_DIR, REDACTED_CREDENTIAL_SENTINEL
 from frigate.genai import GenAIClient
 from frigate.models import Event, Recordings, ReviewSegment
@@ -112,30 +111,6 @@ class TestHttpApp(BaseTestHttp):
             mqtt = response.json()["mqtt"]
             assert mqtt["password"] == REDACTED_CREDENTIAL_SENTINEL
 
-    def test_config_response_hides_notification_email_from_viewers(self):
-        self.minimal_config["notifications"] = {"email": "{FRIGATE_TEST_EMAIL}"}
-
-        with patch.dict(FRIGATE_ENV_VARS, {"FRIGATE_TEST_EMAIL": "me@example.com"}):
-            app = super().create_app()
-
-        assert app.frigate_config.notifications.email == "me@example.com"
-
-        with AuthTestClient(app) as client:
-            response = client.get(
-                "/config",
-                headers={"remote-user": "viewer", "remote-role": "viewer"},
-            )
-            assert response.status_code == 200
-            config = response.json()
-            assert config["notifications"]["email"] == REDACTED_CREDENTIAL_SENTINEL
-            assert (
-                config["cameras"]["front_door"]["notifications"]["email"]
-                == REDACTED_CREDENTIAL_SENTINEL
-            )
-
-            response = client.get("/config")
-            assert response.json()["notifications"]["email"] == "me@example.com"
-
     def test_config_response_keeps_plus_model_reference(self):
         model_id = "test_plus_reference"
         model_path = os.path.join(MODEL_CACHE_DIR, model_id)

frigate/test/test_camera_watchdog.py

@@ -59,6 +59,7 @@ def build_watchdog(
             MagicMock(),
         )
 
+    watchdog.requestor = MagicMock()
     return watchdog
 
 
@@ -107,8 +108,8 @@ class TestCameraWatchdogStreamHealth(unittest.TestCase):
     def test_status_goes_to_the_matching_role_topic(self):
         watchdog = self._build_watchdog()
 
-        watchdog.record_status[STREAM_TYPE_MAIN].send("online", 100.0)
-        watchdog.record_status[STREAM_TYPE_SUB].send("offline", 100.0)
+        watchdog._send_record_status(STREAM_TYPE_MAIN, "online", 100.0)
+        watchdog._send_record_status(STREAM_TYPE_SUB, "offline", 100.0)
 
         watchdog.requestor.send_data.assert_any_call(
             "front_door/status/record", "online"
@@ -120,9 +121,9 @@ class TestCameraWatchdogStreamHealth(unittest.TestCase):
     def test_status_is_cached_per_stream(self):
         watchdog = self._build_watchdog()
 
-        watchdog.record_status[STREAM_TYPE_MAIN].send("online", 100.0)
-        watchdog.record_status[STREAM_TYPE_SUB].send("online", 100.0)
-        watchdog.record_status[STREAM_TYPE_MAIN].send("online", 100.0)
+        watchdog._send_record_status(STREAM_TYPE_MAIN, "online", 100.0)
+        watchdog._send_record_status(STREAM_TYPE_SUB, "online", 100.0)
+        watchdog._send_record_status(STREAM_TYPE_MAIN, "online", 100.0)
 
         assert watchdog.requestor.send_data.call_count == 2
 

frigate/test/test_config.py

@@ -6,7 +6,6 @@ from copy import deepcopy
 from unittest.mock import patch
 
 import numpy as np
-import requests
 from pydantic import ValidationError
 from ruamel.yaml.constructor import DuplicateKeyError
 
@@ -1596,31 +1595,6 @@ class TestConfig(unittest.TestCase):
         frigate_config = FrigateConfig(**config)
         assert frigate_config.primary_model.merged_labelmap[0] == "amazon"
 
-    @patch(
-        "frigate.plus.PlusApi.get_model_download_url",
-        side_effect=requests.exceptions.ConnectionError,
-    )
-    def test_plus_unreachable_is_validation_error(self, _):
-        config = {
-            "mqtt": {"host": "mqtt"},
-            "models": [{"path": "plus://unreachable", "devices": ["cpu"]}],
-            "cameras": {
-                "back": {
-                    "ffmpeg": {
-                        "inputs": [
-                            {
-                                "path": "rtsp://10.0.0.1:554/video",
-                                "roles": ["detect"],
-                            },
-                        ]
-                    },
-                }
-            },
-        }
-
-        with self.assertRaisesRegex(ValidationError, "Unable to connect to Frigate+"):
-            FrigateConfig(**config)
-
     def test_fails_on_invalid_role(self):
         config = {
             "mqtt": {"host": "mqtt"},

frigate/test/test_go2rtc_pid_stats.py

@@ -1,70 +0,0 @@
-"""Tests for resolving the go2rtc pid from cpu usages."""
-
-import unittest
-from types import SimpleNamespace
-from unittest.mock import Mock, patch
-
-from frigate.stats.util import get_go2rtc_pid, stats_snapshot
-
-
-class TestGo2rtcPid(unittest.TestCase):
-    def test_finds_go2rtc_by_binary_path(self):
-        cpu_usages = {
-            "frigate.full_system": {"cpu": "1.0", "mem": "2.0"},
-            "100": {"cmdline": "ffmpeg -i rtsp://127.0.0.1:8554/go2rtc_cam"},
-            "200": {
-                "cmdline": "/usr/local/go2rtc/bin/go2rtc -config=/dev/shm/go2rtc.yaml"
-            },
-            "300": {"cmdline": "frigate.recording"},
-        }
-
-        self.assertEqual(get_go2rtc_pid(cpu_usages), 200)
-
-    def test_finds_custom_go2rtc_binary(self):
-        self.assertEqual(get_go2rtc_pid({"42": {"cmdline": "/config/go2rtc"}}), 42)
-
-    def test_returns_none_when_go2rtc_is_not_running(self):
-        self.assertIsNone(get_go2rtc_pid({"100": {"cmdline": "ffmpeg -i x"}}))
-        self.assertIsNone(get_go2rtc_pid({}))
-
-
-class TestGo2rtcPidInSnapshot(unittest.TestCase):
-    def snapshot(self, tracking: dict, go2rtc_pid: int) -> dict:
-        def update_stats(stats: dict) -> None:
-            stats["cpu_usages"] = {
-                str(go2rtc_pid): {
-                    "cmdline": "/usr/local/go2rtc/bin/go2rtc -config=x",
-                    "cpu": str(go2rtc_pid / 100),
-                    "mem": str(go2rtc_pid / 10),
-                }
-            }
-
-        config = SimpleNamespace(
-            cameras={},
-            telemetry=SimpleNamespace(stats=SimpleNamespace(network_bandwidth=False)),
-        )
-        hardware_stats = Mock()
-        hardware_stats.update_stats.side_effect = update_stats
-
-        with (
-            patch("frigate.stats.util.get_detector_stats", return_value={}),
-            patch("frigate.stats.util.embeddings_stats", return_value={}),
-            patch("frigate.stats.util.calculate_shm_requirements", return_value={}),
-        ):
-            return stats_snapshot(config, tracking, hardware_stats)
-
-    def test_snapshot_follows_go2rtc_restart(self):
-        tracking = {
-            "camera_metrics": {},
-            "detectors": {},
-            "started": 0,
-            "latest_frigate_version": "",
-            "processes": {"go2rtc": 200, "recording": 50},
-            "storage_maintainer": None,
-        }
-
-        first = self.snapshot(tracking, 200)["processes"]["go2rtc"]
-        self.assertEqual(first, {"pid": 200, "cpu": "2.0", "mem": "20.0"})
-
-        restarted = self.snapshot(tracking, 300)["processes"]["go2rtc"]
-        self.assertEqual(restarted, {"pid": 300, "cpu": "3.0", "mem": "30.0"})

frigate/test/test_motion_detector.py

@@ -29,6 +29,7 @@ class TestImprovedMotionDetector(unittest.TestCase):
 
         class DummyPTZ:
             def __init__(self):
+                self.autotracker_enabled = _Stub(False)
                 self.motor_stopped = _Stub(False)
                 self.stop_time = _Stub(0)
 

frigate/test/test_ptz_autotrack.py

@@ -7,8 +7,9 @@ KeyError on the autotracker thread or silently keep the wrong state:
 
 - autotracker_init only got an entry for cameras enabled when PtzAutoTracker was
   constructed, so runtime-enabled cameras raised KeyError on lookup.
-- _disable only changed the main process config, so the camera process kept
-  running its motion estimator for a camera that could not autotrack.
+- ptz_metrics autotracker_enabled is what the camera processes read, but nothing
+  updated it when autotracking was enabled through a config save, so it stayed
+  False and the tracker never built a motion estimator.
 """
 
 import unittest
@@ -16,8 +17,7 @@ from unittest.mock import MagicMock
 
 from frigate.camera import PTZMetrics
 from frigate.config import FrigateConfig
-from frigate.config.camera.updater import CameraConfigUpdateEnum
-from frigate.ptz.autotrack import PtzAutoTracker, calculate_max_target_box
+from frigate.ptz.autotrack import PtzAutoTracker
 
 CAMERA = "ptz_cam"
 
@@ -53,9 +53,8 @@ def _make_tracker(autotracking_enabled: bool = True) -> PtzAutoTracker:
     onvif over the network. Only the config/metrics state is relevant here."""
     tracker = PtzAutoTracker.__new__(PtzAutoTracker)
     tracker.config = _config(autotracking_enabled)
-    tracker.ptz_metrics = {CAMERA: PTZMetrics()}
+    tracker.ptz_metrics = {CAMERA: PTZMetrics(autotracker_enabled=False)}
     tracker.onvif = MagicMock()
-    tracker.dispatcher = MagicMock()
     tracker.config_subscriber = MagicMock()
     tracker.autotracker_init = {}
     tracker.calibrating = {}
@@ -84,49 +83,47 @@ class TestAutotrackerInitGuards(unittest.IsolatedAsyncioTestCase):
         tracker.onvif.get_camera_status.assert_not_called()
 
 
-class TestAutotrackerEnqueueMove(unittest.TestCase):
-    def _enqueue(self, pan: float, tilt: float, zoom: float) -> MagicMock:
-        tracker = _make_tracker()
-        tracker.move_queues = {CAMERA: MagicMock()}
-        tracker.move_queue_locks = {CAMERA: MagicMock()}
-        tracker.move_queue_locks[CAMERA].locked.return_value = False
-
-        tracker._enqueue_move(CAMERA, 1000.0, pan, tilt, zoom)
-
-        return tracker.onvif.loop.call_soon_threadsafe
-
-    def test_move_is_clipped_to_the_onvif_range(self) -> None:
-        # velocity estimates can push the predicted centroid outside the frame
-        call_soon = self._enqueue(1.7, -2.5, 0.4)
-
-        call_soon.assert_called_once()
-        self.assertEqual(call_soon.call_args.args[1], (1000.0, 1.0, -1.0, 0.4))
-
-    def test_empty_move_is_not_enqueued(self) -> None:
-        self._enqueue(0, 0, 0).assert_not_called()
-
-
-class TestAutotrackerDisable(unittest.TestCase):
-    def test_disable_publishes_to_camera_process(self) -> None:
+class TestAutotrackerMetricSync(unittest.TestCase):
+    def test_metric_follows_config_when_enabled_by_update(self) -> None:
+        # autotracking enabled via a config save: the metric was seeded False when
+        # the camera was added and nothing else updates it
         tracker = _make_tracker(autotracking_enabled=True)
+        metrics = tracker.ptz_metrics[CAMERA]
+        self.assertFalse(metrics.autotracker_enabled.value)
 
-        tracker._disable(CAMERA, "onvif connection failed")
+        tracker.config_subscriber.check_for_updates.return_value = {"onvif": [CAMERA]}
+        tracker.check_for_updates()
 
-        autotracking = tracker.config.cameras[CAMERA].onvif.autotracking
-        self.assertFalse(autotracking.enabled)
+        self.assertTrue(metrics.autotracker_enabled.value)
 
-        publish = tracker.dispatcher.config_updater.publish_update
-        publish.assert_called_once()
-        topic, payload = publish.call_args.args
-        self.assertEqual(topic.update_type, CameraConfigUpdateEnum.autotracking)
-        self.assertEqual(topic.camera, CAMERA)
-        self.assertIs(payload, autotracking)
+    def test_metric_follows_config_when_disabled_by_update(self) -> None:
+        tracker = _make_tracker(autotracking_enabled=False)
+        metrics = tracker.ptz_metrics[CAMERA]
+        metrics.autotracker_enabled.value = True
 
+        tracker.config_subscriber.check_for_updates.return_value = {
+            "autotracking": [CAMERA]
+        }
+        tracker.check_for_updates()
 
-class TestMaxTargetBox(unittest.TestCase):
-    def test_follows_zoom_factor(self) -> None:
-        self.assertAlmostEqual(calculate_max_target_box(0.5), 0.6**2)
-        self.assertAlmostEqual(calculate_max_target_box(0.25), 0.6**4)
+        self.assertFalse(metrics.autotracker_enabled.value)
+
+    def test_metric_sync_skips_camera_without_metrics(self) -> None:
+        # `add` reaches the maintainer and the autotracker on separate threads with
+        # no ordering guarantee, so the metrics may not exist yet
+        tracker = _make_tracker()
+        tracker.ptz_metrics = {}
+        tracker.config_subscriber.check_for_updates.return_value = {"add": [CAMERA]}
+
+        tracker.check_for_updates()
+
+    def test_metric_sync_skips_unknown_camera(self) -> None:
+        tracker = _make_tracker()
+        tracker.config_subscriber.check_for_updates.return_value = {
+            "add": ["not_in_config"]
+        }
+
+        tracker.check_for_updates()
 
 
 if __name__ == "__main__":

frigate/test/test_ptz_onvif.py

@@ -2,9 +2,14 @@
 
 Regression coverage for a camera that is initialized while autotracking is off and
 has it enabled later, which is the normal wizard flow: set the camera up first,
-configure autotracking afterwards. get_camera_status skips its re-init branch when
-init is True, so everything it reads must exist whether or not autotracking was
-enabled at init time.
+configure autotracking afterwards. The autotracking-only request objects used to
+be created only when autotracking was enabled at init time, so the camera was left
+with init=True but no status_request. get_camera_status skips its re-init branch
+when init is True, so it went straight to the missing key and raised KeyError on
+the tracking thread.
+
+The request objects are built from the locally parsed WSDL and cost no network, so
+they are always created and init=True now implies they exist.
 
 Also covers the inverse direction: the ptz movement timestamps must not be written
 for a camera that has autotracking off, because nothing clears them back out.
@@ -94,6 +99,7 @@ def _make_controller(autotracking_enabled: bool) -> OnvifController:
     controller.config = config
     controller.cams = {CAMERA: {"onvif": _make_onvif_camera(), "init": False}}
     controller.failed_cams = {}
+    controller.camera_configs = {CAMERA: config.cameras[CAMERA]}
     controller.ptz_metrics = {CAMERA: MagicMock()}
     return controller
 
@@ -104,6 +110,7 @@ def _make_move_controller(autotracking_enabled: bool) -> OnvifController:
     config = _config(autotracking_enabled)
     controller = OnvifController.__new__(OnvifController)
     controller.config = config
+    controller.camera_configs = {CAMERA: config.cameras[CAMERA]}
     controller.failed_cams = {}
 
     ptz = MagicMock()
@@ -121,30 +128,45 @@ def _make_move_controller(autotracking_enabled: bool) -> OnvifController:
             },
         }
     }
-    controller.ptz_metrics = {CAMERA: PTZMetrics()}
+    controller.ptz_metrics = {
+        CAMERA: PTZMetrics(autotracker_enabled=autotracking_enabled)
+    }
     return controller
 
 
 class TestOnvifInitRequests(unittest.IsolatedAsyncioTestCase):
-    async def test_camera_status_independent_of_autotracking_at_init(self) -> None:
+    async def test_status_request_created_when_autotracking_disabled(self) -> None:
         # the wizard flow: onvif configured first, autotracking enabled later
+        controller = _make_controller(autotracking_enabled=False)
+
+        self.assertTrue(await controller._init_onvif(CAMERA))
+
+        cam = controller.cams[CAMERA]
+        self.assertTrue(cam["init"])
+        self.assertIn("status_request", cam)
+        self.assertIn("service_capabilities_request", cam)
+
+    async def test_status_request_created_when_autotracking_enabled(self) -> None:
+        controller = _make_controller(autotracking_enabled=True)
+
+        self.assertTrue(await controller._init_onvif(CAMERA))
+
+        cam = controller.cams[CAMERA]
+        self.assertIn("status_request", cam)
+        self.assertIn("service_capabilities_request", cam)
+
+    async def test_init_implies_status_request_exists(self) -> None:
+        # the invariant get_camera_status relies on: it skips re-init when init is
+        # True and then reads status_request without guarding
         for autotracking_enabled in (True, False):
             with self.subTest(autotracking_enabled=autotracking_enabled):
                 controller = _make_controller(autotracking_enabled)
-                controller.status_locks = {CAMERA: asyncio.Lock()}
 
-                self.assertTrue(await controller._init_onvif(CAMERA))
+                await controller._init_onvif(CAMERA)
 
-                status = MagicMock()
-                status.MoveStatus.PanTilt = "IDLE"
-                status.MoveStatus.Zoom = "IDLE"
-                ptz = controller.cams[CAMERA]["ptz"]
-                ptz.GetStatus = AsyncMock(return_value=status)
-
-                await controller.get_camera_status(CAMERA)
-
-                ptz.GetStatus.assert_awaited_once_with({"ProfileToken": "profile_1"})
-                self.assertFalse(controller.cams[CAMERA]["active"])
+                cam = controller.cams[CAMERA]
+                if cam["init"]:
+                    self.assertEqual(cam["status_request"].request_type, "GetStatus")
 
     async def test_requests_built_without_contacting_camera(self) -> None:
         # create_type is a local WSDL lookup; cameras that do not implement

frigate/track/norfair_tracker.py

@@ -223,7 +223,7 @@ class NorfairTracker(ObjectTracker):
             ),
         }
 
-        if self.camera_config.onvif.autotracking.enabled:
+        if self.ptz_metrics.autotracker_enabled.value:
             self.ptz_motion_estimator = PtzMotionEstimator(
                 self.camera_config, self.ptz_metrics
             )
@@ -515,7 +515,7 @@ class NorfairTracker(ObjectTracker):
         yuv_frame: np.ndarray | None = None
 
         if (
-            self.camera_config.onvif.autotracking.enabled
+            self.ptz_metrics.autotracker_enabled.value
             or self.detect_config.stationary.classifier
         ):
             yuv_frame = self.frame_manager.get(
@@ -534,7 +534,7 @@ class NorfairTracker(ObjectTracker):
             points = np.array([[obj[2][0], obj[2][1]], [obj[2][2], obj[2][3]]])
 
             embedding = None
-            if self.camera_config.onvif.autotracking.enabled:
+            if self.ptz_metrics.autotracker_enabled.value:
                 embedding = get_histogram(
                     yuv_frame, obj[2][0], obj[2][1], obj[2][2], obj[2][3]
                 )
@@ -559,7 +559,7 @@ class NorfairTracker(ObjectTracker):
 
         coord_transformations = None
 
-        if self.camera_config.onvif.autotracking.enabled:
+        if self.ptz_metrics.autotracker_enabled.value:
             # we must have been enabled by mqtt, so set up the estimator
             if not self.ptz_motion_estimator:
                 self.ptz_motion_estimator = PtzMotionEstimator(

frigate/track/object_processing.py

@@ -41,7 +41,7 @@ from frigate.const import (
 )
 from frigate.events.types import EventStateEnum, EventTypeEnum
 from frigate.models import Event, ReviewSegment, Timeline
-from frigate.ptz.autotrack import PtzAutoTracker
+from frigate.ptz.autotrack import PtzAutoTrackerThread
 from frigate.track.tracked_object import TrackedObject
 from frigate.util.image import SharedMemoryFrameManager
 
@@ -60,7 +60,7 @@ class TrackedObjectProcessor(threading.Thread):
         config: FrigateConfig,
         dispatcher: Dispatcher,
         tracked_objects_queue: MpQueue,
-        ptz_autotracker_thread: PtzAutoTracker,
+        ptz_autotracker_thread: PtzAutoTrackerThread,
         stop_event: MpEvent,
     ) -> None:
         super().__init__(name="detected_frames_processor")
@@ -153,7 +153,7 @@ class TrackedObjectProcessor(threading.Thread):
             )
 
         def autotrack(camera: str, obj: TrackedObject, frame_name: str) -> None:
-            self.ptz_autotracker_thread.autotrack_object(camera, obj)
+            self.ptz_autotracker_thread.ptz_autotracker.autotrack_object(camera, obj)
 
         def end(camera: str, obj: TrackedObject, frame_name: str) -> None:
             # populate has_snapshot
@@ -177,7 +177,7 @@ class TrackedObjectProcessor(threading.Thread):
                     "type": "end",
                 }
                 self.dispatcher.publish("events", json.dumps(message), retain=False)
-                self.ptz_autotracker_thread.end_object(camera, obj)
+                self.ptz_autotracker_thread.ptz_autotracker.end_object(camera, obj)
 
             self.event_sender.publish(
                 (

frigate/video/detect.py

@@ -94,7 +94,6 @@ class CameraTracker(FrigateProcess):
             self.config.detect.fps,
             name=self.config.name,
             ptz_metrics=self.ptz_metrics,
-            autotracking_enabled=self.config.onvif.autotracking.enabled,
         )
         object_detector = RemoteObjectDetector(
             self.config.name,
@@ -196,12 +195,10 @@ def process_frames(
         None,
         {camera_config.name: camera_config},
         [
-            CameraConfigUpdateEnum.autotracking,
             CameraConfigUpdateEnum.detect,
             CameraConfigUpdateEnum.enabled,
             CameraConfigUpdateEnum.motion,
             CameraConfigUpdateEnum.objects,
-            CameraConfigUpdateEnum.onvif,
         ],
     )
 
@@ -238,11 +235,6 @@ def process_frames(
             motion_detector.config = camera_config.motion
             motion_detector.update_mask()
 
-        if "autotracking" in updated_configs or "onvif" in updated_configs:
-            motion_detector.autotracking_enabled = (
-                camera_config.onvif.autotracking.enabled
-            )
-
         if (
             not camera_enabled
             and prev_enabled != camera_enabled
@@ -357,8 +349,8 @@ def process_frames(
 
             # only add in the motion boxes when not calibrating and a ptz is not moving via autotracking
             # the ptz timestamps are only maintained while autotracking is on, so gate
-            # on the config rather than trusting them to be reset otherwise
-            ptz_moving = camera_config.onvif.autotracking.enabled and (
+            # on the metric rather than trusting them to be reset otherwise
+            ptz_moving = ptz_metrics.autotracker_enabled.value and (
                 ptz_moving_at_frame_time(
                     frame_time,
                     ptz_metrics.start_time.value,

frigate/video/ffmpeg.py

@@ -6,7 +6,6 @@ import subprocess as sp
 import threading
 import time
 from collections import defaultdict, deque
-from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 from multiprocessing import Queue, Value
 from multiprocessing.synchronize import Event as MpEvent
@@ -109,27 +108,6 @@ def capture_frames(
         frame_index = 0 if frame_index == shm_frame_count - 1 else frame_index + 1
 
 
-@dataclass
-class RoleStatus:
-    """Publishes a role's status when it changes or the resend interval elapses."""
-
-    requestor: InterProcessRequestor
-    topic: str
-    resend_interval: float
-    last_status: str | None = None
-    last_update_time: float = 0.0
-
-    def send(self, status: str, now: float) -> None:
-        """Publish a changed status or resend it after the configured interval."""
-        if (
-            status != self.last_status
-            or (now - self.last_update_time) >= self.resend_interval
-        ):
-            self.requestor.send_data(self.topic, status)
-            self.last_status = status
-            self.last_update_time = now
-
-
 class CameraWatchdog(threading.Thread):
     def __init__(
         self,
@@ -208,16 +186,33 @@ class CameraWatchdog(threading.Thread):
         self._stall_active: bool = False
 
         # Status caching to reduce message volume
-        self.detect_status = self._role_status("detect")
-        self.record_status = {
-            stream_type: self._role_status(role)
-            for stream_type, role in STREAM_TYPE_TO_ROLE.items()
-        }
+        self._last_detect_status: str | None = None
+        self._last_record_status: dict[str, str] = {}
+        self._last_detect_status_update_time: float = 0.0
+        self._last_record_status_update_time: dict[str, float] = defaultdict(float)
 
-    def _role_status(self, role: str) -> RoleStatus:
-        return RoleStatus(
-            self.requestor, f"{self.config.name}/status/{role}", self.sleeptime
-        )
+    def _send_detect_status(self, status: str, now: float) -> None:
+        """Send detect status only if changed or retry_interval has elapsed."""
+        if (
+            status != self._last_detect_status
+            or (now - self._last_detect_status_update_time) >= self.sleeptime
+        ):
+            self.requestor.send_data(f"{self.config.name}/status/detect", status)
+            self._last_detect_status = status
+            self._last_detect_status_update_time = now
+
+    def _send_record_status(self, stream_type: str, status: str, now: float) -> None:
+        """Send a record stream's status only if changed or retry_interval has elapsed."""
+        if (
+            status != self._last_record_status.get(stream_type)
+            or (now - self._last_record_status_update_time[stream_type])
+            >= self.sleeptime
+        ):
+            self.requestor.send_data(
+                f"{self.config.name}/status/{STREAM_TYPE_TO_ROLE[stream_type]}", status
+            )
+            self._last_record_status[stream_type] = status
+            self._last_record_status_update_time[stream_type] = now
 
     def _send_roles_offline(self, roles: list[CameraRoleEnum], now: float) -> None:
         """Send offline status for each role of a restarted ffmpeg process."""
@@ -227,7 +222,7 @@ class CameraWatchdog(threading.Thread):
             stream_type = ROLE_TO_STREAM_TYPE.get(role.value)
 
             if stream_type is not None:
-                self.record_status[stream_type].send("offline", now)
+                self._send_record_status(stream_type, "offline", now)
             else:
                 self.requestor.send_data(
                     f"{self.config.name}/status/{role.value}", "offline"
@@ -393,11 +388,11 @@ class CameraWatchdog(threading.Thread):
 
                     # update camera status
                     now = datetime.now().timestamp()
-                    self.detect_status.send("disabled", now)
-                    self.record_status[STREAM_TYPE_MAIN].send("disabled", now)
+                    self._send_detect_status("disabled", now)
+                    self._send_record_status(STREAM_TYPE_MAIN, "disabled", now)
                     # cameras without a sub stream never get a record_sub topic
                     if self.config.record.sub.enabled:
-                        self.record_status[STREAM_TYPE_SUB].send("disabled", now)
+                        self._send_record_status(STREAM_TYPE_SUB, "disabled", now)
                 self.was_enabled = enabled
                 continue
 
@@ -470,7 +465,7 @@ class CameraWatchdog(threading.Thread):
             can_restart = time_since_last_restart >= self.sleeptime
 
             if not self.capture_thread.is_alive():
-                self.detect_status.send("offline", now)
+                self._send_detect_status("offline", now)
                 self.camera_fps.value = 0
                 self.logger.error(
                     f"Ffmpeg process crashed unexpectedly for {self.config.name}."
@@ -482,7 +477,7 @@ class CameraWatchdog(threading.Thread):
                 self.fps_overflow_count += 1
 
                 if self.fps_overflow_count == 3:
-                    self.detect_status.send("offline", now)
+                    self._send_detect_status("offline", now)
                     self.fps_overflow_count = 0
                     self.camera_fps.value = 0
                     self.logger.info(
@@ -492,7 +487,7 @@ class CameraWatchdog(threading.Thread):
                         self.reset_capture_thread(drain_output=False)
                         last_restart_time = now
             elif now - self.capture_thread.current_frame.value > 20:
-                self.detect_status.send("offline", now)
+                self._send_detect_status("offline", now)
                 self.camera_fps.value = 0
                 self.logger.info(
                     f"No frames received from {self.config.name} in 20 seconds. Exiting ffmpeg..."
@@ -502,7 +497,7 @@ class CameraWatchdog(threading.Thread):
                     last_restart_time = now
             else:
                 # process is running normally
-                self.detect_status.send("online", now)
+                self._send_detect_status("online", now)
                 self.fps_overflow_count = 0
 
             for p in self.ffmpeg_other_processes:
@@ -545,7 +540,7 @@ class CameraWatchdog(threading.Thread):
                     elif stale_stream is None:
                         if poll is None:
                             for stream_type in recorded_streams:
-                                self.record_status[stream_type].send("online", now)
+                                self._send_record_status(stream_type, "online", now)
 
                         p["latest_segment_time"] = max(
                             self.latest_cache_segment_time[stream_type]
@@ -561,22 +556,22 @@ class CameraWatchdog(threading.Thread):
                     p["cmd"], self.logger, p["logpipe"], ffmpeg_process=p["process"]
                 )
 
-            if self.detect_process_records_sub and self.config.record.stream_enabled(
-                STREAM_TYPE_SUB
+            if (
+                self.detect_process_records_sub
+                and self.config.record.stream_enabled(STREAM_TYPE_SUB)
+                and self.capture_thread is not None
+                and self.capture_thread.is_alive()
             ):
                 now_utc = datetime.now().astimezone(UTC)
                 stale_reason = self._stream_staleness(STREAM_TYPE_SUB, now_utc)
 
-                if self.detect_status.last_status == "offline":
-                    # the sub stream is down whenever the detect process is
-                    self.record_status[STREAM_TYPE_SUB].send("offline", now)
-                elif stale_reason is None:
-                    self.record_status[STREAM_TYPE_SUB].send("online", now)
+                if stale_reason is None:
+                    self._send_record_status(STREAM_TYPE_SUB, "online", now)
                 elif can_restart:
                     self.logger.error(
                         f"{stale_reason} for {self.config.name} (sub, shared with detect) in the last {self.record_stale_threshold[STREAM_TYPE_SUB]}s. Restarting ffmpeg..."
                     )
-                    self.record_status[STREAM_TYPE_SUB].send("offline", now)
+                    self._send_record_status(STREAM_TYPE_SUB, "offline", now)
                     self.reset_capture_thread()
                     last_restart_time = now
 

web/e2e/helpers/system-tabs.ts

@@ -0,0 +1,11 @@
+import type { FrigateApp } from "../fixtures/frigate-test";
+
+// On mobile the System tabs sit in an OverflowStrip, which keeps an inert copy
+// of every tab for measurement and hides the ones that do not fit behind a
+// kebab. The selected tab always stays in the strip.
+
+export function systemTab(frigateApp: FrigateApp, name: string) {
+  return frigateApp.page
+    .locator(`[aria-label="Select ${name}" i]:not([inert] *)`)
+    .first();
+}

web/e2e/specs/auth.spec.ts

@@ -7,12 +7,13 @@
  */
 
 import { test, expect } from "../fixtures/frigate-test";
+import { systemTab } from "../helpers/system-tabs";
 import { viewerProfile } from "../fixtures/mock-data/profile";
 
 test.describe("Auth — admin access @high", () => {
   test("admin /system renders general tab", async ({ frigateApp }) => {
     await frigateApp.goto("/system");
-    await expect(frigateApp.page.getByLabel("Select general")).toBeVisible({
+    await expect(systemTab(frigateApp, "general")).toBeVisible({
       timeout: 15_000,
     });
   });
@@ -28,7 +29,7 @@ test.describe("Auth — admin access @high", () => {
 
   test("admin /logs renders frigate tab", async ({ frigateApp }) => {
     await frigateApp.goto("/logs");
-    await expect(frigateApp.page.getByLabel("Select frigate")).toBeVisible({
+    await expect(systemTab(frigateApp, "frigate")).toBeVisible({
       timeout: 5_000,
     });
   });

web/e2e/specs/live.spec.ts

@@ -287,3 +287,22 @@ test.describe("Live mobile layout @critical @mobile", () => {
     await expect(frigateApp.page.locator("body")).toBeVisible();
   });
 });
+
+test.describe("Live camera groups @medium", () => {
+  test("a group with an invalid icon renders a fallback icon", async ({
+    frigateApp,
+  }) => {
+    await frigateApp.installDefaults({
+      config: {
+        camera_groups: {
+          outdoor: { cameras: ["front_door"], icon: "generic" },
+        },
+      },
+    });
+    await frigateApp.goto("/");
+    const group = frigateApp.page
+      .locator('[aria-label="Camera Groups"]:not([inert] *)')
+      .first();
+    await expect(group.locator("svg")).toBeVisible({ timeout: 10_000 });
+  });
+});

web/e2e/specs/system-health.spec.ts

@@ -6,6 +6,7 @@
  */
 
 import { test, expect } from "../fixtures/frigate-test";
+import { systemTab } from "../helpers/system-tabs";
 import { viewerProfile } from "../fixtures/mock-data/profile";
 
 const NOW = Math.floor(Date.now() / 1000);
@@ -55,7 +56,7 @@ test.describe("System — Health tab @medium", () => {
     });
     await frigateApp.goto("/system");
 
-    await expect(frigateApp.page.getByLabel("Select health")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "health")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
@@ -801,7 +802,7 @@ test.describe("System — Health notices sources @medium", () => {
       stats: QUIET_STATS,
     });
     await frigateApp.goto("/system#health");
-    await expect(frigateApp.page.getByLabel("Select health")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "health")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },

web/e2e/specs/system.spec.ts

@@ -6,42 +6,66 @@
  * RestartDialog cancel flow.
  */
 
-import { test, expect } from "../fixtures/frigate-test";
+import { test, expect, FrigateApp } from "../fixtures/frigate-test";
 import {
   expectBodyInteractive,
   waitForBodyInteractive,
 } from "../helpers/overlay-interaction";
+import { systemTab } from "../helpers/system-tabs";
+
+async function selectTab(frigateApp: FrigateApp, name: string) {
+  const kebab = frigateApp.page.getByLabel("Show all tabs");
+
+  if (frigateApp.isMobile && (await kebab.isVisible())) {
+    await kebab.click();
+    await frigateApp.page
+      .locator(`[aria-label="Select ${name}" i]:not([inert] *)`)
+      .last()
+      .click();
+    return;
+  }
+
+  await systemTab(frigateApp, name).click();
+}
+
+async function expectTabActive(frigateApp: FrigateApp, name: string) {
+  await expect(systemTab(frigateApp, name)).toHaveAttribute(
+    "data-state",
+    "on",
+    {
+      timeout: 5_000,
+    },
+  );
+}
 
 test.describe("System — tabs @medium", () => {
   test("general tab is active by default via #general hash", async ({
     frigateApp,
   }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    await expect(frigateApp.page.getByLabel("Select storage")).toBeVisible();
-    await expect(frigateApp.page.getByLabel("Select cameras")).toBeVisible();
+    if (!frigateApp.isMobile) {
+      await expect(systemTab(frigateApp, "storage")).toBeVisible();
+      await expect(systemTab(frigateApp, "cameras")).toBeVisible();
+    }
   });
 
   test("Storage tab activates and deactivates General", async ({
     frigateApp,
   }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    await frigateApp.page.getByLabel("Select storage").click();
-    await expect(frigateApp.page.getByLabel("Select storage")).toHaveAttribute(
-      "data-state",
-      "on",
-      { timeout: 5_000 },
-    );
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await selectTab(frigateApp, "storage");
+    await expectTabActive(frigateApp, "storage");
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "off",
     );
@@ -49,24 +73,20 @@ test.describe("System — tabs @medium", () => {
 
   test("Cameras tab activates", async ({ frigateApp }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    await frigateApp.page.getByLabel("Select cameras").click();
-    await expect(frigateApp.page.getByLabel("Select cameras")).toHaveAttribute(
-      "data-state",
-      "on",
-      { timeout: 5_000 },
-    );
+    await selectTab(frigateApp, "cameras");
+    await expectTabActive(frigateApp, "cameras");
   });
 
   test("general tab shows version and last-refreshed", async ({
     frigateApp,
   }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
@@ -87,17 +107,13 @@ test.describe("System — tabs @medium", () => {
     frigateApp,
   }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    await frigateApp.page.getByLabel("Select storage").click();
-    await expect(frigateApp.page.getByLabel("Select storage")).toHaveAttribute(
-      "data-state",
-      "on",
-      { timeout: 5_000 },
-    );
+    await selectTab(frigateApp, "storage");
+    await expectTabActive(frigateApp, "storage");
     // On desktop, tab buttons render text labels so the word "storage"
     // always appears in #pageRoot after switching. On mobile, tabs are
     // icon-only, so we verify the general-tab content disappears instead
@@ -112,25 +128,23 @@ test.describe("System — tabs @medium", () => {
     } else {
       // Mobile: tab activation (data-state "on") already asserted above.
       // Additionally confirm general tab is no longer the active tab.
-      await expect(
-        frigateApp.page.getByLabel("Select general"),
-      ).toHaveAttribute("data-state", "off", { timeout: 5_000 });
+      await expect(systemTab(frigateApp, "general")).toHaveAttribute(
+        "data-state",
+        "off",
+        { timeout: 5_000 },
+      );
     }
   });
 
   test("cameras tab renders each configured camera", async ({ frigateApp }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    await frigateApp.page.getByLabel("Select cameras").click();
-    await expect(frigateApp.page.getByLabel("Select cameras")).toHaveAttribute(
-      "data-state",
-      "on",
-      { timeout: 5_000 },
-    );
+    await selectTab(frigateApp, "cameras");
+    await expectTabActive(frigateApp, "cameras");
     // Cameras tab lists every camera from config/stats. The default
     // mock has front_door, backyard, garage.
     for (const cam of ["front_door", "backyard", "garage"]) {
@@ -151,17 +165,13 @@ test.describe("System — tabs @medium", () => {
       config: { semantic_search: { enabled: true } },
     });
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    const enrichTab = frigateApp.page.getByLabel(/select enrichments/i).first();
-    await expect(enrichTab).toBeVisible({ timeout: 5_000 });
-    await enrichTab.click();
-    await expect(enrichTab).toHaveAttribute("data-state", "on", {
-      timeout: 5_000,
-    });
+    await selectTab(frigateApp, "enrichments");
+    await expectTabActive(frigateApp, "enrichments");
   });
 });
 
@@ -223,31 +233,27 @@ test.describe("System — mobile @medium @mobile", () => {
 
   test("tabs render at mobile viewport", async ({ frigateApp }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toBeVisible({
+    await expect(systemTab(frigateApp, "general")).toBeVisible({
       timeout: 15_000,
     });
   });
 
   test("switching tabs works at mobile viewport", async ({ frigateApp }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
     );
-    await frigateApp.page.getByLabel("Select storage").click();
-    await expect(frigateApp.page.getByLabel("Select storage")).toHaveAttribute(
-      "data-state",
-      "on",
-      { timeout: 5_000 },
-    );
+    await selectTab(frigateApp, "storage");
+    await expectTabActive(frigateApp, "storage");
   });
 
   test("header controls leave the logo uncovered on a narrow phone", async ({
     frigateApp,
   }) => {
     await frigateApp.goto("/system#general");
-    await expect(frigateApp.page.getByLabel("Select general")).toHaveAttribute(
+    await expect(systemTab(frigateApp, "general")).toHaveAttribute(
       "data-state",
       "on",
       { timeout: 15_000 },
@@ -255,9 +261,9 @@ test.describe("System — mobile @medium @mobile", () => {
     await frigateApp.page.setViewportSize({ width: 320, height: 740 });
 
     const logo = frigateApp.page.locator("svg.fill-current").first();
-    const tabs = frigateApp.page
-      .locator("[data-radix-scroll-area-viewport]")
-      .filter({ has: frigateApp.page.getByLabel("Select general") });
+    const kebab = frigateApp.page.getByLabel("Show all tabs");
+    await expect(kebab).toBeVisible();
+    const tabs = kebab.locator("..");
     const refreshed = frigateApp.page.getByText(/Just now|ago/);
 
     const logoBox = await logo.boundingBox();
@@ -267,20 +273,9 @@ test.describe("System — mobile @medium @mobile", () => {
     expect(tabsBox!.x + tabsBox!.width).toBeLessThanOrEqual(logoBox!.x + 1);
     expect(refreshedBox!.x).toBeGreaterThanOrEqual(logoBox!.x + logoBox!.width);
 
-    // the clipped tabs stay reachable by scrolling
-    const overflow = await tabs.evaluate((el) => ({
-      scroll: el.scrollWidth,
-      client: el.clientWidth,
-    }));
-    expect(overflow.scroll).toBeGreaterThan(overflow.client);
-    await tabs.evaluate((el) => {
-      el.scrollLeft = el.scrollWidth;
-    });
-    await frigateApp.page.getByLabel("Select cameras").click();
-    await expect(frigateApp.page.getByLabel("Select cameras")).toHaveAttribute(
-      "data-state",
-      "on",
-      { timeout: 5_000 },
-    );
+    // the tabs that do not fit stay reachable through the kebab
+    await selectTab(frigateApp, "cameras");
+    await expectTabActive(frigateApp, "cameras");
+    await expect(frigateApp.page.getByLabel("Show less")).toHaveCount(0);
   });
 });

web/public/locales/en/views/system.json

@@ -14,6 +14,8 @@
   },
   "title": "System",
   "metrics": "System metrics",
+  "showAllTabs": "Show all tabs",
+  "showLessTabs": "Show less",
   "health": {
     "title": "Health",
     "notices": {

web/src/components/filter/CameraGroupSelector.tsx

@@ -8,18 +8,8 @@ import { isDesktop, isMobile } from "react-device-detect";
 import useSWR from "swr";
 import { MdHome } from "react-icons/md";
 import { Button, buttonVariants } from "../ui/button";
-import {
-  useCallback,
-  useContext,
-  useEffect,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
-import { AnimatePresence, motion } from "framer-motion";
-import { HiDotsHorizontal } from "react-icons/hi";
-import { IoClose } from "react-icons/io5";
+import { useCallback, useContext, useEffect, useMemo, useState } from "react";
+import OverflowStrip from "../mobile/OverflowStrip";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip";
 import { LuPencil, LuPlus } from "react-icons/lu";
 import {
@@ -156,80 +146,7 @@ export function CameraGroupSelector({ className }: CameraGroupSelectorProps) {
 
   const [addGroup, setAddGroup] = useState(false);
 
-  // mobile overflow reveal - the group strip sits left of the logo and is
-  // clipped (not scrollable) when there are too many groups, so render only
-  // the buttons that fully fit and surface a kebab next to the last visible
-  // one that expands a panel revealing all of them
-
-  const [expanded, setExpanded] = useState(false);
-  // null => all buttons fit, render them all with no kebab; a number => only
-  // that many fit alongside the kebab
-  const [visibleCount, setVisibleCount] = useState<number | null>(null);
-  const wrapperRef = useRef<HTMLDivElement | null>(null);
-  const measureRef = useRef<HTMLDivElement | null>(null);
-
-  useLayoutEffect(() => {
-    if (isDesktop) {
-      return;
-    }
-
-    const wrapper = wrapperRef.current;
-    const measure = measureRef.current;
-
-    if (!wrapper || !measure) {
-      return;
-    }
-
-    const gap = 8; // gap-2 between buttons in the strip
-    const wrapperGap = 4; // gap-1 between the strip and the kebab
-
-    const compute = () => {
-      const buttons = Array.from(measure.children) as HTMLElement[];
-
-      if (buttons.length === 0) {
-        return;
-      }
-
-      // the trailing child of the measurement row is a kebab clone
-      const kebab = buttons[buttons.length - 1];
-      const groupButtons = buttons.slice(0, -1);
-      const available = wrapper.clientWidth;
-      const fullWidth =
-        groupButtons.reduce((sum, el) => sum + el.offsetWidth, 0) +
-        Math.max(groupButtons.length - 1, 0) * gap;
-
-      if (fullWidth <= available) {
-        setVisibleCount(null);
-        return;
-      }
-
-      const budget = available - kebab.offsetWidth - wrapperGap;
-      let used = 0;
-      let count = 0;
-
-      for (const el of groupButtons) {
-        const next = (count === 0 ? 0 : gap) + el.offsetWidth;
-
-        if (used + next <= budget) {
-          used += next;
-          count += 1;
-        } else {
-          break;
-        }
-      }
-
-      setVisibleCount(Math.max(count, 1));
-    };
-
-    compute();
-
-    const observer = new ResizeObserver(compute);
-    observer.observe(wrapper);
-
-    return () => observer.disconnect();
-  }, [groups, isAdmin]);
-
-  const groupButtons = (afterSelect?: () => void) => {
+  const groupButtons = () => {
     const buttons = [
       <Button
         key="default-group"
@@ -245,7 +162,6 @@ export function CameraGroupSelector({ className }: CameraGroupSelectorProps) {
           if (group) {
             setGroup("default", true);
           }
-          afterSelect?.();
         }}
       >
         <MdHome className="size-5" />
@@ -263,12 +179,16 @@ export function CameraGroupSelector({ className }: CameraGroupSelectorProps) {
           size="sm"
           onClick={() => {
             setGroup(name, group != "default");
-            afterSelect?.();
           }}
         >
-          {config && config.icon && isValidIconName(config.icon) && (
-            <IconRenderer icon={LuIcons[config.icon]} className="size-5" />
-          )}
+          <IconRenderer
+            icon={
+              isValidIconName(config.icon)
+                ? LuIcons[config.icon]
+                : LuIcons.LuFolder
+            }
+            className="size-5"
+          />
         </Button>
       )),
     ];
@@ -282,7 +202,6 @@ export function CameraGroupSelector({ className }: CameraGroupSelectorProps) {
           size="sm"
           onClick={() => {
             setAddGroup(true);
-            afterSelect?.();
           }}
         >
           <LuPencil className="size-5 text-primary-variant" />
@@ -350,12 +269,14 @@ export function CameraGroupSelector({ className }: CameraGroupSelectorProps) {
                     onMouseEnter={() => showTooltip(name)}
                     onMouseLeave={() => showTooltip(undefined)}
                   >
-                    {config && config.icon && isValidIconName(config.icon) && (
-                      <IconRenderer
-                        icon={LuIcons[config.icon]}
-                        className="size-4"
-                      />
-                    )}
+                    <IconRenderer
+                      icon={
+                        isValidIconName(config.icon)
+                          ? LuIcons[config.icon]
+                          : LuIcons.LuFolder
+                      }
+                      className="size-4"
+                    />
                   </Button>
                 </TooltipTrigger>
                 <TooltipPortal>
@@ -390,74 +311,13 @@ export function CameraGroupSelector({ className }: CameraGroupSelectorProps) {
           )}
         </div>
       ) : (
-        <div
-          ref={wrapperRef}
-          className={cn("flex min-w-0 items-center gap-1", className)}
-        >
-          <div className="flex min-w-0 items-center gap-2 overflow-hidden whitespace-nowrap">
-            {visibleCount == null
-              ? groupButtons()
-              : groupButtons().slice(0, visibleCount)}
-          </div>
-          {visibleCount != null && (
-            <Button
-              variant="ghost"
-              size="sm"
-              className="shrink-0 px-2 text-secondary-foreground"
-              aria-label={t("group.showAll")}
-              onClick={() => setExpanded(true)}
-            >
-              <HiDotsHorizontal className="size-5" />
-            </Button>
-          )}
-
-          {/* invisible row used only to measure natural button widths so we
-              can render exactly the buttons that fully fit */}
-          <div
-            className="pointer-events-none absolute left-0 top-0 h-0 w-0 overflow-hidden"
-            aria-hidden
-            inert
-          >
-            <div ref={measureRef} className="flex w-max items-center gap-2">
-              {groupButtons()}
-              <Button variant="ghost" size="sm" className="px-2">
-                <HiDotsHorizontal className="size-5" />
-              </Button>
-            </div>
-          </div>
-
-          {expanded && (
-            <div
-              className="fixed inset-0 z-20"
-              onClick={() => setExpanded(false)}
-            />
-          )}
-          <AnimatePresence>
-            {expanded && (
-              <motion.div
-                key="group-overlay"
-                className="absolute inset-x-0 top-0 z-30 bg-background py-1 shadow-lg"
-                initial={{ clipPath: "inset(0 100% 0 0)" }}
-                animate={{ clipPath: "inset(0 0% 0 0)" }}
-                exit={{ clipPath: "inset(0 100% 0 0)" }}
-                transition={{ duration: 0.2, ease: "easeInOut" }}
-              >
-                <div className="flex flex-wrap items-center gap-2">
-                  {groupButtons(() => setExpanded(false))}
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    className="ml-auto shrink-0 px-2 text-secondary-foreground"
-                    aria-label={t("group.showLess")}
-                    onClick={() => setExpanded(false)}
-                  >
-                    <IoClose className="size-5" />
-                  </Button>
-                </div>
-              </motion.div>
-            )}
-          </AnimatePresence>
-        </div>
+        <OverflowStrip
+          className={className}
+          items={groupButtons()}
+          activeIndex={groups.findIndex(([name]) => name == group) + 1}
+          showAllLabel={t("group.showAll")}
+          showLessLabel={t("group.showLess")}
+        />
       )}
     </>
   );

web/src/components/mobile/OverflowStrip.tsx

@@ -0,0 +1,167 @@
+import { ReactNode, useLayoutEffect, useRef, useState } from "react";
+import { AnimatePresence, motion } from "framer-motion";
+import { HiDotsHorizontal } from "react-icons/hi";
+import { IoClose } from "react-icons/io5";
+import { Button } from "../ui/button";
+import { cn } from "@/lib/utils";
+
+type OverflowStripProps = {
+  className?: string;
+  items: ReactNode[];
+  activeIndex?: number;
+  gapClassName?: string;
+  showAllLabel: string;
+  showLessLabel: string;
+};
+
+// Renders only the items that fully fit and surfaces a kebab next to the last
+// visible one. The kebab expands a panel over the nearest positioned ancestor
+// that reveals every item.
+export default function OverflowStrip({
+  className,
+  items,
+  activeIndex = 0,
+  gapClassName = "gap-2",
+  showAllLabel,
+  showLessLabel,
+}: OverflowStripProps) {
+  const [expanded, setExpanded] = useState(false);
+  // null => all items fit, render them all with no kebab; a number => only
+  // that many fit alongside the kebab
+  const [visibleCount, setVisibleCount] = useState<number | null>(null);
+  const wrapperRef = useRef<HTMLDivElement | null>(null);
+  const measureRef = useRef<HTMLDivElement | null>(null);
+
+  useLayoutEffect(() => {
+    const wrapper = wrapperRef.current;
+    const measure = measureRef.current;
+
+    if (!wrapper || !measure) {
+      return;
+    }
+
+    const wrapperGap = 4; // gap-1 between the strip and the kebab
+
+    const compute = () => {
+      const children = Array.from(measure.children) as HTMLElement[];
+
+      if (children.length === 0) {
+        return;
+      }
+
+      // the trailing child of the measurement row is a kebab clone
+      const kebab = children[children.length - 1];
+      const start = children[0].offsetLeft;
+      const ends = children
+        .slice(0, -1)
+        .map((el) => el.offsetLeft + el.offsetWidth - start);
+      const available = wrapper.clientWidth;
+
+      if (ends[ends.length - 1] <= available) {
+        setVisibleCount(null);
+        return;
+      }
+
+      const budget = available - kebab.offsetWidth - wrapperGap;
+      const count = ends.filter((end) => end <= budget).length;
+
+      setVisibleCount(Math.max(count, 1));
+    };
+
+    compute();
+
+    const observer = new ResizeObserver(compute);
+    observer.observe(wrapper);
+    observer.observe(measure);
+
+    return () => observer.disconnect();
+  }, [items.length, gapClassName]);
+
+  // a selected item past the cut takes the last visible slot
+  const visibleItems =
+    visibleCount == null
+      ? items
+      : activeIndex >= visibleCount
+        ? [...items.slice(0, visibleCount - 1), items[activeIndex]]
+        : items.slice(0, visibleCount);
+
+  return (
+    <div
+      ref={wrapperRef}
+      className={cn("flex min-w-0 items-center gap-1", className)}
+    >
+      <div
+        className={cn(
+          "flex min-w-0 items-center overflow-hidden whitespace-nowrap",
+          gapClassName,
+        )}
+      >
+        {visibleItems}
+      </div>
+      {visibleCount != null && (
+        <Button
+          variant="ghost"
+          size="sm"
+          className="shrink-0 px-2 text-secondary-foreground"
+          aria-label={showAllLabel}
+          onClick={() => setExpanded(true)}
+        >
+          <HiDotsHorizontal className="size-5" />
+        </Button>
+      )}
+
+      {/* invisible row used only to measure natural item widths so we can
+          render exactly the items that fully fit */}
+      <div
+        className="pointer-events-none absolute left-0 top-0 h-0 w-0 overflow-hidden"
+        aria-hidden
+        inert
+      >
+        <div
+          ref={measureRef}
+          className={cn("flex w-max items-center", gapClassName)}
+        >
+          {items}
+          <Button variant="ghost" size="sm" className="px-2">
+            <HiDotsHorizontal className="size-5" />
+          </Button>
+        </div>
+      </div>
+
+      {expanded && (
+        <div
+          className="fixed inset-0 z-20"
+          onClick={() => setExpanded(false)}
+        />
+      )}
+      <AnimatePresence>
+        {expanded && (
+          <motion.div
+            key="overflow-overlay"
+            className="absolute inset-x-0 top-0 z-30 bg-background py-1 shadow-lg"
+            initial={{ clipPath: "inset(0 100% 0 0)" }}
+            animate={{ clipPath: "inset(0 0% 0 0)" }}
+            exit={{ clipPath: "inset(0 100% 0 0)" }}
+            transition={{ duration: 0.2, ease: "easeInOut" }}
+          >
+            {/* a tap on any item bubbles up and collapses the panel */}
+            <div
+              className={cn("flex flex-wrap items-center", gapClassName)}
+              onClick={() => setExpanded(false)}
+            >
+              {items}
+              <Button
+                variant="ghost"
+                size="sm"
+                className="ml-auto shrink-0 px-2 text-secondary-foreground"
+                aria-label={showLessLabel}
+              >
+                <IoClose className="size-5" />
+              </Button>
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+}

web/src/pages/System.tsx

@@ -1,8 +1,10 @@
 import useSWR from "swr";
 import { FrigateStats } from "@/types/stats";
-import { useEffect, useMemo, useRef, useState } from "react";
+import { ReactNode, useEffect, useMemo, useRef, useState } from "react";
 import TimeAgo from "@/components/dynamic/TimeAgo";
 import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
+import { Toggle } from "@/components/ui/toggle";
+import OverflowStrip from "@/components/mobile/OverflowStrip";
 import { isDesktop, isMobile } from "react-device-detect";
 import GeneralMetrics from "@/views/system/GeneralMetrics";
 import StorageMetrics from "@/views/system/StorageMetrics";
@@ -36,6 +38,14 @@ const allMetrics = [
 ] as const;
 type SystemMetric = (typeof allMetrics)[number];
 
+const metricIcons: Record<SystemMetric, ReactNode> = {
+  health: <LuHeartPulse className="size-4" />,
+  general: <LuActivity className="size-4" />,
+  enrichments: <LuSearchCode className="size-4" />,
+  storage: <LuHardDrive className="size-4" />,
+  cameras: <FaVideo className="size-4" />,
+};
+
 function System() {
   const { t } = useTranslation(["views/system"]);
   const { data: config } = useSWR<FrigateConfig>("config", {
@@ -98,43 +108,66 @@ function System() {
         {isMobile && (
           <Logo className="absolute inset-x-1/2 h-8 -translate-x-1/2" />
         )}
-        <ScrollArea className={cn("whitespace-nowrap", isMobile && "w-[45%]")}>
-          <div className="flex flex-row">
-            <ToggleGroup
-              className="*:rounded-md *:px-3 *:py-4"
-              type="single"
-              size="sm"
-              value={pageToggle}
-              onValueChange={(value: SystemMetric) => {
-                if (value) {
-                  setPageToggle(value);
-                }
-              }} // don't allow the severity to be unselected
-            >
-              {Object.values(metrics).map((item) => (
-                <ToggleGroupItem
+        {isMobile ? (
+          <div className="w-[calc(50%-1rem)]">
+            <OverflowStrip
+              items={metrics.map((item) => (
+                <Toggle
                   key={item}
-                  className={`flex items-center justify-between gap-2 ${pageToggle == item ? "" : "*:text-muted-foreground"}`}
-                  value={item}
+                  className={cn(
+                    "shrink-0 rounded-md px-3 py-4",
+                    pageToggle != item && "*:text-muted-foreground",
+                  )}
+                  size="sm"
+                  pressed={pageToggle == item}
+                  onPressedChange={() => setPageToggle(item)}
                   aria-label={t("selectItem", {
                     ns: "common",
                     item: t(item + ".title"),
                   })}
                 >
-                  {item == "health" && <LuHeartPulse className="size-4" />}
-                  {item == "general" && <LuActivity className="size-4" />}
-                  {item == "enrichments" && <LuSearchCode className="size-4" />}
-                  {item == "storage" && <LuHardDrive className="size-4" />}
-                  {item == "cameras" && <FaVideo className="size-4" />}
-                  {isDesktop && (
-                    <div className="smart-capitalize">{t(item + ".title")}</div>
-                  )}
-                </ToggleGroupItem>
+                  {metricIcons[item]}
+                </Toggle>
               ))}
-            </ToggleGroup>
-            <ScrollBar orientation="horizontal" className="h-0" />
+              activeIndex={metrics.indexOf(pageToggle)}
+              gapClassName="gap-0.5"
+              showAllLabel={t("showAllTabs")}
+              showLessLabel={t("showLessTabs")}
+            />
           </div>
-        </ScrollArea>
+        ) : (
+          <ScrollArea className="whitespace-nowrap">
+            <div className="flex flex-row">
+              <ToggleGroup
+                className="*:rounded-md *:px-3 *:py-4"
+                type="single"
+                size="sm"
+                value={pageToggle}
+                onValueChange={(value: SystemMetric) => {
+                  if (value) {
+                    setPageToggle(value);
+                  }
+                }} // don't allow the severity to be unselected
+              >
+                {Object.values(metrics).map((item) => (
+                  <ToggleGroupItem
+                    key={item}
+                    className={`flex items-center justify-between gap-2 ${pageToggle == item ? "" : "*:text-muted-foreground"}`}
+                    value={item}
+                    aria-label={t("selectItem", {
+                      ns: "common",
+                      item: t(item + ".title"),
+                    })}
+                  >
+                    {metricIcons[item]}
+                    <div className="smart-capitalize">{t(item + ".title")}</div>
+                  </ToggleGroupItem>
+                ))}
+              </ToggleGroup>
+              <ScrollBar orientation="horizontal" className="h-0" />
+            </div>
+          </ScrollArea>
+        )}
 
         <div className="flex h-full items-center">
           {pageToggle == "health" && (

web/src/views/live/LiveDashboardView.tsx

@@ -419,7 +419,7 @@ export default function LiveDashboardView({
       {isMobile && (
         <div className="relative flex h-11 items-center justify-between">
           <Logo className="absolute inset-x-1/2 h-8 -translate-x-1/2" />
-          <div className="w-[45%]">
+          <div className="w-[calc(50%-1rem)]">
             <CameraGroupSelector />
           </div>
           {(!cameraGroup || cameraGroup == "default" || isMobileOnly) && (