This is the README for 0.8.1, if you are using version 0.7; see here for the correct README
Finally. Thanks to @NickM-27 for starting this. After sitting on it for far too long I decided to do the work I needed to, this integration now acts much like every intergration, splitting down by entity, device and integration.
This means a lot of this documentation is now out of date, I will upgrade it when all the option changes have been finalised, for now I will just add a quick note inline.
For now I recommend leaving your old configuration in place so you can revert back to a 0.7 release if you encounter an issue.
The code now uses Pyaarlo by installing it via pip rather than maintaining its own version. If you run into a problem check the Pyaarlo README file,it may have a fix not mentioned here.
The code will retry authorization tokens for as long as they are valid. This
means a reduction in authentication attempts and 2FA requests. If this does
not work for you send me some logs showing the error and restart with
save_session: False
added to your configuration.
You will now have less to configure... for example, device refresh and stream timeouts are enabled by default.
The following options have been removed:
hide_deprecated_services
; all component services are now in the aarlo
http_connections
; no longer used after cloudscraper was neededhttp_max_size
; no longer used after cloudscraper was neededAarlo is an Asynchronous Arlo component for Home Assistant, it uses the Arlo Website APIs to function and supports base stations, cameras, lights and doorbells.
Aarlo is based on the original Arlo component and it can operate as replacement with minimal configuration changes.
Aarlo also provides a custom Lovelace Card, which overlays a camera's last snapshot with its current status and allows access to the cameras recording library and live-streaming.
Aarlo provides:
This document assumes you are familiar with Home Assistant setup and configuration.
Wherever you see /config
in this document it refers to your Home Assistant
configuration directory. For example, for my installation it's
/home/steve/ha
which is mapped to /config
by my docker container.
If you aren't familiar with Home Assistant I recommend visiting the Community Website. It's full of helpful people and there is always someone who's encountered the problem you are trying to fix.
Many thanks to:
Pyarlo and Arlo for doing all the hard work figuring the API out and the free Python lesson!
sseclient for reading from the event stream
Button Card for a working Lovelace card I could understand
JetBrains for the excellent PyCharm IDE and providing me with an open source licence to speed up the project development.
You only need to use one of these installation mechanisms. I recommend HACS.
Aarlo is part of the default HACS store. If you're not interested in development branches this is the easiest way to install.
Copy the aarlo
directory into your /config/custom_components
directory.
Run the installation script. Run it once to make sure the operations look sane
and run it a second time with the go
parameter to do the actual work. If you
update just rerun the script, it will overwrite all installed files.
install /config
# check output looks good
install go /config
You can replace all instances of arlo
with aarlo
in your Home Assistant
configuration files to start using Aarlo. The following sections detail new
configuration items you can use to add extra functionality to your new Aarlo
component.
You can also run Arlo and Aarlo side by side but you will need to create an Aarlo specific login.
If you are replacing the original Arlo component you don't need to do this step.
Aarlo needs a dedicated Aarlo login. If you try to reuse an existing login - for example, the login from the Arlo app on your phone - the app and this component will constantly fight to log in.
When you have created the Aarlo login, from your original Arlo account grant access to any devices you want to share and give the Aarlo user admin access.
This is now handled from the Integration Page
The following configuration is the minimum needed.
aarlo:
username: !secret arlo_username
password: !secret arlo_password
** This is now handled from the Integration Configure Pages **
The following enables and configures the base stations.
alarm_control_panel:
- platform: aarlo
away_mode_name: armed
home_mode_name: home
night_mode_name: night
trigger_time: 30
alarm_volume: 8
away_mode_name
Arlo mode to use when setting alarm to Armed Away
.armed
which maps to Arlo's default Armed
mode.disarmed_mode_name
Arlo mode to use when setting alarm to Disarmed
.disarmed
which maps to Arlo's default Disarmed
mode.home_mode_name
Arlo mode to use when setting alarm to Armed Home
.home
.night_mode_name
Arlo mode to use when setting alarm to Armed Night
.night
.trigger_time
determines how long, in seconds, the triggered alarm willalarm_volume
determine how loud, from 1 to 8, the triggered alarm willArlo does not have a built in home
or night
mode. If you need them create
a custom mode in Arlo and home_mode_name
and night_mode_name
to map to
them. You don't need to map all modes - I don't use night_mode
. Names are
case-insensitive. Using duplicate names will cause problems, for example,
mapping both away
and night
mode to armed
will work when setting the
mode from Home Assistant but might not show the correct mode if you change it
in the Arlo app.
See here for more information on mode names.
This is now handled from the Integration Configure Pages
The following enables any cameras.
camera:
- platform: aarlo
The following enables and configures the binary sensors.
binary_sensor:
- platform: aarlo
monitored_conditions:
- motion
- sound
- ding
- cry
- connectivity
Items on the monitored_conditions
can be one or more of the following:
motion
fires when a camera, doorbell or light detects motion.sound
fires when a camera detects a sound.ding
fires when a doorbell is pressed.cry
fires when crying is detected (ArloBaby only)connectivity
is true when Arlo a device is connectedThe Arlo backend sends the notifications on the event stream so they are (almost) real time.
This is now handled from the Integration Configure Pages
The following enables and configures the sensors.
sensor:
- platform: aarlo
monitored_conditions:
- total_cameras
- last_capture
- recent_activity
- captured_today
- battery_level
- signal_strength
- temperature
- humidity
- air_quality
Items on the monitored_conditions
can be one or more of the following:
total_cameras
is a global sensor showing the number of cameras detected.The rest of the sensors appear per camera.
last_capture
The last time an event was captured by this camera.recent_activity
Is on
if activity was recently seen on the camera.captured_today
The number of events captured by the camera today.battery_level
The percentage of battery remaining.signal_strength
The Wi-Fi signal strength of the camera.temperature
The temperature in the room where the camera is, if supported.humidity
The humidity in the room where the camera is, if supported.air_quality
The air quality in the room where the camera is, if supported.If you have an Arlo Smart Plan the last_capture
sensor has the attribute
'object_type' containing what Arlo cloud service identified as starting the
recording ("Person", "Vehicle", "Animal", ...). You can use templates in Home
Assistant to trigger automations on different object types.
Note: It is important to note a limitation from pyaarlo that the 'object_type' only gets updated AFTER arlo has processed what caused the motion.
This is now handled from the Integration Configure Pages
The following enables any lights:
light:
- platform: aarlo
The component supports the standard Arlo Light, Arlo Baby Light and Arlo Pro 3 Floodlight.
There is one quirk; on all lights but the Arlo Pro 3 Floodlight you can adjust the brightness of a light while it is on but the change will not take effect until you turn the light off and back on again. This how the official web interface works.
This is now handled from the Integration Configure Pages
The following enables and configures some pseudo switches:
switch:
- platform: aarlo
siren: True
all_sirens: True
snapshot: True
doorbell_silence: True
siren_volume: 1
siren_duration: 10
siren
If True
, will create a switch for each siren device that allowsall_sirens
If True
, will create a switch for all the siren devices thatsnapshot
If True
, will create a switch for each camera to allow you todoorbell_silence
If True
, will create two switches for each doorbell, tosiren_volume
and siren_duration
controls how loud, from 1 to 10, the siren
is and how long, in seconds, it sounds.
This is now handled from the Integration Configure Pages
The following enables media player for supported devices:
media_player:
- platform: aarlo
A custom Lovelace card which is based on the picture-glance
can be found here:
https://github.com/twrecked/lovelace-hass-aarlo
The custom Lovelace card allows access to the video recordings library and presents customizable camera information on the camera feed. It was influenced by the Arlo web interface camera view.
This piece is optional, Aarlo will work with the standard Lovelace cards.
Aarlo supports 2-factor authentication.
This is now handled from the Integration Page
To check if you need to enable 2FA, log in to actual Arlo website using your Home Assistant account and see if it sends you a verification code. If it does, you will need to provide a mechanism to get this code, choose one of the following:
For IMAP 2FA Aarlo needs to access and your email account form where it reads the token Arlo sent.
aarlo:
tfa_source: imap
tfa_type: email
tfa_host: imap.host.com
tfa_username: your-user-name
tfa_password: your-imap-password
If needed, you can specify a port by appending it to the host.
aarlo:
tfa_source: imap
tfa_type: email
tfa_host: imap.host.com:1234
tfa_username: your-user-name
tfa_password: your-imap-password
For GMail and Yahoo (and other web based email client) you can't log in with your usual password, you will have to create an application specific password. Explaining why this is necessary is out of the scope of this document so see the following pages.
If you find you can't log in to your IMAP account check the application password requirement.
Once you have created the application password use it in the 2FA configuration.
For GMail
the set-up would look like this:
aarlo:
#..other config..
tfa_source: imap
tfa_type: email
tfa_host: imap.gmail.com
tfa_username: !secret gmail_username
tfa_password: !secret gmail_app_password
PUSH 2FA Arlo is used when account is set for 2FA to phone app.
aarlo:
tfa_source: push
tfa_type: PUSH
Entity ID naming follows this pattern
component-type.aarlo_lower_case_name_with_underscores
.
For example, a camera called "Front Door" will have an entity id of
camera.aarlo_front_door
.
For full compatibility Aarlo will decode Unicode characters. This means a
camera called Haustür
will be called component-type.aarlo_haustur
.
If you do not want this behaviour - and be warned, this may cause problems
using certain Home Assistant services - add no_unicode_squash: True
to your
configuration.
If you use the save_media_to
parameter to specify a file naming scheme
Aarlo will use that to save all media - videos and snapshots - locally. You
can use the following substitutions:
SN
; the device serial numberN
; the device nameY
; the year of the recording, include centurym
; the month of the year as a number (range 01 to 12)d
; the day of the month as a number (range 01 to 31)H
; the hour of the day (range 00 to 23)M
; the minute of the hour (range 00 to 59)S
; the seconds of the minute (range 00 to 59)F
; a shortcut for Y-m-d
T
; a shortcut for H:M:S
t
; a shortcut for H-M-S
s
; the number of seconds since the epochYou specify the substitution by prefixing it with a $
in the format string.
You can optionally use curly brackets to remove any ambiguity. For example,
the following configuration will save all media under /config/media
organized by serial number and then by date. The code will add the correct
file extension.
save_media_to: "/config/media/${SN}/${Y}/${m}/${d}/${T}"
The first time you configure save_media_to
the system can take several
minutes to download all the currently available media. The download is
throttled to not overload Home Assistant or Arlo. Once the initial download is
completed updates should happen a lot faster.
The code doesn't provide any management of the downloads, it will keep
downloading them until your device is full. It also doesn't provide a NAS
interface, you need to mount the NAS device and point save_media_to
at it.
You need to use the custom `aarlo-glance card. And you need to do one or both of these:
stream
to the image_click
options of the cardstream
to the image_top
or image_bottom
options of the cardStreaming works with Home Assistant and, for most people, will just work. But there are still some things to be wary of.
Arlo recently upgraded their streaming servers to support mpeg-dash
. You can
stream this directly to your browser without going through your Home Assistant
install.
One of the biggest advantages of direct streaming was audio support but that has been added to non-direct streaming in recent Home Assistant releases. Direct streaming still offloads the conversion from your Home Assistant server and reduces the bandwidth usage of your home network, this is especially true if streaming from outside your home network.
You can not stream directly to Apple devices, they don't support mpeg-dash
.
Internally the code will use non-direct streaming as needed. For example, to
save recording into the Arlo library of longer than 30 seconds the code must
open a stream to the Arlo servers, it can only do this in non-direct mode
because the stream component doesn't support mpeg-dash
.
To use it on your aarlo-glance
card you need to add direct
to the
image_view
options of the card. You can mix direct and non-direct cards on
the UI.
To get streaming working in virtualenv
you still need to make sure a couple
of libraries are installed. For ubuntu
the following works:
source your-env/bin/activate
sudo apt install libavformat-dev
sudo apt install libavdevice-dev
pip install av==6.1.2
If you are still having issues please read these 3 posts:
Snapshots can be tricky.
The initial implementation would issue a fullFrameSnapshot
request and Arlo
would return a snapshot. The problem was it wasn't very consistent, I have 2
identical cameras where snapshot will work on one and not the other. Arlo uses
this implementation to allow you to position the camera and I've seen it not
work on their web interface and app.
The next implementation would start a stream and issues a snapshot command - mimicking the camera button show on the live stream on the web interface. Again, this mostly worked but some cameras would steadfastly refuse to send back a snapshot.
The latest version adds to the previous stream version by allowing the updated thumbnail from the stream to be used as the snapshot image. This method works best but there are still some pieces of configuration you can tweak to make it better.
stream_snapshot
; set to True
to turn on stream snapshots, default False
.stream_snapshot_stop
; a positive integer, the number of seconds to stopsnapshot_checks
; an integer array, default values 1 and 5. Force Aarlo tomediaUploadNotifications
.snapshot_timeout
; a positive integer, default 60. How long to give theThis is a summary of possible sizes:
camera | user_agent | stream_snapshot | worked | size |
---|---|---|---|---|
street | linux | yes | yes | 640x352 |
street | linux | no | sometimes | |
front | linux | yes | yes | 1920x1072 |
front | linux | no | yes | |
street | apple | yes | no* | |
street | apple | no | sometimes | 1280x720 |
front | apple | yes | yes | |
front | apple | no | yes | 1920x1072 |
*And I know up until about 2 weeks ago this row was working.
street is an 1st gen Arlo (VMC3030) front is an Arlo Pro (VMC4030P)
The following user agents are available:
arlo
; the original netgear
use agent, this is the default and will getrtsps
streams from the Arlo servers.linux
; a newer Chrome
user agent, this will get mpeg-dash
streams fromapple
, ipad
, iphone
, mac
, firefox
; these simulate these devices ormpeg_dash
streams.As you can see, the user agent you supply to Arlo determines what streaming format is used. I used to think that the agent you used to log in had to be the same as the agent you use to start a stream. After some testing I find this is not the case.
What this means is Aarlo can select the best user agent for the task.
camera.record
service will use arlo
agent so Home Assistant can savemp4
.camera.play_stream
service will use arlo
agent so Home Assistant canhls
.arlo_stream_url
web service will use the linux
agent to return a URLmpeg-dash
stream.Those camera.play_stream
and arlo_stream_url
changes are important, they
allow the aarlo-glance
Lovelace card to choose direct or non-direct streams
regardless of the default user agent provided.
The default user agent is used in all other cases. This means, for example, the one you set if picked for snapshot operations.
The component uses the Arlo webapi.
arlo
componentIf you do find the component locks up after a while (I've seen reports of hours, days or weeks), you can add the following to the main configuration. Start from the top and work down:
refresh_devices_every
, tell Aarlo to request the device list every sostream_timeout
, tell Aarlo to close and reopen the event stream after areconnect_every
, tell Aarlo to logout and back in every so often. Thisrequest_timeout
, the amount of time to allow for a http request to work. AUnify your alarm mode names across all your base stations. There is no way to specify different mode names for each device.
Arlo will allow shared accounts to give cameras their own name. If you find cameras appearing with unexpected names (or not appearing at all), log into the Arlo web interface with your Home Assistant account and make sure the camera names are correct.
You can change the brightness on the light but not while it's turned on. You need to turn it off and back on again for the change to take. This is how the web interface does it.
Coming soon...
Arlo recently added Cloud Flare anti-bot protection to the Arlo website. This service doesn't work well with the Python Requests package. If you see the following errors you are running into Cloud Flare issues.
2021-06-03 13:28:32 WARNING (SyncWorker_4) [pyaarlo] request-error=CloudflareChallengeError
There are a couple of things you can try:
user_agent
and restart Home Assistant. You can even tryuser_agent
to random
if things get desperate./etc/hosts
to point to a specific Arlo web server. You can try#104.18.30.98 ocapi-app.arlo.com
#104.18.31.98 ocapi-app.arlo.com
The good news, Aarlo will now cache the authentication token so once you've logged in you should be not need to be bothered by Cloud Flare for 2 weeks.
This problem affects me, and I'm constantly trying to refine the code.
Arlo is in the middle of (or seems to be in the middle of) changing their back
end event system. The original system used a Server Side Event
socket but
they now support a MQTT
broker system.
By default, the system will use try to work out which event system to use by
looking for keywords in the Arlo server responses. If you aren't seeing the
events you expect to see then try changing to the Server Side Event
back
end. Use the backend
keyword.
aarlo:
#..your current config..
#..use either sse or mqtt for this
backend: sse
If that doesn't help then you will need to turn on logging and examine the output.
Once you have the logs look for the event you are missing at around the time
you are expecting it. The events are usually helpfully named, i.e.
motionDetected
for motion events, batteryLevel
for battery levels.
See Missing Events, they share a lot of the same issues.
And make sure you have enabled Access Rights
for your secondary account.
Arlo won't update some values for non-admin accounts.
I might ask you to provide logging, the follow paragraphs show you how. It's safe to leave these enabled, they just increase the size of the log file.
Home assistant logs everything to /config/home-assistant.log
, a typical piece of
debug from Aarlo looks like this.
2020-01-21 11:44:48 DEBUG (ArloBackgroundWorker) [pyaarlo] fast refresh
2020-01-21 11:44:48 DEBUG (ArloBackgroundWorker) [pyaarlo] day testing with 2020-01-21!
2020-01-21 11:44:50 DEBUG (ArloEventStream) [pyaarlo] async ping response subscriptions/XXXXXX-XXX-XXXXXXX_web
If you fancy poking around and trying to find out what it going wrong, dive
in, searching for ERROR
and any reference to traceBack
is a good place
to start.
You can turn this on by adding the following to your configuration.yaml
file. This provides a high level view of what is happening.
logger:
default: info
logs:
pyaarlo: debug
custom_components.aarlo: debug
custom_components.aarlo.alarm_control_panel: debug
custom_components.aarlo.binary_sensor: debug
custom_components.aarlo.camera: debug
custom_components.aarlo.light: debug
custom_components.aarlo.media_player: debug
custom_components.aarlo.sensor: debug
custom_components.aarlo.switch: debug
If, for example, you suspect the problem is just with your lights you can remove unneeded debug:
logger:
default: info
logs:
pyaarlo: debug
custom_components.aarlo: debug
custom_components.aarlo.light: debug
It sometimes helps to turn on more verbose debug, this provides more information about the program's internal states.
Follow the Basic Debug instructions and then add this to your Aarlo config.
aarlo:
# old config
verbose_debug: True
Finally, you can look at what events Arlo is sending you by turning on packet dumping.
Follow the Basic Debug instructions and then add this to your Aarlo config.
aarlo:
# old config
verbose_debug: True
packet_dump: True
The logs will now include dumps of packets sent by Arlo. The following is an example of a subscription response:
{ "status": "connected"},
{ "action": "is",
"from": "XXXXXXXXXXXXX",
"resource": "subscriptions/XXXXXX-XXX-XXXXXXX_web",
"to": "XXXXXX-XXX-XXXXXXX_web",
"transId": "web!38a29262-1ce0-4c4d-8f75-fafec2c34332"}
Another example, if Arlo detects motion you will see a packet with the following field in it:
"properties": {"motionDetected": "True"},
If you run into problems please create a bug report, include the following information in the bug report to help debugging.
If you attach any logs to the bug report it's a good idea to encrypt them before uploading them. You can do this in several ways.
You can encrypt your output on this
webpage. You can upload the file or copy
and paste it into the buffer. Press Submit
.
This page doesn't forward automatically the output to me, so you will have to copy and paste it into a file and attach it to the bug report.
If you are comfortable using the command line you can use curl
to encrypt
the logs. Attach home-assistant.log.enc
to the bug report.
If you are using a Linux environment you don't need to run this from the docker.
docker exec -it YOUR_DOCKER_NAME bash
cd /config/
cat home-assistant.log | curl -s -F 'plain_text_file=@-;filename=clear.txt' https://pyaarlo-tfa.appspot.com/encrypt > home-assistant.log.enc
exit
You can do this using the pyaarlo component. The easiest way to install it is in a virtual environment. The following steps will install Pyaarlo.
$ python3 -m venv pyaarlo
$ source pyaarlo/bin/activate
(pyaarlo) $ pip install pyaarlo
(pyaarlo) $ pyaarlo --help
To encrypt your logs save the output to a file and do the following. Attach
home-assistant.log.enc
to the bug report.
(pyaarlo)$ cat your-log-file | pyaarlo encrypt > home-assistant.log.enc
You don't need to keep re-installing pyaarlo, just re-activate the virtualenv.
$ cd where-you-where-before
$ source pyaarlo/bin/activate
(pyaarlo) $ pyaarlo --help
When you're finished with pyaarlo deactivate the virtualenv.
(pyaarlo) $ deactivate
$
Data isn't anonymized internally... I will be adding that functionality.
I don't own every piece Arlo of equipment so sometimes, when things go wrong, I need to see what Arlo actually expects this code to send and what this code can expect back from Arlo. Aarlo simulates a web browser connection so you can find out what is expected by using the browser Developer Tools.
This instructions are for Chrome but most browsers (I hope!) have similar functionality.
More Tools
Developer Tools
. You can also use the shortcutCTRL+SHIFT+I
.Network
tab in the newly opened window.When you log in the data passed between the browser and Arlo website will
start to appear, and keep appearing, in this tab. If you click on an entry
under Name
you can examine the packets in more detail.
Headers
tab shows you what was sent in the headers of the request.Payload
tabs shows you what was sent in the body of the requestPreview
tab shows the reply sent back from Arlo.If you hover over the field under name
a pop up will display the full URL the
request was sent to.
For example, Arlo creates a new device with a WOOHOO
button, I don't
posses such a device but you'd like the WOOHOO
functionality implementing in
Aarlo. What I need is the sequence of packets and their replies when you
press the button. The only real way to do this is to press the button and see
what new packets appear in the Name
tab.
You will then need to copy and paste them into a bug report on GitHub. See the previous section on how to hide sensitive data.
The following additional parameters can be specified against the aarlo platform for more granular control:
Field | Type | Default | Description |
---|---|---|---|
db_motion_time |
integer |
30 (s) |
Duration of doorbell motion. (Arlo doorbell only indicates motion is present not that it stops) |
db_ding_time |
integer |
60 (s) |
Duration of doorbell press. (Arlo doorbell only indicates doorbell was pressed, not that it was released) |
recent_time |
integer |
60 (s) |
Used to hold the cameras in a recent activity state after a recording or streaming event. (Streaming & recording can be over in a few seconds, without this the camera will revert to idle, possibly looking like nothing has happened.) |
last_format |
strftime | '%m-%d %H:%M' |
Display format of last captured time |
serial_ids |
boolean | False | Use device IDS for the entity names. BE CAREFUL, WILL RENAME ALL YOUR ENTITIES |
request_timeout |
time period | 60 |
Timeout for requests sent to Arlo server. 0 means no timeout. |
stream_timeout |
time period | 120 |
Timeout for inactivity on the Arlo event stream. 0 means no timeout. Used to help with Arlo components becoming unresponsive. |
reconnect_every |
integer |
0 (minutes) |
If not 0 then force a logout every reconect_entry time period. Used to help with Arlo components becoming unresponsive. |
refresh_devices_every |
integer |
2 (hours) |
Used to force a device refresh every x hours. 0 = no refreshing. Used to resolve issue with mode changes failing after several days of use. |
refresh_modes_every |
integer |
0 (minutes) |
Used to force a mode refresh every x minutes. 0 = no refreshing. Used to resolve issue with mode changes failing after several days of use. |
packet_dump |
boolean | False |
Causes aarlo to store all the packets it sees in /config/.aarlo/packets.dump file. Only really needed for debugging and reverse engineering the API. |
conf_dir |
string | '/config/.aarlo' |
Location to store component state. (The default is fine for hass.io, docker, and virtualenv systems - don't set this value unless asked to.) |
host |
string | https://my.arlo.com |
Sets the host aarlo will connect to |
auth_host |
string | https://ocapi-app.arlo.com |
Sets the authentication host aarlo will connect to |
backend |
string | mqtt |
Use mqtt or sse backend |
no_media_upload |
boolean | False |
Used as a workaround for Arlo issues where the camera never gets a media upload notification. (Not needed in most cases.) *Deprecated, prefer media_retry . |
media_retry |
list(ints) | 5, 15, 25 | Used as a workaround for Arlo issues where the camera never gets a media upload notification. (Not needed in most cases.) |
mode_api |
string | auto |
available options: [v1 , v2 , v3 ] You can override this by setting this option to v1 or v2 to use the old or new version exclusively. The default is auto, choose based on device |
save_updates_to |
string | '' | A directory to automatically save updated camera images to. Has format $save_updates_to/$unique_id.jpg
|
save_media_to |
string | '' | A string describing where to save new media files. This include both video and snapshots. See the "Save Media" section. |
verbose_debug |
boolean | False |
Turn on extra debug. This extra information is usually not needed! |
library_days |
integer |
27 (days) |
Change the number of days of video the component downloads from Arlo. |
injection_service |
boolean | False |
If True enable the packet injection service. |
user_agent |
string | arlo |
Tells the system which user agent to pass to Arlo. |
stream_snapshot |
boolean | False |
If True will always try to start a stream before taking a snapshot. If False will take and idle or streaming snapshot depending on the camera state. |
stream_snapshot_stop |
integer |
10 (seconds) |
How long to wait before stopping the snapshot stream, 0 means let Arlo do it. |
snapshot_checks |
list(ints) | 1 and 5 (seconds) | Force Aarlo to check for a snapshot before mediaUploadNotification appears. |
snapshot_timeout |
integer | 65 (seconds) | How long to wait before abandoning snapshot attempt |
The following camera statuses are reported:
Idle
camera is doing nothingTurned Off
user has turned the camera offRecording
camera has detected something and is recordingStreaming
camera is streaming live video to another other loginTaking Snapshot
cameras is updating the thumbnailRecently Active
camera has seen activity within the last few minutesToo Cold!
the camera is shutdown until it warms upThe component provides the following services:
Service | Parameters | Description |
---|---|---|
aarlo.camera_request_snapshot |
entity_id - name(s) of entities to use |
This requests a snapshot be taken. Camera will move from taking_snapshot state when finished |
aarlo.camera_request_snapshot_to_file |
entity_id - name(s) of entities to use filename - where to save snapshot |
This requests a snapshot be taken and written to the passed file. Camera will move from taking_snapshot state when finished |
aarlo.camera_start_recording |
entity_id - name(s) of entities to use duration - amount of time in seconds to record |
Begins video capture from the specified camera |
aarlo.camera_request_video_to_file |
entity_id - name(s) of entities to use filename - where to save video |
This requests a video be taken and written to the passed file. Camera will move from recording state when finished |
aarlo.camera_stop_activity |
entity_id - name(s) of entities to use |
This moves the camera into the idle state. Can be used to stop streaming or recording. |
aarlo.alarm_set_mode |
entity_id - name(s) of entities to use mode - custom mode to change to |
Set the alarm to a custom mode |
aarlo.siren_on |
duration - amount of time in seconds to recordvolume - how loud to set siren |
Turn a siren on. |
aarlo.sirens_on |
entity_id - name(s) of entities to use duration - amount of time in seconds to recordvolume - how loud to set siren |
Turns all sirens on. |
aarlo.siren_off |
entity_id - name(s) of entities to use |
Turns a siren off. |
aarlo.sirens_off |
Turns all sirens off. | |
aarlo.restart_device |
entity_id - name(s) of entities to reboot |
Restarts a base station. You need admin access to do this. |
aarlo.inject_response |
filename - file to read packet from |
Inject a packet into the event stream. |
For recordings longer than 30 seconds you will need to white list the /tmp
directory. This is because we have to keep a stream to Arlo open to prevent
them from stopping the recording after 30 seconds. And we write this stream to
the /tmp
directory.
For restart_device
you need to log in with the main account.
These services are deprecated and will be going away. By moving services under
the aarlo domain it allows Home Assistant to use the services.yaml
descriptions.
Service | Parameters | Description |
---|---|---|
camera.aarlo_request_snapshot |
entity_id - camera to get snapshot from |
This requests a snapshot be taken. Camera will move from taking_snapshot state when finished |
camera.aarlo_request_snapshot_to_file |
entity_id - camera to get snapshot fromfilename - where to save snapshot |
This requests a snapshot be taken and written to the passed file. Camera will move from taking_snapshot state when finished |
camera.aarlo_stop_activity |
entity_id - camera to get snapshot from |
This moves the camera into the idle state. Can be used to stop streaming |
camera.start_recording |
entity_id - camera to start recordingduration - amount of time in seconds to record |
Begins video capture from the specified camera |
camera.stop_recording |
entity_id - camera to stop recording |
Ends video capture from the specified camera |
alarm_control_panel.aarlo_set_mode |
entity_id - camera to get snapshot frommode - custom mode to change to |
Set the alarm to a custom mode |
The following events can fire:
Event | Description |
---|---|
aarlo_image_updated | The image updated |
aarlo_snapshot_updated | The image updated, and it was caused by a snapshot. |
aarlo_capture_updated | The image updated, and it was caused by an Arlo recording. |
The following events are deprecated:
Event | Description |
---|---|
aarlo_snapshot_ready | The image is updated |
The component provides the following extra web sockets:
Service | Parameters | Description |
---|---|---|
aarlo_video_url |
entity_id - camera to get details from
|
Request details of the last recorded video. Returns: url - video urlurl_type - video typethumbnail - thumbnail image urlthumbnail_type - thumbnail image type
|
aarlo_library |
at-most - return at most this number of entries
|
Request up the details of at-most recently recorded videos. Returns an array of:created_at : unix time stampcreated_at_pretty : pretty version of the create timeurl : URL of the videourl_type : video typethumbnail : URL of the thumbnailthumbnail_type : thumbnail typeobject : object in the video that triggered the captureobject_region : region in the video that triggered the capture
|
aarlo_stream_url |
entity_id - camera to get snapshot fromfilename - where to save snapshot |
Ask the camera to start streaming. Returns:url - URL of the video stream
|
aarlo_snapshot_image |
entity_id - camera to get snapshot from
|
Request a snapshot. Returns image details: content_type : the image typecontent : the image
|
aarlo_stop_activity |
entity_id - camera to stop activity on
|
Stop all the activity in the camera. Returns: stopped : True if stop request went in
|
- id: 'automation-0100'
alias: Camera Snapshot
trigger:
- entity_id: camera.aarlo_camera1,camera.aarlo_camera2
for: 00:00:03
from: 'idle'
platform: state
to: 'recording'
- entity_id: camera.aarlo_camera1,camera.aarlo_camera2
for: 00:00:03
from: 'recently active'
platform: state
to: 'recording'
condition: []
action:
- data_template:
entity_id: "{{ trigger.entity_id }}"
service: camera.aarlo_request_snapshot
- id: 'automation-0101'
alias: Record video when garage opens
description: ''
trigger:
- entity_id: cover.garage_door
platform: state
to: open
condition: []
action:
- data:
duration: 300
entity_id: camera.aarlo_garage
service: camera.aarlo_start_recording