mirror of
https://github.com/home-assistant/core.git
synced 2025-08-22 03:40:02 +00:00
.devcontainer
.github
.vscode
docs
homeassistant
auth
components
abode
acer_projector
actiontec
adguard
ads
aftership
air_quality
airly
airvisual
aladdin_connect
alarm_control_panel
alarmdecoder
alarmdotcom
alert
alexa
alpha_vantage
amazon_polly
ambiclimate
ambient_station
amcrest
ampio
android_ip_webcam
androidtv
anel_pwrctrl
anthemav
apache_kafka
apcupsd
api
apns
apple_tv
aprs
aqualogic
aquostv
arcam_fmj
arduino
arest
arlo
aruba
arwn
asterisk_cdr
asterisk_mbox
asuswrt
atome
august
aurora
aurora_abb_powerone
auth
automatic
automation
avea
avion
awair
aws
axis
azure_event_hub
baidu
bayesian
bbb_gpio
bbox
beewi_smartclim
bh1750
binary_sensor
bitcoin
bizkaibus
blackbird
blink
blinksticklight
blinkt
blockchain
bloomsky
bluesound
bluetooth_le_tracker
bluetooth_tracker
bme280
bme680
bmw_connected_drive
bom
braviatv
broadlink
brottsplatskartan
browser
brunt
bt_home_hub_5
bt_smarthub
buienradar
caldav
calendar
camera
canary
cast
cert_expiry
channels
cisco_ios
cisco_mobility_express
cisco_webex_teams
ciscospark
citybikes
clementine
clickatell
clicksend
clicksend_tts
climate
cloud
cloudflare
cmus
co2signal
coinbase
coinmarketcap
comed_hourly_pricing
comfoconnect
command_line
concord232
config
configurator
conversation
coolmaster
counter
cover
cppm_tracker
cpuspeed
crimereports
cups
currencylayer
daikin
danfoss_air
darksky
datadog
ddwrt
deconz
decora
decora_wifi
default_config
delijn
deluge
demo
denon
denonavr
deutsche_bahn
device_automation
device_sun_light_trigger
device_tracker
dht
dialogflow
digital_ocean
digitalloggers
directv
discogs
discord
discovery
dlib_face_detect
dlib_face_identify
dlink
dlna_dmr
dnsip
dominos
doods
doorbird
dovado
downloader
dsmr
dte_energy_bridge
dublin_bus_transport
duckdns
duke_energy
dunehd
dwd_weather_warnings
dweet
dyson
ebox
ebusd
ecoal_boiler
ecobee
econet
ecovacs
eddystone_temperature
edimax
ee_brightbox
efergy
egardia
eight_sleep
eliqonline
elkm1
elv
emby
emoncms
emoncms_history
emulated_hue
emulated_roku
enigma2
enocean
enphase_envoy
entur_public_transport
environment_canada
envirophat
envisalink
ephember
epson
epsonworkforce
eq3btsmart
esphome
essent
etherscan
eufy
everlights
evohome
facebook
facebox
fail2ban
familyhub
fan
fastdotcom
feedreader
ffmpeg
ffmpeg_motion
ffmpeg_noise
fibaro
fido
file
filesize
filter
fints
fitbit
__init__.py
manifest.json
sensor.py
fixer
fleetgo
flexit
flic
flock
flunearyou
flux
flux_led
folder
folder_watcher
foobot
fortigate
fortios
foscam
foursquare
free_mobile
freebox
freedns
fritz
fritzbox
fritzbox_callmonitor
fritzbox_netmonitor
fritzdect
fronius
frontend
frontier_silicon
futurenow
garadget
gc100
gearbest
geizhals
generic
generic_thermostat
geniushub
geo_json_events
geo_location
geo_rss_events
geofency
geonetnz_quakes
github
gitlab_ci
gitter
glances
gntp
goalfeed
gogogate2
google
google_assistant
google_cloud
google_domains
google_maps
google_pubsub
google_translate
google_travel_time
google_wifi
gpmdp
gpsd
gpslogger
graphite
greeneye_monitor
greenwave
group
growatt_server
gstreamer
gtfs
gtt
habitica
hangouts
harman_kardon_avr
harmony
hassio
haveibeenpwned
hddtemp
hdmi_cec
heatmiser
heos
here_travel_time
hikvision
hikvisioncam
hipchat
history
history_graph
history_stats
hitron_coda
hive
hlk_sw16
homeassistant
homekit
homekit_controller
homematic
homematicip_cloud
homeworks
honeywell
hook
horizon
hp_ilo
html5
http
htu21d
huawei_lte
huawei_router
hue
hunterdouglas_powerview
hydrawise
hydroquebec
hyperion
ialarm
iaqualink
icloud
idteck_prox
ifttt
iglo
ign_sismologia
ihc
image_processing
imap
imap_email_content
incomfort
influxdb
input_boolean
input_datetime
input_number
input_select
input_text
insteon
integration
intent_script
ios
iota
iperf3
ipma
iqvia
irish_rail_transport
islamic_prayer_times
iss
isy994
itach
itunes
izone
jewish_calendar
joaoapps_join
juicenet
kaiterra
kankun
keba
keenetic_ndms2
keyboard
keyboard_remote
kira
kiwi
knx
kodi
konnected
kwb
lacrosse
lametric
lannouncer
lastfm
launch_library
lcn
lg_netcast
lg_soundbar
life360
lifx
lifx_cloud
lifx_legacy
light
lightwave
limitlessled
linksys_smart
linky
linode
linux_battery
lirc
litejet
liveboxplaytv
llamalab_automate
local_file
locative
lock
lockitron
logbook
logentries
logger
logi_circle
london_air
london_underground
loopenergy
lovelace
luci
luftdaten
lupusec
lutron
lutron_caseta
lw12wifi
lyft
magicseaweed
mailbox
mailgun
manual
manual_mqtt
map
marytts
mastodon
matrix
maxcube
mcp23017
media_extractor
media_player
mediaroom
melissa
meraki
message_bird
met
meteo_france
meteoalarm
metoffice
mfi
mhz19
microsoft
microsoft_face
microsoft_face_detect
microsoft_face_identify
miflora
mikrotik
mill
min_max
minio
mitemp_bt
mjpeg
mobile_app
mochad
modbus
modem_callerid
mold_indicator
monoprice
moon
mopar
mpchc
mpd
mqtt
mqtt_eventstream
mqtt_json
mqtt_room
mqtt_statestream
mvglive
mychevy
mycroft
myq
mysensors
mystrom
mythicbeastsdns
n26
nad
namecheapdns
nanoleaf
neato
nederlandse_spoorwegen
nello
ness_alarm
nest
netatmo
netdata
netgear
netgear_lte
netio
neurio_energy
nextbus
nfandroidtv
niko_home_control
nilu
nissan_leaf
nmap_tracker
nmbs
no_ip
noaa_tides
norway_air
notify
notion
nsw_fuel_station
nsw_rural_fire_service_feed
nuheat
nuimo_controller
nuki
nut
nws
nx584
nzbget
oasa_telematics
obihai
octoprint
oem
ohmconnect
ombi
onboarding
onewire
onkyo
onvif
openalpr_cloud
openalpr_local
opencv
openevse
openexchangerates
opengarage
openhardwaremonitor
openhome
opensensemap
opensky
opentherm_gw
openuv
openweathermap
opple
orangepi_gpio
orvibo
osramlightify
otp
owlet
owntracks
panasonic_bluray
panasonic_viera
pandora
panel_custom
panel_iframe
pencom
persistent_notification
person
philips_js
pi_hole
picotts
piglow
pilight
ping
pioneer
pjlink
plaato
plant
plex
plugwise
plum_lightpad
pocketcasts
point
postnl
prezzibenzina
proliphix
prometheus
prowl
proximity
proxy
ps4
ptvsd
pulseaudio_loopback
push
pushbullet
pushetta
pushover
pushsafer
pvoutput
pyload
python_script
qbittorrent
qld_bushfire
qnap
qrcode
quantum_gateway
qwikswitch
rachio
radarr
radiotherm
rainbird
raincloud
rainforest_eagle
rainmachine
random
raspihats
raspyrfm
recollect_waste
recorder
recswitch
reddit
rejseplanen
remember_the_milk
remote
remote_rpi_gpio
repetier
rest
rest_command
rflink
rfxtrx
ring
ripple
rmvtransport
rocketchat
roku
roomba
route53
rova
rpi_camera
rpi_gpio
rpi_gpio_pwm
rpi_pfio
rpi_rf
rss_feed_template
rtorrent
russound_rio
russound_rnet
sabnzbd
saj
samsungtv
satel_integra
scene
scrape
script
scsgate
season
sendgrid
sense
sensehat
sensibo
sensor
serial
serial_pm
sesame
seven_segments
seventeentrack
shell_command
shiftr
shodan
shopping_list
sht31
sigfox
simplepush
simplisafe
simulated
sisyphus
sky_hub
skybeacon
skybell
slack
sleepiq
slide
sma
smappee
smarthab
smartthings
smarty
smhi
smtp
snapcast
snips
snmp
sochain
socialblade
solaredge
solaredge_local
solax
soma
somfy
somfy_mylink
sonarr
songpal
sonos
sony_projector
soundtouch
spaceapi
spc
speedtestdotnet
spider
splunk
spotcrime
spotify
sql
squeezebox
ssdp
starlingbank
startca
statistics
statsd
steam_online
stiebel_eltron
stream
streamlabswater
stride
suez_water
sun
supervisord
supla
swiss_hydrological_data
swiss_public_transport
swisscom
switch
switchbot
switcher_kis
switchmate
syncthru
synology
synology_chat
synology_srm
synologydsm
syslog
system_health
system_log
systemmonitor
tado
tahoma
tank_utility
tapsaff
tautulli
tcp
ted5000
teksavvy
telegram
telegram_bot
tellduslive
tellstick
telnet
temper
template
tensorflow
tesla
tfiac
thermoworks_smoke
thethingsnetwork
thingspeak
thinkingcleaner
thomson
threshold
tibber
tikteck
tile
time_date
timer
tod
todoist
tof
tomato
toon
torque
totalconnect
touchline
tplink
tplink_lte
traccar
trackr
tradfri
trafikverket_train
trafikverket_weatherstation
transmission
transport_nsw
travisci
trend
tts
tuya
twentemilieu
twilio
twilio_call
twilio_sms
twitch
twitter
ubee
ubus
ue_smart_radio
uk_transport
unifi
unifi_direct
universal
upc_connect
upcloud
updater
upnp
uptime
uptimerobot
uscis
usgs_earthquakes_feed
utility_meter
uvc
vacuum
vallox
vasttrafik
velbus
velux
venstar
vera
verisure
version
vesync
viaggiatreno
vicare
vivotek
vizio
vlc
vlc_telnet
voicerss
volkszaehler
volumio
volvooncall
vultr
w800rf32
wake_on_lan
waqi
water_heater
waterfurnace
watson_iot
watson_tts
waze_travel_time
weather
webhook
weblink
webostv
websocket_api
wemo
whois
wink
wirelesstag
withings
workday
worldclock
worldtidesinfo
worxlandroid
wsdot
wunderground
wunderlist
wwlln
x10
xbox_live
xeoma
xfinity
xiaomi
xiaomi_aqara
xiaomi_miio
xiaomi_tv
xmpp
xs1
yale_smart_alarm
yamaha
yamaha_musiccast
yandex_transport
yandextts
yeelight
yeelightsunflower
yessssms
yi
yr
yweather
zabbix
zamg
zengge
zeroconf
zestimate
zha
zhong_hong
zigbee
ziggo_mediabox_xl
zone
zoneminder
zwave
__init__.py
generated
helpers
scripts
util
__init__.py
__main__.py
bootstrap.py
config.py
config_entries.py
const.py
core.py
data_entry_flow.py
exceptions.py
loader.py
monkey_patch.py
package_constraints.txt
requirements.py
setup.py
script
tests
.codecov.yml
.coveragerc
.dockerignore
.gitattributes
.gitignore
.hound.yml
.ignore
.pre-commit-config.yaml
.readthedocs.yml
.travis.yml
CLA.md
CODEOWNERS
CODE_OF_CONDUCT.md
CONTRIBUTING.md
Dockerfile.dev
LICENSE.md
MANIFEST.in
README.rst
azure-pipelines-ci.yml
azure-pipelines-release.yml
azure-pipelines-translation.yml
azure-pipelines-wheels.yml
mypyrc
pylintrc
pyproject.toml
requirements_all.txt
requirements_docs.txt
requirements_test.txt
requirements_test_all.txt
setup.cfg
setup.py
tox.ini
525 lines
19 KiB
Python
525 lines
19 KiB
Python
"""Support for the Fitbit API."""
|
|
import os
|
|
import logging
|
|
import datetime
|
|
import time
|
|
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.core import callback
|
|
from homeassistant.components.http import HomeAssistantView
|
|
from homeassistant.components.sensor import PLATFORM_SCHEMA
|
|
from homeassistant.const import ATTR_ATTRIBUTION
|
|
from homeassistant.const import CONF_UNIT_SYSTEM
|
|
from homeassistant.helpers.entity import Entity
|
|
from homeassistant.helpers.icon import icon_for_battery_level
|
|
import homeassistant.helpers.config_validation as cv
|
|
from homeassistant.util.json import load_json, save_json
|
|
|
|
|
|
_CONFIGURING = {}
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
ATTR_ACCESS_TOKEN = "access_token"
|
|
ATTR_REFRESH_TOKEN = "refresh_token"
|
|
ATTR_CLIENT_ID = "client_id"
|
|
ATTR_CLIENT_SECRET = "client_secret"
|
|
ATTR_LAST_SAVED_AT = "last_saved_at"
|
|
|
|
CONF_MONITORED_RESOURCES = "monitored_resources"
|
|
CONF_CLOCK_FORMAT = "clock_format"
|
|
ATTRIBUTION = "Data provided by Fitbit.com"
|
|
|
|
FITBIT_AUTH_CALLBACK_PATH = "/api/fitbit/callback"
|
|
FITBIT_AUTH_START = "/api/fitbit"
|
|
FITBIT_CONFIG_FILE = "fitbit.conf"
|
|
FITBIT_DEFAULT_RESOURCES = ["activities/steps"]
|
|
|
|
SCAN_INTERVAL = datetime.timedelta(minutes=30)
|
|
|
|
DEFAULT_CONFIG = {"client_id": "CLIENT_ID_HERE", "client_secret": "CLIENT_SECRET_HERE"}
|
|
|
|
FITBIT_RESOURCES_LIST = {
|
|
"activities/activityCalories": ["Activity Calories", "cal", "fire"],
|
|
"activities/calories": ["Calories", "cal", "fire"],
|
|
"activities/caloriesBMR": ["Calories BMR", "cal", "fire"],
|
|
"activities/distance": ["Distance", "", "map-marker"],
|
|
"activities/elevation": ["Elevation", "", "walk"],
|
|
"activities/floors": ["Floors", "floors", "walk"],
|
|
"activities/heart": ["Resting Heart Rate", "bpm", "heart-pulse"],
|
|
"activities/minutesFairlyActive": ["Minutes Fairly Active", "minutes", "walk"],
|
|
"activities/minutesLightlyActive": ["Minutes Lightly Active", "minutes", "walk"],
|
|
"activities/minutesSedentary": [
|
|
"Minutes Sedentary",
|
|
"minutes",
|
|
"seat-recline-normal",
|
|
],
|
|
"activities/minutesVeryActive": ["Minutes Very Active", "minutes", "run"],
|
|
"activities/steps": ["Steps", "steps", "walk"],
|
|
"activities/tracker/activityCalories": ["Tracker Activity Calories", "cal", "fire"],
|
|
"activities/tracker/calories": ["Tracker Calories", "cal", "fire"],
|
|
"activities/tracker/distance": ["Tracker Distance", "", "map-marker"],
|
|
"activities/tracker/elevation": ["Tracker Elevation", "", "walk"],
|
|
"activities/tracker/floors": ["Tracker Floors", "floors", "walk"],
|
|
"activities/tracker/minutesFairlyActive": [
|
|
"Tracker Minutes Fairly Active",
|
|
"minutes",
|
|
"walk",
|
|
],
|
|
"activities/tracker/minutesLightlyActive": [
|
|
"Tracker Minutes Lightly Active",
|
|
"minutes",
|
|
"walk",
|
|
],
|
|
"activities/tracker/minutesSedentary": [
|
|
"Tracker Minutes Sedentary",
|
|
"minutes",
|
|
"seat-recline-normal",
|
|
],
|
|
"activities/tracker/minutesVeryActive": [
|
|
"Tracker Minutes Very Active",
|
|
"minutes",
|
|
"run",
|
|
],
|
|
"activities/tracker/steps": ["Tracker Steps", "steps", "walk"],
|
|
"body/bmi": ["BMI", "BMI", "human"],
|
|
"body/fat": ["Body Fat", "%", "human"],
|
|
"body/weight": ["Weight", "", "human"],
|
|
"devices/battery": ["Battery", None, None],
|
|
"sleep/awakeningsCount": ["Awakenings Count", "times awaken", "sleep"],
|
|
"sleep/efficiency": ["Sleep Efficiency", "%", "sleep"],
|
|
"sleep/minutesAfterWakeup": ["Minutes After Wakeup", "minutes", "sleep"],
|
|
"sleep/minutesAsleep": ["Sleep Minutes Asleep", "minutes", "sleep"],
|
|
"sleep/minutesAwake": ["Sleep Minutes Awake", "minutes", "sleep"],
|
|
"sleep/minutesToFallAsleep": ["Sleep Minutes to Fall Asleep", "minutes", "sleep"],
|
|
"sleep/startTime": ["Sleep Start Time", None, "clock"],
|
|
"sleep/timeInBed": ["Sleep Time in Bed", "minutes", "hotel"],
|
|
}
|
|
|
|
FITBIT_MEASUREMENTS = {
|
|
"en_US": {
|
|
"duration": "ms",
|
|
"distance": "mi",
|
|
"elevation": "ft",
|
|
"height": "in",
|
|
"weight": "lbs",
|
|
"body": "in",
|
|
"liquids": "fl. oz.",
|
|
"blood glucose": "mg/dL",
|
|
"battery": "",
|
|
},
|
|
"en_GB": {
|
|
"duration": "milliseconds",
|
|
"distance": "kilometers",
|
|
"elevation": "meters",
|
|
"height": "centimeters",
|
|
"weight": "stone",
|
|
"body": "centimeters",
|
|
"liquids": "milliliters",
|
|
"blood glucose": "mmol/L",
|
|
"battery": "",
|
|
},
|
|
"metric": {
|
|
"duration": "milliseconds",
|
|
"distance": "kilometers",
|
|
"elevation": "meters",
|
|
"height": "centimeters",
|
|
"weight": "kilograms",
|
|
"body": "centimeters",
|
|
"liquids": "milliliters",
|
|
"blood glucose": "mmol/L",
|
|
"battery": "",
|
|
},
|
|
}
|
|
|
|
BATTERY_LEVELS = {"High": 100, "Medium": 50, "Low": 20, "Empty": 0}
|
|
|
|
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
|
|
{
|
|
vol.Optional(
|
|
CONF_MONITORED_RESOURCES, default=FITBIT_DEFAULT_RESOURCES
|
|
): vol.All(cv.ensure_list, [vol.In(FITBIT_RESOURCES_LIST)]),
|
|
vol.Optional(CONF_CLOCK_FORMAT, default="24H"): vol.In(["12H", "24H"]),
|
|
vol.Optional(CONF_UNIT_SYSTEM, default="default"): vol.In(
|
|
["en_GB", "en_US", "metric", "default"]
|
|
),
|
|
}
|
|
)
|
|
|
|
|
|
def request_app_setup(hass, config, add_entities, config_path, discovery_info=None):
|
|
"""Assist user with configuring the Fitbit dev application."""
|
|
configurator = hass.components.configurator
|
|
|
|
def fitbit_configuration_callback(callback_data):
|
|
"""Handle configuration updates."""
|
|
config_path = hass.config.path(FITBIT_CONFIG_FILE)
|
|
if os.path.isfile(config_path):
|
|
config_file = load_json(config_path)
|
|
if config_file == DEFAULT_CONFIG:
|
|
error_msg = (
|
|
"You didn't correctly modify fitbit.conf",
|
|
" please try again",
|
|
)
|
|
configurator.notify_errors(_CONFIGURING["fitbit"], error_msg)
|
|
else:
|
|
setup_platform(hass, config, add_entities, discovery_info)
|
|
else:
|
|
setup_platform(hass, config, add_entities, discovery_info)
|
|
|
|
start_url = f"{hass.config.api.base_url}{FITBIT_AUTH_CALLBACK_PATH}"
|
|
|
|
description = """Please create a Fitbit developer app at
|
|
https://dev.fitbit.com/apps/new.
|
|
For the OAuth 2.0 Application Type choose Personal.
|
|
Set the Callback URL to {}.
|
|
They will provide you a Client ID and secret.
|
|
These need to be saved into the file located at: {}.
|
|
Then come back here and hit the below button.
|
|
""".format(
|
|
start_url, config_path
|
|
)
|
|
|
|
submit = "I have saved my Client ID and Client Secret into fitbit.conf."
|
|
|
|
_CONFIGURING["fitbit"] = configurator.request_config(
|
|
"Fitbit",
|
|
fitbit_configuration_callback,
|
|
description=description,
|
|
submit_caption=submit,
|
|
description_image="/static/images/config_fitbit_app.png",
|
|
)
|
|
|
|
|
|
def request_oauth_completion(hass):
|
|
"""Request user complete Fitbit OAuth2 flow."""
|
|
configurator = hass.components.configurator
|
|
if "fitbit" in _CONFIGURING:
|
|
configurator.notify_errors(
|
|
_CONFIGURING["fitbit"], "Failed to register, please try again."
|
|
)
|
|
|
|
return
|
|
|
|
def fitbit_configuration_callback(callback_data):
|
|
"""Handle configuration updates."""
|
|
|
|
start_url = f"{hass.config.api.base_url}{FITBIT_AUTH_START}"
|
|
|
|
description = f"Please authorize Fitbit by visiting {start_url}"
|
|
|
|
_CONFIGURING["fitbit"] = configurator.request_config(
|
|
"Fitbit",
|
|
fitbit_configuration_callback,
|
|
description=description,
|
|
submit_caption="I have authorized Fitbit.",
|
|
)
|
|
|
|
|
|
def setup_platform(hass, config, add_entities, discovery_info=None):
|
|
"""Set up the Fitbit sensor."""
|
|
config_path = hass.config.path(FITBIT_CONFIG_FILE)
|
|
if os.path.isfile(config_path):
|
|
config_file = load_json(config_path)
|
|
if config_file == DEFAULT_CONFIG:
|
|
request_app_setup(
|
|
hass, config, add_entities, config_path, discovery_info=None
|
|
)
|
|
return False
|
|
else:
|
|
save_json(config_path, DEFAULT_CONFIG)
|
|
request_app_setup(hass, config, add_entities, config_path, discovery_info=None)
|
|
return False
|
|
|
|
if "fitbit" in _CONFIGURING:
|
|
hass.components.configurator.request_done(_CONFIGURING.pop("fitbit"))
|
|
|
|
import fitbit
|
|
|
|
access_token = config_file.get(ATTR_ACCESS_TOKEN)
|
|
refresh_token = config_file.get(ATTR_REFRESH_TOKEN)
|
|
expires_at = config_file.get(ATTR_LAST_SAVED_AT)
|
|
if None not in (access_token, refresh_token):
|
|
authd_client = fitbit.Fitbit(
|
|
config_file.get(ATTR_CLIENT_ID),
|
|
config_file.get(ATTR_CLIENT_SECRET),
|
|
access_token=access_token,
|
|
refresh_token=refresh_token,
|
|
expires_at=expires_at,
|
|
refresh_cb=lambda x: None,
|
|
)
|
|
|
|
if int(time.time()) - expires_at > 3600:
|
|
authd_client.client.refresh_token()
|
|
|
|
unit_system = config.get(CONF_UNIT_SYSTEM)
|
|
if unit_system == "default":
|
|
authd_client.system = authd_client.user_profile_get()["user"]["locale"]
|
|
if authd_client.system != "en_GB":
|
|
if hass.config.units.is_metric:
|
|
authd_client.system = "metric"
|
|
else:
|
|
authd_client.system = "en_US"
|
|
else:
|
|
authd_client.system = unit_system
|
|
|
|
dev = []
|
|
registered_devs = authd_client.get_devices()
|
|
clock_format = config.get(CONF_CLOCK_FORMAT)
|
|
for resource in config.get(CONF_MONITORED_RESOURCES):
|
|
|
|
# monitor battery for all linked FitBit devices
|
|
if resource == "devices/battery":
|
|
for dev_extra in registered_devs:
|
|
dev.append(
|
|
FitbitSensor(
|
|
authd_client,
|
|
config_path,
|
|
resource,
|
|
hass.config.units.is_metric,
|
|
clock_format,
|
|
dev_extra,
|
|
)
|
|
)
|
|
else:
|
|
dev.append(
|
|
FitbitSensor(
|
|
authd_client,
|
|
config_path,
|
|
resource,
|
|
hass.config.units.is_metric,
|
|
clock_format,
|
|
)
|
|
)
|
|
add_entities(dev, True)
|
|
|
|
else:
|
|
oauth = fitbit.api.FitbitOauth2Client(
|
|
config_file.get(ATTR_CLIENT_ID), config_file.get(ATTR_CLIENT_SECRET)
|
|
)
|
|
|
|
redirect_uri = "{}{}".format(
|
|
hass.config.api.base_url, FITBIT_AUTH_CALLBACK_PATH
|
|
)
|
|
|
|
fitbit_auth_start_url, _ = oauth.authorize_token_url(
|
|
redirect_uri=redirect_uri,
|
|
scope=[
|
|
"activity",
|
|
"heartrate",
|
|
"nutrition",
|
|
"profile",
|
|
"settings",
|
|
"sleep",
|
|
"weight",
|
|
],
|
|
)
|
|
|
|
hass.http.register_redirect(FITBIT_AUTH_START, fitbit_auth_start_url)
|
|
hass.http.register_view(FitbitAuthCallbackView(config, add_entities, oauth))
|
|
|
|
request_oauth_completion(hass)
|
|
|
|
|
|
class FitbitAuthCallbackView(HomeAssistantView):
|
|
"""Handle OAuth finish callback requests."""
|
|
|
|
requires_auth = False
|
|
url = FITBIT_AUTH_CALLBACK_PATH
|
|
name = "api:fitbit:callback"
|
|
|
|
def __init__(self, config, add_entities, oauth):
|
|
"""Initialize the OAuth callback view."""
|
|
self.config = config
|
|
self.add_entities = add_entities
|
|
self.oauth = oauth
|
|
|
|
@callback
|
|
def get(self, request):
|
|
"""Finish OAuth callback request."""
|
|
from oauthlib.oauth2.rfc6749.errors import MismatchingStateError
|
|
from oauthlib.oauth2.rfc6749.errors import MissingTokenError
|
|
|
|
hass = request.app["hass"]
|
|
data = request.query
|
|
|
|
response_message = """Fitbit has been successfully authorized!
|
|
You can close this window now!"""
|
|
|
|
result = None
|
|
if data.get("code") is not None:
|
|
redirect_uri = "{}{}".format(
|
|
hass.config.api.base_url, FITBIT_AUTH_CALLBACK_PATH
|
|
)
|
|
|
|
try:
|
|
result = self.oauth.fetch_access_token(data.get("code"), redirect_uri)
|
|
except MissingTokenError as error:
|
|
_LOGGER.error("Missing token: %s", error)
|
|
response_message = """Something went wrong when
|
|
attempting authenticating with Fitbit. The error
|
|
encountered was {}. Please try again!""".format(
|
|
error
|
|
)
|
|
except MismatchingStateError as error:
|
|
_LOGGER.error("Mismatched state, CSRF error: %s", error)
|
|
response_message = """Something went wrong when
|
|
attempting authenticating with Fitbit. The error
|
|
encountered was {}. Please try again!""".format(
|
|
error
|
|
)
|
|
else:
|
|
_LOGGER.error("Unknown error when authing")
|
|
response_message = """Something went wrong when
|
|
attempting authenticating with Fitbit.
|
|
An unknown error occurred. Please try again!
|
|
"""
|
|
|
|
if result is None:
|
|
_LOGGER.error("Unknown error when authing")
|
|
response_message = """Something went wrong when
|
|
attempting authenticating with Fitbit.
|
|
An unknown error occurred. Please try again!
|
|
"""
|
|
|
|
html_response = """<html><head><title>Fitbit Auth</title></head>
|
|
<body><h1>{}</h1></body></html>""".format(
|
|
response_message
|
|
)
|
|
|
|
if result:
|
|
config_contents = {
|
|
ATTR_ACCESS_TOKEN: result.get("access_token"),
|
|
ATTR_REFRESH_TOKEN: result.get("refresh_token"),
|
|
ATTR_CLIENT_ID: self.oauth.client_id,
|
|
ATTR_CLIENT_SECRET: self.oauth.client_secret,
|
|
ATTR_LAST_SAVED_AT: int(time.time()),
|
|
}
|
|
save_json(hass.config.path(FITBIT_CONFIG_FILE), config_contents)
|
|
|
|
hass.async_add_job(setup_platform, hass, self.config, self.add_entities)
|
|
|
|
return html_response
|
|
|
|
|
|
class FitbitSensor(Entity):
|
|
"""Implementation of a Fitbit sensor."""
|
|
|
|
def __init__(
|
|
self, client, config_path, resource_type, is_metric, clock_format, extra=None
|
|
):
|
|
"""Initialize the Fitbit sensor."""
|
|
self.client = client
|
|
self.config_path = config_path
|
|
self.resource_type = resource_type
|
|
self.is_metric = is_metric
|
|
self.clock_format = clock_format
|
|
self.extra = extra
|
|
self._name = FITBIT_RESOURCES_LIST[self.resource_type][0]
|
|
if self.extra:
|
|
self._name = "{0} Battery".format(self.extra.get("deviceVersion"))
|
|
unit_type = FITBIT_RESOURCES_LIST[self.resource_type][1]
|
|
if unit_type == "":
|
|
split_resource = self.resource_type.split("/")
|
|
try:
|
|
measurement_system = FITBIT_MEASUREMENTS[self.client.system]
|
|
except KeyError:
|
|
if self.is_metric:
|
|
measurement_system = FITBIT_MEASUREMENTS["metric"]
|
|
else:
|
|
measurement_system = FITBIT_MEASUREMENTS["en_US"]
|
|
unit_type = measurement_system[split_resource[-1]]
|
|
self._unit_of_measurement = unit_type
|
|
self._state = 0
|
|
|
|
@property
|
|
def name(self):
|
|
"""Return the name of the sensor."""
|
|
return self._name
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the sensor."""
|
|
return self._state
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
"""Return the unit of measurement of this entity, if any."""
|
|
return self._unit_of_measurement
|
|
|
|
@property
|
|
def icon(self):
|
|
"""Icon to use in the frontend, if any."""
|
|
if self.resource_type == "devices/battery" and self.extra:
|
|
battery_level = BATTERY_LEVELS[self.extra.get("battery")]
|
|
return icon_for_battery_level(battery_level=battery_level, charging=None)
|
|
return "mdi:{}".format(FITBIT_RESOURCES_LIST[self.resource_type][2])
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the state attributes."""
|
|
attrs = {}
|
|
|
|
attrs[ATTR_ATTRIBUTION] = ATTRIBUTION
|
|
|
|
if self.extra:
|
|
attrs["model"] = self.extra.get("deviceVersion")
|
|
attrs["type"] = self.extra.get("type").lower()
|
|
|
|
return attrs
|
|
|
|
def update(self):
|
|
"""Get the latest data from the Fitbit API and update the states."""
|
|
if self.resource_type == "devices/battery" and self.extra:
|
|
self._state = self.extra.get("battery")
|
|
else:
|
|
container = self.resource_type.replace("/", "-")
|
|
response = self.client.time_series(self.resource_type, period="7d")
|
|
raw_state = response[container][-1].get("value")
|
|
if self.resource_type == "activities/distance":
|
|
self._state = format(float(raw_state), ".2f")
|
|
elif self.resource_type == "activities/tracker/distance":
|
|
self._state = format(float(raw_state), ".2f")
|
|
elif self.resource_type == "body/bmi":
|
|
self._state = format(float(raw_state), ".1f")
|
|
elif self.resource_type == "body/fat":
|
|
self._state = format(float(raw_state), ".1f")
|
|
elif self.resource_type == "body/weight":
|
|
self._state = format(float(raw_state), ".1f")
|
|
elif self.resource_type == "sleep/startTime":
|
|
if raw_state == "":
|
|
self._state = "-"
|
|
elif self.clock_format == "12H":
|
|
hours, minutes = raw_state.split(":")
|
|
hours, minutes = int(hours), int(minutes)
|
|
setting = "AM"
|
|
if hours > 12:
|
|
setting = "PM"
|
|
hours -= 12
|
|
elif hours == 0:
|
|
hours = 12
|
|
self._state = f"{hours}:{minutes:02d} {setting}"
|
|
else:
|
|
self._state = raw_state
|
|
else:
|
|
if self.is_metric:
|
|
self._state = raw_state
|
|
else:
|
|
try:
|
|
self._state = "{0:,}".format(int(raw_state))
|
|
except TypeError:
|
|
self._state = raw_state
|
|
|
|
if self.resource_type == "activities/heart":
|
|
self._state = response[container][-1].get("value").get("restingHeartRate")
|
|
|
|
token = self.client.client.session.token
|
|
config_contents = {
|
|
ATTR_ACCESS_TOKEN: token.get("access_token"),
|
|
ATTR_REFRESH_TOKEN: token.get("refresh_token"),
|
|
ATTR_CLIENT_ID: self.client.client.client_id,
|
|
ATTR_CLIENT_SECRET: self.client.client.client_secret,
|
|
ATTR_LAST_SAVED_AT: int(time.time()),
|
|
}
|
|
save_json(self.config_path, config_contents)
|