413 lines
14 KiB
Python
413 lines
14 KiB
Python
|
"""Reolink Camera Media Source Implementation."""
|
||
|
|
from urllib import parse
|
||
|
|
import secrets
|
||
|
|
import datetime as dt
|
||
|
|
import logging
|
||
|
|
from typing import Optional, Tuple
|
||
|
|
from aiohttp import web
|
||
|
|
from haffmpeg.tools import IMAGE_JPEG
|
||
|
|
|
||
|
|
from dateutil import relativedelta
|
||
|
|
|
||
|
|
from homeassistant.core import HomeAssistant, callback
|
||
|
|
|
||
|
|
import homeassistant.util.dt as dt_utils
|
||
|
|
|
||
|
|
from homeassistant.components.http import HomeAssistantView
|
||
|
|
|
||
|
|
# from homeassistant.components.http.auth import async_sign_path
|
||
|
|
from homeassistant.components.media_player.errors import BrowseError
|
||
|
|
from homeassistant.components.media_player.const import (
|
||
|
|
MEDIA_CLASS_DIRECTORY,
|
||
|
|
MEDIA_CLASS_VIDEO,
|
||
|
|
MEDIA_TYPE_VIDEO,
|
||
|
|
)
|
||
|
|
from homeassistant.components.media_source.const import MEDIA_MIME_TYPES
|
||
|
|
from homeassistant.components.media_source.error import MediaSourceError, Unresolvable
|
||
|
|
from homeassistant.components.media_source.models import (
|
||
|
|
BrowseMediaSource,
|
||
|
|
MediaSource,
|
||
|
|
MediaSourceItem,
|
||
|
|
PlayMedia,
|
||
|
|
)
|
||
|
|
|
||
|
|
from homeassistant.components.stream import create_stream
|
||
|
|
from homeassistant.components.ffmpeg import async_get_image
|
||
|
|
|
||
|
|
from custom_components.reolink_dev.base import ReolinkBase
|
||
|
|
|
||
|
|
from . import typings
|
||
|
|
|
||
|
|
from .const import BASE, DEFAULT_THUMBNAIL_OFFSET, DOMAIN
|
||
|
|
|
||
|
|
_LOGGER = logging.getLogger(__name__)
|
||
|
|
# MIME_TYPE = "rtmp/mp4"
|
||
|
|
# MIME_TYPE = "video/mp4"
|
||
|
|
MIME_TYPE = "application/x-mpegURL"
|
||
|
|
|
||
|
|
NAME = "Reolink IP Camera"
|
||
|
|
|
||
|
|
|
||
|
|
class IncompatibleMediaSource(MediaSourceError):
|
||
|
|
"""Incompatible media source attributes."""
|
||
|
|
|
||
|
|
|
||
|
|
async def async_get_media_source(hass: HomeAssistant):
|
||
|
|
"""Set up Reolink media source."""
|
||
|
|
_LOGGER.debug("Creating REOLink Media Source")
|
||
|
|
source = ReolinkSource(hass)
|
||
|
|
hass.http.register_view(ReolinkSourceThumbnailView(hass, source))
|
||
|
|
return source
|
||
|
|
|
||
|
|
|
||
|
|
class ReolinkSource(MediaSource):
|
||
|
|
"""Provide Reolink camera recordings as media sources."""
|
||
|
|
|
||
|
|
name: str = NAME
|
||
|
|
|
||
|
|
def __init__(self, hass: HomeAssistant):
|
||
|
|
"""Initialize Reolink source."""
|
||
|
|
super().__init__(DOMAIN)
|
||
|
|
self.hass = hass
|
||
|
|
self.cache = {}
|
||
|
|
|
||
|
|
async def async_resolve_media(self, item: MediaSourceItem) -> PlayMedia:
|
||
|
|
"""Resolve a media item to a playable item."""
|
||
|
|
_, camera_id, event_id = async_parse_identifier(item)
|
||
|
|
cache: typings.MediaSourceCacheEntry = self.cache[camera_id]
|
||
|
|
event = cache["playback_events"][event_id]
|
||
|
|
base: ReolinkBase = self.hass.data[DOMAIN][cache["entry_id"]][BASE]
|
||
|
|
url = await base.api.get_vod_source(event["file"])
|
||
|
|
_LOGGER.debug("Load VOD %s", url)
|
||
|
|
stream = create_stream(self.hass, url)
|
||
|
|
stream.add_provider("hls", timeout=600)
|
||
|
|
url: str = stream.endpoint_url("hls")
|
||
|
|
# the media browser seems to have a problem with the master_playlist
|
||
|
|
# ( it does not load the referenced playlist ) so we will just
|
||
|
|
# force the reference playlist instead, this seems to work
|
||
|
|
# though technically wrong
|
||
|
|
url = url.replace("master_", "")
|
||
|
|
_LOGGER.debug("Proxy %s", url)
|
||
|
|
return PlayMedia(url, MIME_TYPE)
|
||
|
|
|
||
|
|
async def async_browse_media(
|
||
|
|
self, item: MediaSourceItem, media_types: Tuple[str] = MEDIA_MIME_TYPES
|
||
|
|
) -> BrowseMediaSource:
|
||
|
|
"""Browse media."""
|
||
|
|
|
||
|
|
try:
|
||
|
|
source, camera_id, event_id = async_parse_identifier(item)
|
||
|
|
except Unresolvable as err:
|
||
|
|
raise BrowseError(str(err)) from err
|
||
|
|
|
||
|
|
_LOGGER.debug("Browsing %s, %s, %s", source, camera_id, event_id)
|
||
|
|
|
||
|
|
if camera_id and camera_id not in self.cache:
|
||
|
|
raise BrowseError("Camera does not exist.")
|
||
|
|
|
||
|
|
if (
|
||
|
|
event_id
|
||
|
|
and not "/" in event_id
|
||
|
|
and event_id not in self.cache[camera_id]["playback_events"]
|
||
|
|
):
|
||
|
|
raise BrowseError("Event does not exist.")
|
||
|
|
|
||
|
|
return await self._async_browse_media(source, camera_id, event_id, False)
|
||
|
|
|
||
|
|
async def _async_browse_media(
|
||
|
|
self, source: str, camera_id: str, event_id: str = None, no_descend: bool = True
|
||
|
|
) -> BrowseMediaSource:
|
||
|
|
""" actual browse after input validation """
|
||
|
|
event: typings.VodEvent = None
|
||
|
|
cache: typings.MediaSourceCacheEntry = None
|
||
|
|
start_date = None
|
||
|
|
|
||
|
|
if camera_id and camera_id in self.cache:
|
||
|
|
cache = self.cache[camera_id]
|
||
|
|
|
||
|
|
if cache and event_id:
|
||
|
|
if "playback_events" in cache and event_id in cache["playback_events"]:
|
||
|
|
event = cache["playback_events"][event_id]
|
||
|
|
end_date = event["end"]
|
||
|
|
start_date = event["start"]
|
||
|
|
time = start_date.time()
|
||
|
|
duration = end_date - start_date
|
||
|
|
|
||
|
|
title = f"{time} {duration}"
|
||
|
|
else:
|
||
|
|
year, *rest = event_id.split("/", 3)
|
||
|
|
month = rest[0] if len(rest) > 0 else None
|
||
|
|
day = rest[1] if len(rest) > 1 else None
|
||
|
|
|
||
|
|
start_date = dt.datetime.combine(
|
||
|
|
dt.date(
|
||
|
|
int(year), int(month) if month else 1, int(day) if day else 1
|
||
|
|
),
|
||
|
|
dt.time.min,
|
||
|
|
dt_utils.now().tzinfo,
|
||
|
|
)
|
||
|
|
|
||
|
|
title = f"{start_date.date()}"
|
||
|
|
|
||
|
|
path = f"{source}/{camera_id}/{event_id}"
|
||
|
|
else:
|
||
|
|
if cache is None:
|
||
|
|
camera_id = ""
|
||
|
|
title = NAME
|
||
|
|
else:
|
||
|
|
title = cache["name"]
|
||
|
|
|
||
|
|
path = f"{source}/{camera_id}"
|
||
|
|
|
||
|
|
media_class = MEDIA_CLASS_DIRECTORY if event is None else MEDIA_CLASS_VIDEO
|
||
|
|
|
||
|
|
media = BrowseMediaSource(
|
||
|
|
domain=DOMAIN,
|
||
|
|
identifier=path,
|
||
|
|
media_class=media_class,
|
||
|
|
media_content_type=MEDIA_TYPE_VIDEO,
|
||
|
|
title=title,
|
||
|
|
can_play=bool(not event is None and event.get("file")),
|
||
|
|
can_expand=event is None,
|
||
|
|
)
|
||
|
|
|
||
|
|
if not event is None and cache.get("playback_thumbnails", False):
|
||
|
|
url = "/api/" + DOMAIN + f"/media_proxy/{camera_id}/{event_id}"
|
||
|
|
|
||
|
|
# TODO : I cannot find a way to get the current user context at this point
|
||
|
|
# so I will have to leave the view as unauthenticated, as a temporary
|
||
|
|
# security measure, I will add a unique token to the event to limit
|
||
|
|
# "exposure"
|
||
|
|
# url = async_sign_path(self.hass, None, url, dt.timedelta(minutes=30))
|
||
|
|
if "token" not in event:
|
||
|
|
event["token"] = secrets.token_hex()
|
||
|
|
media.thumbnail = f"{url}?token={parse.quote_plus(event['token'])}"
|
||
|
|
|
||
|
|
if not media.can_play and not media.can_expand:
|
||
|
|
_LOGGER.debug(
|
||
|
|
"Camera %s with event %s without media url found", camera_id, event_id
|
||
|
|
)
|
||
|
|
raise IncompatibleMediaSource
|
||
|
|
|
||
|
|
if not media.can_expand or no_descend:
|
||
|
|
return media
|
||
|
|
|
||
|
|
media.children = []
|
||
|
|
|
||
|
|
base: ReolinkBase = None
|
||
|
|
|
||
|
|
if cache is None:
|
||
|
|
for entry_id in self.hass.data[DOMAIN]:
|
||
|
|
entry = self.hass.data[DOMAIN][entry_id]
|
||
|
|
if not isinstance(entry, dict) or not BASE in entry:
|
||
|
|
continue
|
||
|
|
base = entry[BASE]
|
||
|
|
camera_id = base.unique_id
|
||
|
|
cache = self.cache.get(camera_id, None)
|
||
|
|
if cache is None:
|
||
|
|
cache = self.cache[camera_id] = {
|
||
|
|
"entry_id": entry_id,
|
||
|
|
"unique_id": base.unique_id,
|
||
|
|
"playback_events": {},
|
||
|
|
}
|
||
|
|
cache["name"] = base.name
|
||
|
|
|
||
|
|
child = await self._async_browse_media(source, camera_id)
|
||
|
|
media.children.append(child)
|
||
|
|
return media
|
||
|
|
|
||
|
|
base = self.hass.data[DOMAIN][cache["entry_id"]][BASE]
|
||
|
|
|
||
|
|
# TODO: the cache is one way so over time it can grow and have invalid
|
||
|
|
# records, the code should be expanded to invalidate/expire
|
||
|
|
# entries
|
||
|
|
|
||
|
|
if base is None:
|
||
|
|
raise BrowseError("Camera does not exist.")
|
||
|
|
|
||
|
|
if not start_date:
|
||
|
|
if (
|
||
|
|
"playback_day_entries" not in cache
|
||
|
|
or cache.get("playback_months", -1) != base.playback_months
|
||
|
|
):
|
||
|
|
end_date = dt_utils.now()
|
||
|
|
start_date = dt.datetime.combine(end_date.date(), dt.time.min)
|
||
|
|
cache["playback_months"] = base.playback_months
|
||
|
|
if cache["playback_months"] > 1:
|
||
|
|
start_date -= relativedelta.relativedelta(
|
||
|
|
months=int(cache["playback_months"])
|
||
|
|
)
|
||
|
|
|
||
|
|
entries = cache["playback_day_entries"] = []
|
||
|
|
|
||
|
|
search, _ = await base.api.send_search(start_date, end_date, True)
|
||
|
|
|
||
|
|
if not search is None:
|
||
|
|
for status in search:
|
||
|
|
year = status["year"]
|
||
|
|
month = status["mon"]
|
||
|
|
for day, flag in enumerate(status["table"], start=1):
|
||
|
|
if flag == "1":
|
||
|
|
entries.append(dt.date(year, month, day))
|
||
|
|
|
||
|
|
entries.sort()
|
||
|
|
else:
|
||
|
|
entries = cache["playback_day_entries"]
|
||
|
|
|
||
|
|
for date in cache["playback_day_entries"]:
|
||
|
|
child = await self._async_browse_media(
|
||
|
|
source, camera_id, f"{date.year}/{date.month}/{date.day}"
|
||
|
|
)
|
||
|
|
media.children.append(child)
|
||
|
|
|
||
|
|
return media
|
||
|
|
|
||
|
|
cache["playback_thumbnails"] = base.playback_thumbnails
|
||
|
|
|
||
|
|
end_date = dt.datetime.combine(
|
||
|
|
start_date.date(), dt.time.max, start_date.tzinfo
|
||
|
|
)
|
||
|
|
|
||
|
|
_, files = await base.api.send_search(start_date, end_date)
|
||
|
|
|
||
|
|
if not files is None:
|
||
|
|
events = cache.setdefault("playback_events", {})
|
||
|
|
|
||
|
|
for file in files:
|
||
|
|
dto = file["EndTime"]
|
||
|
|
end_date = dt.datetime(
|
||
|
|
dto["year"],
|
||
|
|
dto["mon"],
|
||
|
|
dto["day"],
|
||
|
|
dto["hour"],
|
||
|
|
dto["min"],
|
||
|
|
dto["sec"],
|
||
|
|
0,
|
||
|
|
end_date.tzinfo,
|
||
|
|
)
|
||
|
|
dto = file["StartTime"]
|
||
|
|
start_date = dt.datetime(
|
||
|
|
dto["year"],
|
||
|
|
dto["mon"],
|
||
|
|
dto["day"],
|
||
|
|
dto["hour"],
|
||
|
|
dto["min"],
|
||
|
|
dto["sec"],
|
||
|
|
0,
|
||
|
|
end_date.tzinfo,
|
||
|
|
)
|
||
|
|
event_id = str(start_date.timestamp())
|
||
|
|
event = events.setdefault(event_id, {})
|
||
|
|
event["start"] = start_date
|
||
|
|
event["end"] = end_date
|
||
|
|
event["file"] = file["name"]
|
||
|
|
|
||
|
|
child = await self._async_browse_media(source, camera_id, event_id)
|
||
|
|
media.children.append(child)
|
||
|
|
|
||
|
|
return media
|
||
|
|
|
||
|
|
|
||
|
|
class ReolinkSourceThumbnailView(HomeAssistantView):
|
||
|
|
""" Thumbnial view handler """
|
||
|
|
|
||
|
|
url = "/api/" + DOMAIN + "/media_proxy/{camera_id}/{event_id}"
|
||
|
|
name = "api:" + DOMAIN + ":image"
|
||
|
|
requires_auth = False
|
||
|
|
cors_allowed = True
|
||
|
|
|
||
|
|
def __init__(self, hass: HomeAssistant, source: ReolinkSource):
|
||
|
|
"""Initialize media view """
|
||
|
|
|
||
|
|
self.hass = hass
|
||
|
|
self.source = source
|
||
|
|
|
||
|
|
async def get(
|
||
|
|
self, request: web.Request, camera_id: str, event_id: str
|
||
|
|
) -> web.Response:
|
||
|
|
""" start a GET request. """
|
||
|
|
|
||
|
|
if not camera_id or not event_id:
|
||
|
|
raise web.HTTPNotFound()
|
||
|
|
|
||
|
|
cache: typings.MediaSourceCacheEntry = self.source.cache.get(camera_id, None)
|
||
|
|
if cache is None or "playback_events" not in cache:
|
||
|
|
_LOGGER.debug("camera %s not found", camera_id)
|
||
|
|
raise web.HTTPNotFound()
|
||
|
|
|
||
|
|
event = cache["playback_events"].get(event_id, None)
|
||
|
|
if event is None:
|
||
|
|
_LOGGER.debug("camera %s, event %s not found", camera_id, event_id)
|
||
|
|
raise web.HTTPNotFound()
|
||
|
|
|
||
|
|
token = request.query.get("token")
|
||
|
|
if (token and event.get("token") != token) or (
|
||
|
|
not token and not self.requires_auth
|
||
|
|
):
|
||
|
|
_LOGGER.debug(
|
||
|
|
"invalid or missing token %s for camera %s, event %s",
|
||
|
|
token,
|
||
|
|
camera_id,
|
||
|
|
event_id,
|
||
|
|
)
|
||
|
|
raise web.HTTPNotFound()
|
||
|
|
|
||
|
|
_LOGGER.debug("thumbnail %s, %s", camera_id, event_id)
|
||
|
|
|
||
|
|
base: ReolinkBase = self.hass.data[DOMAIN][cache["entry_id"]][BASE]
|
||
|
|
|
||
|
|
image = event.get("thumbnail", None)
|
||
|
|
if (
|
||
|
|
image is None
|
||
|
|
or cache.get("playback_thumbnail_offset", DEFAULT_THUMBNAIL_OFFSET)
|
||
|
|
!= base.playback_thumbnail_offset
|
||
|
|
):
|
||
|
|
cache["playback_thumbnails"] = base.playback_thumbnails
|
||
|
|
cache["playback_thumbnail_offset"] = base.playback_thumbnail_offset
|
||
|
|
|
||
|
|
if not cache["playback_thumbnails"]:
|
||
|
|
_LOGGER.debug("Thumbnails not allowed on camera %s", camera_id)
|
||
|
|
raise web.HTTPInternalServerError()
|
||
|
|
|
||
|
|
_LOGGER.debug("generating thumbnail for %s, %s", camera_id, event_id)
|
||
|
|
|
||
|
|
extra_cmd: str = None
|
||
|
|
if cache["playback_thumbnail_offset"] > 0:
|
||
|
|
extra_cmd = f"-ss {cache['playback_thumbnail_offset']}"
|
||
|
|
|
||
|
|
image = event["thumbail"] = await async_get_image(
|
||
|
|
self.hass,
|
||
|
|
await base.api.get_vod_source(event["file"]),
|
||
|
|
extra_cmd=extra_cmd,
|
||
|
|
)
|
||
|
|
_LOGGER.debug("generated thumbnail for %s, %s", camera_id, event_id)
|
||
|
|
|
||
|
|
if image:
|
||
|
|
return web.Response(body=image, content_type=IMAGE_JPEG)
|
||
|
|
|
||
|
|
_LOGGER.debug(
|
||
|
|
"No thumbnail generated for camera %s, event %s", camera_id, event_id
|
||
|
|
)
|
||
|
|
raise web.HTTPInternalServerError()
|
||
|
|
|
||
|
|
|
||
|
|
@callback
|
||
|
|
def async_parse_identifier(
|
||
|
|
item: MediaSourceItem,
|
||
|
|
) -> Tuple[str, str, Optional[str]]:
|
||
|
|
"""Parse identifier."""
|
||
|
|
if not item.identifier:
|
||
|
|
return "events", "", None
|
||
|
|
|
||
|
|
source, path = item.identifier.lstrip("/").split("/", 1)
|
||
|
|
|
||
|
|
if source != "events":
|
||
|
|
raise Unresolvable("Unknown source directory.")
|
||
|
|
|
||
|
|
if "/" in path:
|
||
|
|
camera_id, event_id = path.split("/", 1)
|
||
|
|
|
||
|
|
return source, camera_id, event_id
|
||
|
|
|
||
|
|
return source, path, None
|