Adding Coordinator and Refactoring #251 from sca075/refactoring_camera

Adding Coordinator and Refactoring

Author: sca075

custom_components/mqtt_vacuum_camera/__init__.py

@@ -13,12 +13,13 @@
     Platform,
 )
 from homeassistant.core import ServiceCall
+from homeassistant.config_entries import ConfigEntryState, ConfigEntry
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.reload import async_register_admin_service
 from homeassistant.helpers.storage import STORAGE_DIR
 
 from .common import (
-    get_device_info,
+    get_vacuum_device_info,
     get_entity_identifier_from_mqtt,
     get_vacuum_mqtt_topic,
     get_vacuum_unique_id_from_mqtt_topic,
@@ -31,6 +32,7 @@
     CONF_VACUUM_IDENTIFIERS,
     DOMAIN,
 )
+from .coordinator import MQTTVacuumCoordinator
 from .utils.files_operations import (
     async_clean_up_all_auto_crop_files,
     async_get_translations_vacuum_id,
@@ -41,32 +43,32 @@
 _LOGGER = logging.getLogger(__name__)
 
 
-async def options_update_listener(
-    hass: core.HomeAssistant, config_entry: config_entries.ConfigEntry
-):
+async def options_update_listener(hass: core.HomeAssistant, config_entry: ConfigEntry):
     """Handle options update."""
     await hass.config_entries.async_reload(config_entry.entry_id)
 
 
-async def async_setup_entry(
-    hass: core.HomeAssistant, entry: config_entries.ConfigEntry
-) -> bool:
+async def async_setup_entry(hass: core.HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up platform from a ConfigEntry."""
 
     async def _reload_config(call: ServiceCall) -> None:
         """Reload the camera platform for all entities in the integration."""
-        _LOGGER.debug("Reloading the config entry for all camera entities")
-
+        _LOGGER.debug(f"Reloading the config entry for all {DOMAIN} entities")
         # Retrieve all config entries associated with the DOMAIN
         camera_entries = hass.config_entries.async_entries(DOMAIN)
 
-        # Iterate over each config entry
+        # Iterate over each config entry and check if it's LOADED
         for camera_entry in camera_entries:
-            _LOGGER.debug(f"Unloading entry: {camera_entry.entry_id}")
-            await async_unload_entry(hass, camera_entry)
+            if camera_entry.state == ConfigEntryState.LOADED:
+                _LOGGER.debug(f"Unloading entry: {camera_entry.entry_id}")
+                await async_unload_entry(hass, camera_entry)
 
-            _LOGGER.debug(f"Reloading entry: {camera_entry.entry_id}")
-            await async_setup_entry(hass, camera_entry)
+                _LOGGER.debug(f"Reloading entry: {camera_entry.entry_id}")
+                await async_setup_entry(hass, camera_entry)
+            else:
+                _LOGGER.debug(
+                    f"Skipping entry {camera_entry.entry_id} as it is NOT_LOADED"
+                )
 
         # Optionally, trigger other reinitialization steps if needed
         hass.bus.async_fire(f"event_{DOMAIN}_reloaded", context=call.context)
@@ -78,10 +80,15 @@ async def reset_trims(call: ServiceCall) -> None:
         await hass.services.async_call(DOMAIN, "reload")
         hass.bus.async_fire(f"event_{DOMAIN}_reset_trims", context=call.context)
 
+    # Register Services
+    hass.services.async_register(DOMAIN, "reset_trims", reset_trims)
+    if not hass.services.has_service(DOMAIN, SERVICE_RELOAD):
+        async_register_admin_service(hass, DOMAIN, SERVICE_RELOAD, _reload_config)
+
     hass.data.setdefault(DOMAIN, {})
     hass_data = dict(entry.data)
 
-    vacuum_entity_id, vacuum_device = get_device_info(
+    vacuum_entity_id, vacuum_device = get_vacuum_device_info(
         hass_data[CONF_VACUUM_CONFIG_ENTRY_ID], hass
     )
 
@@ -90,15 +97,21 @@ async def reset_trims(call: ServiceCall) -> None:
             "Unable to lookup vacuum's entity ID. Was it removed?"
         )
 
+    _LOGGER.debug(vacuum_entity_id)
     mqtt_topic_vacuum = get_vacuum_mqtt_topic(vacuum_entity_id, hass)
     if not mqtt_topic_vacuum:
         raise ConfigEntryNotReady("MQTT was not ready yet, automatically retrying")
 
+    vacuum_topic = "/".join(mqtt_topic_vacuum.split("/")[:-1])
+
+    data_coordinator = MQTTVacuumCoordinator(hass, entry, vacuum_topic)
+
     hass_data.update(
         {
-            CONF_VACUUM_CONNECTION_STRING: "/".join(mqtt_topic_vacuum.split("/")[:-1]),
+            CONF_VACUUM_CONNECTION_STRING: vacuum_topic,
             CONF_VACUUM_IDENTIFIERS: vacuum_device.identifiers,
             CONF_UNIQUE_ID: entry.unique_id,
+            "coordinator": data_coordinator,
         }
     )
 
@@ -108,23 +121,18 @@ async def reset_trims(call: ServiceCall) -> None:
     hass_data["unsub_options_update_listener"] = unsub_options_update_listener
     hass.data[DOMAIN][entry.entry_id] = hass_data
 
-    # Register Services
-    hass.services.async_register(DOMAIN, "reset_trims", reset_trims)
-    if not hass.services.has_service(DOMAIN, SERVICE_RELOAD):
-        async_register_admin_service(hass, DOMAIN, SERVICE_RELOAD, _reload_config)
-
     # Forward the setup to the camera platform.
     await hass.async_create_task(
         hass.config_entries.async_forward_entry_setups(entry, ["camera"])
     )
+
     return True
 
 
 async def async_unload_entry(
     hass: core.HomeAssistant, entry: config_entries.ConfigEntry
 ) -> bool:
     """Unload a config entry."""
-    _LOGGER.debug(f"unloading {entry.entry_id}")
     if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
         # Remove config entry from domain.
         entry_data = hass.data[DOMAIN].pop(entry.entry_id)
@@ -138,7 +146,7 @@ async def async_unload_entry(
 
 # noinspection PyCallingNonCallable
 async def async_setup(hass: core.HomeAssistant, config: dict) -> bool:
-    """Set up the Valetudo Camera Custom component from yaml configuration."""
+    """Set up the MQTT Camera Custom component from yaml configuration."""
 
     async def handle_homeassistant_stop(event):
         """Handle Home Assistant stop event."""

custom_components/mqtt_vacuum_camera/camera.py

@@ -1,6 +1,6 @@
 """
 Camera
-Version: v2024.09.0
+Version: v2024.10.0b2
 """
 
 from __future__ import annotations
@@ -20,17 +20,13 @@
 from PIL import Image
 from homeassistant import config_entries, core
 from homeassistant.components.camera import PLATFORM_SCHEMA, Camera, CameraEntityFeature
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.const import CONF_NAME, CONF_UNIQUE_ID, MATCH_ALL
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.reload import async_setup_reload_service
 from homeassistant.helpers.storage import STORAGE_DIR
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from psutil_home_assistant import PsutilWrapper as ProcInsp
 import voluptuous as vol
 
-from .camera_processing import CameraProcessor
-from .camera_shared import CameraSharedManager
 from .common import get_vacuum_unique_id_from_mqtt_topic
 from .const import (
     ATTR_FRIENDLY_NAME,
@@ -45,13 +41,12 @@
     DEFAULT_NAME,
     DOMAIN,
     NOT_STREAMING_STATES,
-    PLATFORMS,
 )
-from .snapshots.snapshot import Snapshots
 from .types import SnapshotStore
 from .utils.colors_man import ColorsManagment
 from .utils.files_operations import async_get_active_user_language, is_auth_updated
-from .valetudo.MQTT.connector import ValetudoConnector
+from .snapshots.snapshot import Snapshots
+from .camera_processing import CameraProcessor
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
     {
@@ -73,27 +68,16 @@ async def async_setup_entry(
 ) -> None:
     """Setup camera from a config entry created in the integrations UI."""
     config = hass.data[DOMAIN][config_entry.entry_id]
+    coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     # Update our config to and eventually add or remove option.
     if config_entry.options:
         config.update(config_entry.options)
 
-    camera = [ValetudoCamera(hass, config)]
+    camera = [MQTTCamera(coordinator, config)]
     async_add_entities(camera, update_before_add=True)
 
 
-async def async_setup_platform(
-    hass: core.HomeAssistant,
-    config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-):
-    """Set up the camera platform."""
-    async_add_entities([ValetudoCamera(hass, config)])
-
-    await async_setup_reload_service(hass, DOMAIN, PLATFORMS)
-
-
-class ValetudoCamera(Camera):
+class MQTTCamera(CoordinatorEntity, Camera):
     """
     Rend the vacuum map and the vacuum state for:
     Valetudo Hypfer and rand256 Firmwares Vacuums maps.
@@ -103,27 +87,25 @@ class ValetudoCamera(Camera):
     _attr_has_entity_name = True
     _unrecorded_attributes = frozenset({MATCH_ALL})
 
-    def __init__(self, hass, device_info):
-        super().__init__()
-        self.hass = hass
+    def __init__(self, coordinator, device_info):
+        super().__init__(coordinator)
+        Camera.__init__(self)
+        self.hass = coordinator.hass
         self._state = "init"
         self._attr_model = "MQTT Vacuums"
         self._attr_brand = "MQTT Vacuum Camera"
         self._attr_name = "Camera"
         self._attr_is_on = True
         self._directory_path = self.hass.config.path()  # get Home Assistant path
-        self._mqtt_listen_topic = str(device_info.get(CONF_VACUUM_CONNECTION_STRING))
-        self._shared, self._file_name = self._handle_init_shared_data(
-            self._mqtt_listen_topic,
-            device_info,
-        )
+        self._shared, self._file_name = coordinator.update_shared_data(device_info)
         self._start_up_logs()
         self._storage_path, self.snapshot_img, self.log_file = self._init_paths()
+        self._mqtt_listen_topic = coordinator.vacuum_topic
         self._attr_unique_id = device_info.get(
             CONF_UNIQUE_ID,
             get_vacuum_unique_id_from_mqtt_topic(self._mqtt_listen_topic),
         )
-        self._mqtt = ValetudoConnector(self._mqtt_listen_topic, self.hass, self._shared)
+        self._mqtt = coordinator.connector
         self._identifiers = device_info.get(CONF_VACUUM_IDENTIFIERS)
         self._snapshots = Snapshots(self.hass, self._shared)
         self.Image = None
@@ -144,23 +126,13 @@ def __init__(self, hass, device_info):
         self._colours.set_initial_colours(device_info)
         # Create the processor for the camera.
         self.processor = CameraProcessor(self.hass, self._shared)
-        self._attr_brand = "MQTT Vacuum Camera"
 
-    @staticmethod
-    def _handle_init_shared_data(mqtt_listen_topic: str, device_info):
-        """Handle the shared data initialization."""
-        manager, shared, file_name = None, None, None
-        if mqtt_listen_topic:
-            manager = CameraSharedManager(
-                mqtt_listen_topic.split("/")[1].lower(), device_info
-            )
-            shared = manager.get_instance()
-            file_name = shared.file_name
-            _LOGGER.debug(f"Camera {file_name} Starting up..")
-        return shared, file_name
+        # Listen to the vacuum.start event
+        self.hass.bus.async_listen("vacuum.start", self.handle_vacuum_start)
 
     @staticmethod
     def _start_up_logs():
+        """Logs the machine running the component data"""
         _LOGGER.info(f"System Release: {platform.node()}, {platform.release()}")
         _LOGGER.info(f"System Version: {platform.version()}")
         _LOGGER.info(f"System Machine: {platform.machine()}")
@@ -172,6 +144,7 @@ def _start_up_logs():
         )
 
     def _init_clear_www_folder(self):
+        """Remove PNG and ZIP's stored in HA config WWW"""
         # If enable_snapshots check if for png in www
         if not self._shared.enable_snapshots and os.path.isfile(
             f"{self._directory_path}/www/snapshot_{self._file_name}.png"
@@ -263,6 +236,13 @@ def extra_state_attributes(self) -> dict:
 
         return attributes
 
+    async def handle_vacuum_start(self, event):
+        """Handle the vacuum.start event."""
+        _LOGGER.debug(f"Received event: {event.event_type}, Data: {event.data}")
+
+        # Call the reset_trims service when vacuum.start event occurs
+        await self.hass.services.async_call("mqtt_vacuum_camera", "reset_trims")
+
     @property
     def should_poll(self) -> bool:
         """ON/OFF Camera Polling"""

custom_components/mqtt_vacuum_camera/camera_processing.py

@@ -1,6 +1,6 @@
 """
 Multiprocessing module
-Version: v2024.09.0
+Version: v2024.10.0
 This module provide the image multiprocessing in order to
 avoid the overload of the main_thread of Home Assistant.
 """

custom_components/mqtt_vacuum_camera/camera_shared.py

@@ -1,14 +1,12 @@
 """
 Class Camera Shared.
 Keep the data between the modules.
-Version: v2024.09.0
+Version: v2024.10.0
 """
 
 import asyncio
 import logging
 
-from custom_components.mqtt_vacuum_camera.types import Colors
-
 from .const import (
     ATTR_CALIBRATION_POINTS,
     ATTR_MARGINS,
@@ -35,6 +33,7 @@
     CONF_ZOOM_LOCK_RATIO,
     DEFAULT_VALUES,
 )
+from .types import Colors
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -160,9 +159,9 @@ def __init__(self, file_name, device_info):
         self.device_info = device_info
 
         # Automatically initialize shared data for the instance
-        self._init_shared_data(device_info)
+        # self._init_shared_data(device_info)
 
-    def _init_shared_data(self, device_info):
+    def update_shared_data(self, device_info):
         """Initialize the shared data with device_info."""
         instance = self.get_instance()  # Retrieve the correct instance
 

custom_components/mqtt_vacuum_camera/common.py

@@ -1,6 +1,6 @@
 """
 Common functions for the MQTT Vacuum Camera integration.
-Version: 2024.07.4
+Version: 2024.10.0
 """
 
 from __future__ import annotations
@@ -20,7 +20,7 @@
 _LOGGER = logging.getLogger(__name__)
 
 
-def get_device_info(
+def get_vacuum_device_info(
     config_entry_id: str, hass: HomeAssistant
 ) -> tuple[str, DeviceEntry] | None:
     """
@@ -44,6 +44,16 @@ def get_device_info(
     return vacuum_entity_id, vacuum_device
 
 
+def get_camera_device_info(hass, entry):
+    """Fetch the device info from the device registry based on entry_id or identifier."""
+    camera_entry = dict(hass.config_entries.async_get_entry(str(entry.entry_id)).data)
+    camera_entry_options = dict(
+        hass.config_entries.async_get_entry(str(entry.entry_id)).options
+    )
+    camera_entry.update(camera_entry_options)
+    return camera_entry
+
+
 def get_entity_identifier_from_mqtt(
     mqtt_identifier: str, hass: HomeAssistant
 ) -> str | None: