196 lines
6.4 KiB
Python
196 lines
6.4 KiB
Python
"""Support for deCONZ devices."""
|
|
import voluptuous as vol
|
|
|
|
from homeassistant import config_entries
|
|
from homeassistant.const import (
|
|
CONF_API_KEY, CONF_HOST, CONF_PORT, EVENT_HOMEASSISTANT_STOP)
|
|
from homeassistant.core import callback
|
|
from homeassistant.helpers import config_validation as cv
|
|
|
|
# Loading the config flow file will register the flow
|
|
from .config_flow import get_master_gateway
|
|
from .const import (
|
|
CONF_ALLOW_CLIP_SENSOR, CONF_ALLOW_DECONZ_GROUPS, CONF_BRIDGEID,
|
|
CONF_MASTER_GATEWAY, DEFAULT_PORT, DOMAIN, _LOGGER)
|
|
from .gateway import DeconzGateway
|
|
|
|
REQUIREMENTS = ['pydeconz==54']
|
|
|
|
CONFIG_SCHEMA = vol.Schema({
|
|
DOMAIN: vol.Schema({
|
|
vol.Optional(CONF_API_KEY): cv.string,
|
|
vol.Optional(CONF_HOST): cv.string,
|
|
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
|
|
})
|
|
}, extra=vol.ALLOW_EXTRA)
|
|
|
|
SERVICE_DECONZ = 'configure'
|
|
|
|
SERVICE_FIELD = 'field'
|
|
SERVICE_ENTITY = 'entity'
|
|
SERVICE_DATA = 'data'
|
|
|
|
SERVICE_SCHEMA = vol.All(vol.Schema({
|
|
vol.Optional(SERVICE_ENTITY): cv.entity_id,
|
|
vol.Optional(SERVICE_FIELD): cv.matches_regex('/.*'),
|
|
vol.Required(SERVICE_DATA): dict,
|
|
vol.Optional(CONF_BRIDGEID): str
|
|
}), cv.has_at_least_one_key(SERVICE_ENTITY, SERVICE_FIELD))
|
|
|
|
SERVICE_DEVICE_REFRESH = 'device_refresh'
|
|
|
|
SERVICE_DEVICE_REFRESCH_SCHEMA = vol.All(vol.Schema({
|
|
vol.Optional(CONF_BRIDGEID): str
|
|
}))
|
|
|
|
|
|
async def async_setup(hass, config):
|
|
"""Load configuration for deCONZ component.
|
|
|
|
Discovery has loaded the component if DOMAIN is not present in config.
|
|
"""
|
|
if not hass.config_entries.async_entries(DOMAIN) and DOMAIN in config:
|
|
deconz_config = config[DOMAIN]
|
|
hass.async_add_job(hass.config_entries.flow.async_init(
|
|
DOMAIN, context={'source': config_entries.SOURCE_IMPORT},
|
|
data=deconz_config
|
|
))
|
|
return True
|
|
|
|
|
|
async def async_setup_entry(hass, config_entry):
|
|
"""Set up a deCONZ bridge for a config entry.
|
|
|
|
Load config, group, light and sensor data for server information.
|
|
Start websocket for push notification of state changes from deCONZ.
|
|
"""
|
|
if DOMAIN not in hass.data:
|
|
hass.data[DOMAIN] = {}
|
|
|
|
if not config_entry.options:
|
|
await async_populate_options(hass, config_entry)
|
|
|
|
gateway = DeconzGateway(hass, config_entry)
|
|
|
|
if not await gateway.async_setup():
|
|
return False
|
|
|
|
hass.data[DOMAIN][gateway.bridgeid] = gateway
|
|
|
|
await gateway.async_update_device_registry()
|
|
|
|
async def async_configure(call):
|
|
"""Set attribute of device in deCONZ.
|
|
|
|
Entity is used to resolve to a device path (e.g. '/lights/1').
|
|
Field is a string representing either a full path
|
|
(e.g. '/lights/1/state') when entity is not specified, or a
|
|
subpath (e.g. '/state') when used together with entity.
|
|
Data is a json object with what data you want to alter
|
|
e.g. data={'on': true}.
|
|
{
|
|
"field": "/lights/1/state",
|
|
"data": {"on": true}
|
|
}
|
|
See Dresden Elektroniks REST API documentation for details:
|
|
http://dresden-elektronik.github.io/deconz-rest-doc/rest/
|
|
"""
|
|
field = call.data.get(SERVICE_FIELD, '')
|
|
entity_id = call.data.get(SERVICE_ENTITY)
|
|
data = call.data[SERVICE_DATA]
|
|
|
|
gateway = get_master_gateway(hass)
|
|
if CONF_BRIDGEID in call.data:
|
|
gateway = hass.data[DOMAIN][call.data[CONF_BRIDGEID]]
|
|
|
|
if entity_id:
|
|
try:
|
|
field = gateway.deconz_ids[entity_id] + field
|
|
except KeyError:
|
|
_LOGGER.error('Could not find the entity %s', entity_id)
|
|
return
|
|
|
|
await gateway.api.async_put_state(field, data)
|
|
|
|
hass.services.async_register(
|
|
DOMAIN, SERVICE_DECONZ, async_configure, schema=SERVICE_SCHEMA)
|
|
|
|
async def async_refresh_devices(call):
|
|
"""Refresh available devices from deCONZ."""
|
|
gateway = get_master_gateway(hass)
|
|
if CONF_BRIDGEID in call.data:
|
|
gateway = hass.data[DOMAIN][call.data[CONF_BRIDGEID]]
|
|
|
|
groups = set(gateway.api.groups.keys())
|
|
lights = set(gateway.api.lights.keys())
|
|
scenes = set(gateway.api.scenes.keys())
|
|
sensors = set(gateway.api.sensors.keys())
|
|
|
|
await gateway.api.async_load_parameters()
|
|
|
|
gateway.async_add_device_callback(
|
|
'group', [group
|
|
for group_id, group in gateway.api.groups.items()
|
|
if group_id not in groups]
|
|
)
|
|
|
|
gateway.async_add_device_callback(
|
|
'light', [light
|
|
for light_id, light in gateway.api.lights.items()
|
|
if light_id not in lights]
|
|
)
|
|
|
|
gateway.async_add_device_callback(
|
|
'scene', [scene
|
|
for scene_id, scene in gateway.api.scenes.items()
|
|
if scene_id not in scenes]
|
|
)
|
|
|
|
gateway.async_add_device_callback(
|
|
'sensor', [sensor
|
|
for sensor_id, sensor in gateway.api.sensors.items()
|
|
if sensor_id not in sensors]
|
|
)
|
|
|
|
hass.services.async_register(
|
|
DOMAIN, SERVICE_DEVICE_REFRESH, async_refresh_devices,
|
|
schema=SERVICE_DEVICE_REFRESCH_SCHEMA)
|
|
|
|
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, gateway.shutdown)
|
|
return True
|
|
|
|
|
|
async def async_unload_entry(hass, config_entry):
|
|
"""Unload deCONZ config entry."""
|
|
gateway = hass.data[DOMAIN].pop(config_entry.data[CONF_BRIDGEID])
|
|
|
|
if not hass.data[DOMAIN]:
|
|
hass.services.async_remove(DOMAIN, SERVICE_DECONZ)
|
|
hass.services.async_remove(DOMAIN, SERVICE_DEVICE_REFRESH)
|
|
elif gateway.master:
|
|
await async_populate_options(hass, config_entry)
|
|
new_master_gateway = next(iter(hass.data[DOMAIN].values()))
|
|
await async_populate_options(hass, new_master_gateway.config_entry)
|
|
|
|
return await gateway.async_reset()
|
|
|
|
|
|
@callback
|
|
async def async_populate_options(hass, config_entry):
|
|
"""Populate default options for gateway.
|
|
|
|
Called by setup_entry and unload_entry.
|
|
Makes sure there is always one master available.
|
|
"""
|
|
master = not get_master_gateway(hass)
|
|
|
|
options = {
|
|
CONF_MASTER_GATEWAY: master,
|
|
CONF_ALLOW_CLIP_SENSOR: config_entry.data.get(
|
|
CONF_ALLOW_CLIP_SENSOR, False),
|
|
CONF_ALLOW_DECONZ_GROUPS: config_entry.data.get(
|
|
CONF_ALLOW_DECONZ_GROUPS, True)
|
|
}
|
|
|
|
hass.config_entries.async_update_entry(config_entry, options=options)
|