async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up an Amcrest IP Camera."""
if discovery_info is None:
return
name = discovery_info[CONF_NAME]
device = hass.data[DATA_AMCREST][DEVICES][name]
entity = AmcrestCam(name, device, get_ffmpeg_manager(hass))
# 2021.9.0 introduced unique id's for the camera entity, but these were not
# unique for different resolution streams. If any cameras were configured
# with this version, update the old entity with the new unique id.
serial_number = await device.api.async_serial_number
serial_number = serial_number.strip()
registry = entity_registry.async_get(hass)
entity_id = registry.async_get_entity_id(CAMERA_DOMAIN, DOMAIN,
serial_number)
if entity_id is not None:
_LOGGER.debug("Updating unique id for camera %s", entity_id)
new_unique_id = f"{serial_number}-{device.resolution}-{device.channel}"
registry.async_update_entity(entity_id, new_unique_id=new_unique_id)
async_add_entities([entity], True)
def __init__(
self,
hass: HomeAssistant,
coordinator: EzvizDataUpdateCoordinator,
serial: str,
camera_username: str,
camera_password: str | None,
camera_rtsp_stream: str | None,
local_rtsp_port: int,
ffmpeg_arguments: str | None,
) -> None:
"""Initialize a Ezviz security camera."""
super().__init__(coordinator, serial)
Camera.__init__(self)
self.stream_options[CONF_USE_WALLCLOCK_AS_TIMESTAMPS] = True
self._username = camera_username
self._password = camera_password
self._rtsp_stream = camera_rtsp_stream
self._local_rtsp_port = local_rtsp_port
self._ffmpeg_arguments = ffmpeg_arguments
self._ffmpeg = get_ffmpeg_manager(hass)
self._attr_unique_id = serial
self._attr_name = self.data["name"]
if camera_password:
self._attr_supported_features = CameraEntityFeature.STREAM
async def handle_async_mjpeg_stream(
self, request: web.Request) -> web.StreamResponse:
"""Generate an HTTP MJPEG stream from the latest recorded activity."""
stream = CameraMjpeg(get_ffmpeg_manager(self.hass).binary)
url = await self.coordinator.device.async_get_activity_video_url()
await stream.open_camera(url, extra_cmd="-r 210")
try:
return await async_aiohttp_proxy_stream(
self.hass,
request,
await stream.get_reader(),
get_ffmpeg_manager(self.hass).ffmpeg_stream_content_type,
)
finally:
await stream.close()
def __init__(
self,
hass: HomeAssistant,
coordinator: CanaryDataUpdateCoordinator,
location_id: str,
device: Device,
ffmpeg_args: str,
) -> None:
"""Initialize a Canary security camera."""
super().__init__(coordinator)
Camera.__init__(self)
self._ffmpeg: FFmpegManager = get_ffmpeg_manager(hass)
self._ffmpeg_arguments = ffmpeg_args
self._location_id = location_id
self._device = device
self._live_stream_session: LiveStreamSession | None = None
self._attr_name = device.name
self._attr_unique_id = str(device.device_id)
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, str(device.device_id))},
manufacturer=MANUFACTURER,
model=device.device_type["name"],
name=device.name,
)
self._image: bytes | None = None
self._expires_at = dt_util.utcnow()
_LOGGER.debug("%s %s has been initialized", self.name,
device.device_type["name"])
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry,
async_add_entities: AddEntitiesCallback) -> None:
"""Set up a Logi Circle Camera based on a config entry."""
devices = await hass.data[LOGI_CIRCLE_DOMAIN].cameras
ffmpeg = get_ffmpeg_manager(hass)
cameras = [LogiCam(device, entry, ffmpeg) for device in devices]
async_add_entities(cameras, True)
async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the FFmpeg binary motion sensor."""
manager = get_ffmpeg_manager(hass)
entity = FFmpegMotion(hass, manager, config)
async_add_entities([entity])
def __init__(self, hass, camera, device_info):
"""Initialize an Arlo camera."""
super().__init__()
self._camera = camera
self._attr_name = camera.name
self._motion_status = False
self._ffmpeg = get_ffmpeg_manager(hass)
self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
self._last_refresh = None
self.attrs = {}
def __init__(self, hass, config):
"""Initialize."""
super().__init__()
self._extra_arguments = config.get(CONF_FFMPEG_ARGUMENTS)
self._last_image = None
self._last_url = None
self._manager = get_ffmpeg_manager(hass)
self._name = config[CONF_NAME]
self._is_on = True
self.host = config[CONF_HOST]
self.port = config[CONF_PORT]
self.path = config[CONF_PATH]
self.user = config[CONF_USERNAME]
self.passwd = config[CONF_PASSWORD]
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Set up a Ring Door Bell and StickUp Camera."""
devices = hass.data[DOMAIN][config_entry.entry_id]["devices"]
ffmpeg_manager = ffmpeg.get_ffmpeg_manager(hass)
cams = []
for camera in chain(devices["doorbots"], devices["authorized_doorbots"],
devices["stickup_cams"]):
if not camera.has_subscription:
continue
cams.append(RingCam(config_entry.entry_id, ffmpeg_manager, camera))
async_add_entities(cams)
def __init__(
self,
hass: HomeAssistant,
coordinator: EzvizDataUpdateCoordinator,
serial: str,
camera_username: str,
camera_password: str | None,
camera_rtsp_stream: str | None,
local_rtsp_port: int,
ffmpeg_arguments: str | None,
) -> None:
"""Initialize a Ezviz security camera."""
super().__init__(coordinator, serial)
Camera.__init__(self)
self._username = camera_username
self._password = camera_password
self._rtsp_stream = camera_rtsp_stream
self._local_rtsp_port = local_rtsp_port
self._ffmpeg_arguments = ffmpeg_arguments
self._ffmpeg = get_ffmpeg_manager(hass)
self._attr_unique_id = serial
self._attr_name = self.data["name"]
async def handle_async_mjpeg_stream(self, request):
"""Generate an HTTP MJPEG stream from the camera."""
LOGGER.debug("Handling mjpeg stream from camera '%s'", self.device.name)
ffmpeg_manager = get_ffmpeg_manager(self.hass)
stream = CameraMjpeg(ffmpeg_manager.binary)
await stream.open_camera(
self._stream_uri,
extra_cmd=self.device.config_entry.options.get(CONF_EXTRA_ARGUMENTS),
)
try:
stream_reader = await stream.get_reader()
return await async_aiohttp_proxy_stream(
self.hass,
request,
stream_reader,
ffmpeg_manager.ffmpeg_stream_content_type,
)
finally:
await stream.close()
async def async_get_transcoder(hass: HomeAssistant) -> Transcoder:
"""Get a nest clip transcoder."""
media_path = hass.config.path(MEDIA_PATH)
ffmpeg_manager = get_ffmpeg_manager(hass)
return Transcoder(ffmpeg_manager.binary, media_path)
def __init__(self, hass, driver, name, entity_id, aid, config):
"""Initialize a Camera accessory object."""
self._ffmpeg = get_ffmpeg_manager(hass)
for config_key, conf in CONFIG_DEFAULTS.items():
if config_key not in config:
config[config_key] = conf
max_fps = config[CONF_MAX_FPS]
max_width = config[CONF_MAX_WIDTH]
max_height = config[CONF_MAX_HEIGHT]
resolutions = [
(w, h, fps)
for w, h, fps in SLOW_RESOLUTIONS
if w <= max_width and h <= max_height and fps < max_fps
] + [
(w, h, max_fps)
for w, h in RESOLUTIONS
if w <= max_width and h <= max_height
]
video_options = {
"codec": {
"profiles": [
VIDEO_CODEC_PARAM_PROFILE_ID_TYPES["BASELINE"],
VIDEO_CODEC_PARAM_PROFILE_ID_TYPES["MAIN"],
VIDEO_CODEC_PARAM_PROFILE_ID_TYPES["HIGH"],
],
"levels": [
VIDEO_CODEC_PARAM_LEVEL_TYPES["TYPE3_1"],
VIDEO_CODEC_PARAM_LEVEL_TYPES["TYPE3_2"],
VIDEO_CODEC_PARAM_LEVEL_TYPES["TYPE4_0"],
],
},
"resolutions": resolutions,
}
audio_options = {
"codecs": [
{"type": "OPUS", "samplerate": 24},
{"type": "OPUS", "samplerate": 16},
]
}
stream_address = config.get(CONF_STREAM_ADDRESS, driver.state.address)
options = {
"video": video_options,
"audio": audio_options,
"address": stream_address,
"srtp": True,
"stream_count": config[CONF_STREAM_COUNT],
}
super().__init__(
hass,
driver,
name,
entity_id,
aid,
config,
category=CATEGORY_CAMERA,
options=options,
)
self._char_motion_detected = None
self.linked_motion_sensor = self.config.get(CONF_LINKED_MOTION_SENSOR)
if self.linked_motion_sensor:
state = self.hass.states.get(self.linked_motion_sensor)
if state:
serv_motion = self.add_preload_service(SERV_MOTION_SENSOR)
self._char_motion_detected = serv_motion.configure_char(
CHAR_MOTION_DETECTED, value=False
)
self._async_update_motion_state(state)
self._char_doorbell_detected = None
self._char_doorbell_detected_switch = None
self.linked_doorbell_sensor = self.config.get(CONF_LINKED_DOORBELL_SENSOR)
if self.linked_doorbell_sensor:
state = self.hass.states.get(self.linked_doorbell_sensor)
if state:
serv_doorbell = self.add_preload_service(SERV_DOORBELL)
self.set_primary_service(serv_doorbell)
self._char_doorbell_detected = serv_doorbell.configure_char(
CHAR_PROGRAMMABLE_SWITCH_EVENT,
value=0,
)
serv_stateless_switch = self.add_preload_service(
SERV_STATELESS_PROGRAMMABLE_SWITCH
)
self._char_doorbell_detected_switch = (
serv_stateless_switch.configure_char(
CHAR_PROGRAMMABLE_SWITCH_EVENT,
value=0,
valid_values={"SinglePress": DOORBELL_SINGLE_PRESS},
)
)
serv_speaker = self.add_preload_service(SERV_SPEAKER)
serv_speaker.configure_char(CHAR_MUTE, value=0)
self._async_update_doorbell_state(state)
