Add more Foscam switches

CODE_OF_CONDUCT.md

@@ -18,7 +18,7 @@ Examples of behavior that contributes to a positive environment for our
 community include:
 
 * Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
+* Being respectful of differing opinions, viewpoints, and experiences[test_init.py](tests%2Fcomponents%2Ffoscam%2Ftest_init.py)
 * Giving and gracefully accepting constructive feedback
 * Accepting responsibility and apologizing to those affected by our mistakes,
   and learning from the experience

homeassistant/components/foscam/__init__.py

@@ -1,7 +1,5 @@
 """The foscam component."""
 
-from libpyfoscam import FoscamCamera
-
 from homeassistant.const import (
     CONF_HOST,
     CONF_PASSWORD,
@@ -10,13 +8,14 @@
     Platform,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.entity_registry import RegistryEntry, async_migrate_entries
+from homeassistant.helpers.entity_registry import async_migrate_entries
 
 from .config_flow import DEFAULT_RTSP_PORT
 from .const import CONF_RTSP_PORT, LOGGER
 from .coordinator import FoscamConfigEntry, FoscamCoordinator
+from .foscamcgi import FoscamCamera
 
-PLATFORMS = [Platform.CAMERA, Platform.SWITCH]
+PLATFORMS = [Platform.CAMERA, Platform.NOTIFY, Platform.NUMBER, Platform.SWITCH]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: FoscamConfigEntry) -> bool:
@@ -30,14 +29,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: FoscamConfigEntry) -> bo
         verbose=False,
     )
     coordinator = FoscamCoordinator(hass, entry, session)
-
+    await hass.async_add_executor_job(session.set_sub_stream_format, 1)
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = coordinator
-
-    # Migrate to correct unique IDs for switches
-    await async_migrate_entities(hass, entry)
-
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
@@ -86,24 +81,3 @@ def update_unique_id(entry):
     LOGGER.debug("Migration to version %s successful", entry.version)
 
     return True
-
-
-async def async_migrate_entities(hass: HomeAssistant, entry: FoscamConfigEntry) -> None:
-    """Migrate old entry."""
-
-    @callback
-    def _update_unique_id(
-        entity_entry: RegistryEntry,
-    ) -> dict[str, str] | None:
-        """Update unique ID of entity entry."""
-        if (
-            entity_entry.domain == Platform.SWITCH
-            and entity_entry.unique_id == "sleep_switch"
-        ):
-            entity_new_unique_id = f"{entity_entry.config_entry_id}_sleep_switch"
-            return {"new_unique_id": entity_new_unique_id}
-
-        return None
-
-    # Migrate entities
-    await async_migrate_entries(hass, entry.entry_id, _update_unique_id)

homeassistant/components/foscam/camera.py

@@ -3,14 +3,19 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import AsyncIterator
+from contextlib import suppress
 
+from aiohttp import web
+import httpx
 import voluptuous as vol
 
 from homeassistant.components.camera import Camera, CameraEntityFeature
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.httpx_client import get_async_client
 
 from .const import CONF_RTSP_PORT, CONF_STREAM, LOGGER, SERVICE_PTZ, SERVICE_PTZ_PRESET
 from .coordinator import FoscamConfigEntry, FoscamCoordinator
@@ -44,6 +49,8 @@
 ATTR_PRESET_NAME = "preset_name"
 
 PTZ_GOTO_PRESET_COMMAND = "ptz_goto_preset"
+TIMEOUT = 10
+BUFFER_SIZE = 102400
 
 
 async def async_setup_entry(
@@ -86,6 +93,27 @@ async def async_setup_entry(
     async_add_entities([HassFoscamCamera(coordinator, config_entry)])
 
 
+async def async_extract_image_from_mjpeg(stream: AsyncIterator[bytes]) -> bytes | None:
+    """Take in a MJPEG stream object, return the jpg from it."""
+    data = b""
+
+    async for chunk in stream:
+        data += chunk
+        jpg_end = data.find(b"\xff\xd9")
+
+        if jpg_end == -1:
+            continue
+
+        jpg_start = data.find(b"\xff\xd8")
+
+        if jpg_start == -1:
+            continue
+
+        return data[jpg_start : jpg_end + 2]
+
+    return None
+
+
 class HassFoscamCamera(FoscamEntity, Camera):
     """An implementation of a Foscam IP camera."""
 
@@ -137,25 +165,57 @@ async def async_added_to_hass(self) -> None:
         else:
             self._attr_motion_detection_enabled = response == 1
 
-    def camera_image(
+    async def async_camera_image(
         self, width: int | None = None, height: int | None = None
     ) -> bytes | None:
         """Return a still image response from the camera."""
-        # Send the request to snap a picture and return raw jpg data
-        # Handle exception if host is not reachable or url failed
-        result, response = self._foscam_session.snap_picture_2()
-        if result != 0:
-            return None
+        return await self._async_digest_or_fallback_camera_image()
 
-        return response
-
-    async def stream_source(self) -> str | None:
-        """Return the stream source."""
-        if self._rtsp_port:
-            return f"rtsp://{self._username}:{self._password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
+    async def _async_digest_or_fallback_camera_image(self) -> bytes | None:
+        """Return a still image response from the camera using digest authentication."""
+        client = get_async_client(self.hass)
+        try:
+            async with client.stream(
+                "get",
+                f"http://{self._foscam_session.host}:{self._foscam_session.port}/cgi-bin/CGIStream.cgi?usr={self._username}&pwd={self._password}",
+                timeout=TIMEOUT,
+            ) as stream:
+                return await async_extract_image_from_mjpeg(
+                    stream.aiter_bytes(BUFFER_SIZE)
+                )
+
+        except TimeoutError:
+            LOGGER.error("Timeout getting camera image from %s", self.name)
 
         return None
 
+    async def _handle_async_mjpeg_digest_stream(
+        self, request: web.Request
+    ) -> web.StreamResponse | None:
+        """Generate an HTTP MJPEG stream from the camera using digest authentication."""
+        async with get_async_client(self.hass).stream(
+            "get",
+            f"http://{self._foscam_session.host}:{self._foscam_session.port}/cgi-bin/CGIStream.cgi?usr={self._username}&pwd={self._password}",
+            timeout=TIMEOUT,
+        ) as stream:
+            response = web.StreamResponse(headers=stream.headers)
+            await response.prepare(request)
+            # Stream until we are done or client disconnects
+            with suppress(TimeoutError, httpx.HTTPError):
+                async for chunk in stream.aiter_bytes(BUFFER_SIZE):
+                    if not self.hass.is_running:
+                        break
+                    async with asyncio.timeout(TIMEOUT):
+                        await response.write(chunk)
+        return response
+
+    async def handle_async_mjpeg_stream(
+        self, request: web.Request
+    ) -> web.StreamResponse | None:
+        """Generate an HTTP MJPEG stream from the camera."""
+        # aiohttp don't support DigestAuth so we use httpx
+        return await self._handle_async_mjpeg_digest_stream(request)
+
     def enable_motion_detection(self) -> None:
         """Enable motion detection in camera."""
         try:

homeassistant/components/foscam/config_flow.py

@@ -2,7 +2,6 @@
 
 from typing import Any
 
-from libpyfoscam import FoscamCamera
 from libpyfoscam.foscam import (
     ERROR_FOSCAM_AUTH,
     ERROR_FOSCAM_UNAVAILABLE,
@@ -22,6 +21,7 @@
 from homeassistant.exceptions import HomeAssistantError
 
 from .const import CONF_RTSP_PORT, CONF_STREAM, DOMAIN, LOGGER
+from .foscamcgi import FoscamCamera
 
 STREAMS = ["Main", "Sub"]
 

homeassistant/components/foscam/coordinator.py

@@ -4,13 +4,12 @@
 from datetime import timedelta
 from typing import Any
 
-from libpyfoscam import FoscamCamera
-
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN, LOGGER
+from .foscamcgi import FoscamCamera
 
 type FoscamConfigEntry = ConfigEntry[FoscamCoordinator]
 
@@ -34,24 +33,52 @@ def __init__(
         )
         self.session = session
 
+    def gather_all_configs(self):
+        """Get all Foscam configurations."""
+        configs = {}
+
+        ret, dev_info = self.session.get_dev_info()
+        configs["dev_info"] = dev_info
+
+        ret, all_info = self.session.get_product_all_info()
+        configs["product_info"] = all_info
+
+        ret, infra_led_config = self.session.get_infra_led_config()
+        configs["is_openIr"] = infra_led_config["mode"]
+
+        ret, mirror_flip_setting = self.session.get_mirror_and_flip_setting()
+        configs["is_Flip"] = mirror_flip_setting["isFlip"]
+        configs["is_Mirror"] = mirror_flip_setting["isMirror"]
+
+        ret, sleep_setting = self.session.is_asleep()
+        configs["is_asleep"] = {"supported": ret == 0, "status": sleep_setting}
+
+        ret, is_openWhiteLight = self.session.getWhiteLightBrightness()
+        configs["is_openWhiteLight"] = is_openWhiteLight["enable"]
+
+        ret, is_sirenalarm = self.session.getSirenConfig()
+        configs["is_sirenalarm"] = is_sirenalarm["sirenEnable"]
+
+        ret, Volume = self.session.getAudioVolume()
+        configs["Volume"] = Volume["volume"]
+
+        ret, SpeakVolume = self.session.getSpeakVolume()
+        configs["SpeakVolume"] = SpeakVolume["SpeakVolume"]
+
+        ret, is_TurnOffVolume = self.session.getVoiceEnableState()
+        configs["is_TurnOffVolume"] = 0 if int(is_TurnOffVolume["isEnable"]) == 1 else 1
+
+        ret, is_TurnOffLight = self.session.getLedEnableState()
+        configs["is_TurnOffLight"] = 0 if int(is_TurnOffLight["isEnable"]) == 1 else 1
+        if ((1 << 8) & int(all_info["reserve3"])) != 0:
+            ret, is_OpenWdr = self.session.getWdrMode()
+            configs["is_OpenWdr"] = is_OpenWdr["mode"]
+        else:
+            ret, is_OpenHdr = self.session.getHdrMode()
+            configs["is_OpenHdr"] = is_OpenHdr["mode"]
+        return configs
+
     async def _async_update_data(self) -> dict[str, Any]:
         """Fetch data from API endpoint."""
-
         async with asyncio.timeout(30):
-            data = {}
-            ret, dev_info = await self.hass.async_add_executor_job(
-                self.session.get_dev_info
-            )
-            if ret == 0:
-                data["dev_info"] = dev_info
-
-            all_info = await self.hass.async_add_executor_job(
-                self.session.get_product_all_info
-            )
-            data["product_info"] = all_info[1]
-
-            ret, is_asleep = await self.hass.async_add_executor_job(
-                self.session.is_asleep
-            )
-            data["is_asleep"] = {"supported": ret == 0, "status": is_asleep}
-            return data
+            return await self.hass.async_add_executor_job(self.gather_all_configs)