async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
"""Set up the Epson media player platform."""
if DATA_EPSON not in hass.data:
hass.data[DATA_EPSON] = []
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
epson = EpsonProjector(async_get_clientsession(hass, verify_ssl=False),
name, host,
config.get(CONF_PORT), config.get(CONF_SSL))
hass.data[DATA_EPSON].append(epson)
async_add_devices([epson], update_before_add=True)
async def async_service_handler(service):
"""Handle for services."""
entity_ids = service.data.get(ATTR_ENTITY_ID)
if entity_ids:
devices = [device for device in hass.data[DATA_EPSON]
if device.entity_id in entity_ids]
else:
devices = hass.data[DATA_EPSON]
for device in devices:
if service.service == SERVICE_SELECT_CMODE:
cmode = service.data.get(ATTR_CMODE)
await device.select_cmode(cmode)
await device.update()
from epson_projector.const import (CMODE_LIST_SET)
epson_schema = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_CMODE): vol.All(cv.string, vol.Any(*CMODE_LIST_SET))
})
hass.services.async_register(
DOMAIN, SERVICE_SELECT_CMODE, async_service_handler,
schema=epson_schema)
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the Epson media player platform."""
from epson_projector.const import (CMODE_LIST_SET)
if DATA_EPSON not in hass.data:
hass.data[DATA_EPSON] = []
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)
ssl = config.get(CONF_SSL)
epson = EpsonProjector(async_get_clientsession(hass, verify_ssl=False),
name, host, port, ssl)
hass.data[DATA_EPSON].append(epson)
async_add_entities([epson], update_before_add=True)
async def async_service_handler(service):
"""Handle for services."""
entity_ids = service.data.get(ATTR_ENTITY_ID)
if entity_ids:
devices = [
device for device in hass.data[DATA_EPSON]
if device.entity_id in entity_ids
]
else:
devices = hass.data[DATA_EPSON]
for device in devices:
if service.service == SERVICE_SELECT_CMODE:
cmode = service.data.get(ATTR_CMODE)
await device.select_cmode(cmode)
device.async_schedule_update_ha_state(True)
epson_schema = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_CMODE):
vol.All(cv.string, vol.Any(*CMODE_LIST_SET))
})
hass.services.async_register(DOMAIN,
SERVICE_SELECT_CMODE,
async_service_handler,
schema=epson_schema)
})
SERVICE_ADD_MEDIA = 'kodi_add_to_playlist'
SERVICE_CALL_METHOD = 'kodi_call_method'
DATA_KODI = 'kodi'
ATTR_MEDIA_TYPE = 'media_type'
ATTR_MEDIA_NAME = 'media_name'
ATTR_MEDIA_ARTIST_NAME = 'artist_name'
ATTR_MEDIA_ID = 'media_id'
ATTR_METHOD = 'method'
MEDIA_PLAYER_ADD_MEDIA_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_MEDIA_TYPE): cv.string,
vol.Optional(ATTR_MEDIA_ID): cv.string,
vol.Optional(ATTR_MEDIA_NAME): cv.string,
vol.Optional(ATTR_MEDIA_ARTIST_NAME): cv.string,
})
MEDIA_PLAYER_CALL_METHOD_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_METHOD): cv.string,
}, extra=vol.ALLOW_EXTRA)
SERVICE_TO_METHOD = {
SERVICE_ADD_MEDIA: {
'method': 'async_add_media_to_playlist',
'schema': MEDIA_PLAYER_ADD_MEDIA_SCHEMA},
SERVICE_CALL_METHOD: {
'method': 'async_call_method',
'schema': MEDIA_PLAYER_CALL_METHOD_SCHEMA},
}
SUPPORT_SELECT_SOURCE)
_CONFIGURING = {}
_LOGGER = logging.getLogger(__name__)
REQUIREMENTS = ['beautifulsoup4==4.6.0']
MIN_TIME_BETWEEN_SCANS = timedelta(seconds=15)
MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
ALEXA_DATA = "alexa_media"
SERVICE_ALEXA_TTS = 'alexa_tts'
ATTR_MESSAGE = 'message'
ALEXA_TTS_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_MESSAGE): cv.string,
})
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_EMAIL): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Required(CONF_URL): cv.string,
})
def request_configuration(hass, config, setup_platform_callback,
captcha_url=None):
"""Request configuration steps from the user."""
configurator = hass.components.configurator
async def configuration_callback(callback_data):
SERVICE_ADD_MEDIA = 'kodi_add_to_playlist'
SERVICE_CALL_METHOD = 'kodi_call_method'
DATA_KODI = 'kodi'
ATTR_MEDIA_TYPE = 'media_type'
ATTR_MEDIA_NAME = 'media_name'
ATTR_MEDIA_ARTIST_NAME = 'artist_name'
ATTR_MEDIA_ID = 'media_id'
ATTR_METHOD = 'method'
MEDIA_PLAYER_ADD_MEDIA_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_MEDIA_TYPE):
cv.string,
vol.Optional(ATTR_MEDIA_ID):
cv.string,
vol.Optional(ATTR_MEDIA_NAME):
cv.string,
vol.Optional(ATTR_MEDIA_ARTIST_NAME):
cv.string,
})
MEDIA_PLAYER_CALL_METHOD_SCHEMA = MEDIA_PLAYER_SCHEMA.extend(
{
vol.Required(ATTR_METHOD): cv.string,
}, extra=vol.ALLOW_EXTRA)
SERVICE_TO_METHOD = {
SERVICE_ADD_MEDIA: {
'method': 'async_add_media_to_playlist',
'schema': MEDIA_PLAYER_ADD_MEDIA_SCHEMA
},
SERVICE_CALL_METHOD: {
vol.Optional(CONF_SOURCE_NAMES, default={}): {
cv.string: cv.string
},
vol.Optional(CONF_ZONE_NAMES, default={}): {
cv.string: cv.string
},
})
SERVICE_ENABLE_OUTPUT = 'yamaha_enable_output'
ATTR_PORT = 'port'
ATTR_ENABLED = 'enabled'
ENABLE_OUTPUT_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_PORT):
cv.string,
vol.Required(ATTR_ENABLED):
cv.boolean
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Yamaha platform."""
import rxv
# Keep track of configured receivers so that we don't end up
# discovering a receiver dynamically that we have static config
# for. Map each device from its unique_id to an instance since
# YamahaDevice is not hashable (thus not possible to add to a set).
if hass.data.get(DATA_YAMAHA) is None:
hass.data[DATA_YAMAHA] = {}
name = config.get(CONF_NAME)
vol.Optional(CONF_PASSWORD): cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
vol.Optional(CONF_USERNAME): cv.string,
})
SERVICE_CALL_METHOD = 'squeezebox_call_method'
DATA_SQUEEZEBOX = 'squeezebox'
KNOWN_SERVERS = 'squeezebox_known_servers'
ATTR_PARAMETERS = 'parameters'
SQUEEZEBOX_CALL_METHOD_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_COMMAND): cv.string,
vol.Optional(ATTR_PARAMETERS):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string]),
})
SERVICE_TO_METHOD = {
SERVICE_CALL_METHOD: {
'method': 'async_call_method',
'schema': SQUEEZEBOX_CALL_METHOD_SCHEMA},
}
@asyncio.coroutine
def async_setup_platform(hass, config, async_add_entities,
discovery_info=None):
"""Set up the squeezebox platform."""
import socket
_LOGGER = logging.getLogger(__name__)
REQUIREMENTS = ['beautifulsoup4==4.6.0', 'simplejson==3.16.0']
MIN_TIME_BETWEEN_SCANS = timedelta(seconds=15)
MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
ALEXA_DATA = "alexa_media"
SERVICE_ALEXA_TTS = 'alexa_tts'
SERVICE_ALEXA_SEQUENCE = 'alexa_sequence'
SERVICE_ALEXA_ROUTINE = 'alexa_routine'
ATTR_MESSAGE = 'message'
ALEXA_TTS_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_MESSAGE): cv.string,
})
ATTR_SEQUENCE = 'sequence'
ALEXA_SEQUENCE_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_SEQUENCE): cv.string,
})
ATTR_ROUTINE = 'routine'
ALEXA_ROUTINE_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ROUTINE): cv.string,
})
CONF_DEBUG = 'debug'
CONF_INCLUDE_DEVICES = 'include_devices'
CONF_EXCLUDE_DEVICES = 'exclude_devices'
REQUIREMENTS = ['eyeD3==0.8.7']
REQUIREMENTS = ['uPnPClient==0.0.8']
REQUIREMENTS = ['validators==0.12.3']
_LOGGER = logging.getLogger(__name__)
ATTR_MASTER = 'master_id'
ATTR_PRESET = 'preset'
ATTR_SLAVES = 'slave_ids'
CONF_LASTFM_API_KEY = 'lastfm_api_key'
DATA_LINKPLAY = 'linkplay'
DEFAULT_NAME = 'LinkPlay device'
LASTFM_API_BASE = "http://ws.audioscrobbler.com/2.0/?method="
LINKPLAY_CONNECT_MULTIROOM_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ENTITY_ID): cv.entity_id,
vol.Required(ATTR_MASTER): cv.entity_id
})
LINKPLAY_PRESET_BUTTON_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_PRESET): cv.positive_int
})
LINKPLAY_REMOVE_SLAVES_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ENTITY_ID): cv.entity_id,
vol.Required(ATTR_SLAVES): cv.entity_ids
})
MAX_VOL = 100
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_NAME): cv.string,
vol.Optional(CONF_HOST): cv.string,
vol.Optional(CONF_SOURCE_IGNORE, default=[]):
vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_ZONE_IGNORE, default=[]):
vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_SOURCE_NAMES, default={}): {cv.string: cv.string},
vol.Optional(CONF_ZONE_NAMES, default={}): {cv.string: cv.string},
})
SERVICE_ENABLE_OUTPUT = 'yamaha_enable_output'
ATTR_PORT = 'port'
ATTR_ENABLED = 'enabled'
ENABLE_OUTPUT_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_PORT): cv.string,
vol.Required(ATTR_ENABLED): cv.boolean
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Yamaha platform."""
import rxv
# Keep track of configured receivers so that we don't end up
# discovering a receiver dynamically that we have static config
# for. Map each device from its unique_id to an instance since
# YamahaDevice is not hashable (thus not possible to add to a set).
if hass.data.get(DATA_YAMAHA) is None:
hass.data[DATA_YAMAHA] = {}
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT):
cv.port,
vol.Optional(CONF_DISABLED_SOURCES): [cv.string],
vol.Optional(CONF_LAST_RADIO_STATION):
cv.string,
vol.Optional(CONF_RADIO_STATIONS): {
cv.string: cv.string
},
})
ACCEPTED_SPEAKER_VALUES = ['A', 'B', 'A+B']
pioneer_speaker_schema = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ENTITY_ID):
cv.entity_ids,
vol.Required(ATTR_SPEAKER):
vol.In(ACCEPTED_SPEAKER_VALUES)
})
pioneer_radio_station_schema = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ENTITY_ID):
cv.entity_ids,
vol.Required(ATTR_STATION):
cv.string
})
pioneer_dim_display_schema = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_ENTITY_ID):
cv.entity_ids,
vol.Required(ATTR_DIM_DISPLAY):
vol.In([0, 1, 2, 3])
vol.Required(CONF_NAME): cv.string,
})
SOURCE_SCHEMA = vol.Schema({
vol.Required(CONF_NAME): cv.string,
})
CONF_ZONES = 'zones'
CONF_SOURCES = 'sources'
DATA_BLACKBIRD = 'blackbird'
SERVICE_SETALLZONES = 'blackbird_set_all_zones'
ATTR_SOURCE = 'source'
BLACKBIRD_SETALLZONES_SCHEMA = MEDIA_PLAYER_SCHEMA.extend(
{vol.Required(ATTR_SOURCE): cv.string})
# Valid zone ids: 1-8
ZONE_IDS = vol.All(vol.Coerce(int), vol.Range(min=1, max=8))
# Valid source ids: 1-8
SOURCE_IDS = vol.All(vol.Coerce(int), vol.Range(min=1, max=8))
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_PORT, CONF_HOST),
PLATFORM_SCHEMA.extend({
vol.Exclusive(CONF_PORT, CONF_TYPE):
cv.string,
vol.Exclusive(CONF_HOST, CONF_TYPE):
cv.string,
vol.Required(CONF_ZONES):
vol.Inclusive(CONF_USERNAME, 'auth'): cv.string,
vol.Inclusive(CONF_PASSWORD, 'auth'): cv.string,
vol.Optional(CONF_ENABLE_WEBSOCKET, default=DEFAULT_ENABLE_WEBSOCKET):
cv.boolean,
})
SERVICE_ADD_MEDIA = 'kodi_add_to_playlist'
SERVICE_SET_SHUFFLE = 'kodi_set_shuffle'
ATTR_MEDIA_TYPE = 'media_type'
ATTR_MEDIA_NAME = 'media_name'
ATTR_MEDIA_ARTIST_NAME = 'artist_name'
ATTR_MEDIA_ID = 'media_id'
MEDIA_PLAYER_SET_SHUFFLE_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required('shuffle_on'): cv.boolean,
})
MEDIA_PLAYER_ADD_MEDIA_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_MEDIA_TYPE): cv.string,
vol.Optional(ATTR_MEDIA_ID): cv.string,
vol.Optional(ATTR_MEDIA_NAME): cv.string,
vol.Optional(ATTR_MEDIA_ARTIST_NAME): cv.string,
})
SERVICE_TO_METHOD = {
SERVICE_ADD_MEDIA: {
'method': 'async_add_media_to_playlist',
'schema': MEDIA_PLAYER_ADD_MEDIA_SCHEMA},
SERVICE_SET_SHUFFLE: {
'method': 'async_set_shuffle',
cv.port,
vol.Optional(CONF_USERNAME):
cv.string,
})
SERVICE_CALL_METHOD = 'squeezebox_call_method'
DATA_SQUEEZEBOX = 'squeezebox'
KNOWN_SERVERS = 'squeezebox_known_servers'
ATTR_PARAMETERS = 'parameters'
SQUEEZEBOX_CALL_METHOD_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_COMMAND):
cv.string,
vol.Optional(ATTR_PARAMETERS):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string]),
})
SERVICE_TO_METHOD = {
SERVICE_CALL_METHOD: {
'method': 'async_call_method',
'schema': SQUEEZEBOX_CALL_METHOD_SCHEMA
},
}
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
})
SOURCE_SCHEMA = vol.Schema({
vol.Required(CONF_NAME): cv.string,
})
CONF_ZONES = 'zones'
CONF_SOURCES = 'sources'
DATA_BLACKBIRD = 'blackbird'
SERVICE_SETALLZONES = 'blackbird_set_all_zones'
ATTR_SOURCE = 'source'
BLACKBIRD_SETALLZONES_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_SOURCE): cv.string
})
# Valid zone ids: 1-8
ZONE_IDS = vol.All(vol.Coerce(int), vol.Range(min=1, max=8))
# Valid source ids: 1-8
SOURCE_IDS = vol.All(vol.Coerce(int), vol.Range(min=1, max=8))
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_PORT, CONF_HOST),
PLATFORM_SCHEMA.extend({
vol.Exclusive(CONF_PORT, CONF_TYPE): cv.string,
vol.Exclusive(CONF_HOST, CONF_TYPE): cv.string,
vol.Required(CONF_ZONES): vol.Schema({ZONE_IDS: ZONE_SCHEMA}),
SERVICE_SEARCH = DATA_VIRGINTIVO + '_search'
SERVICE_SUBTITLES_OFF = DATA_VIRGINTIVO + '_subtitles_off'
SERVICE_SUBTITLES_ON = DATA_VIRGINTIVO + '_subtitles_on'
SERVICE_TELEPORT = DATA_VIRGINTIVO + '_teleport'
ATTR_REPEATS = 'repeats'
# Valid tivo ids: 1-9
TIVO_IDS = vol.All(vol.Coerce(int), vol.Range(min=1, max=9))
# Valid channel ids: 1-999
CHANNEL_IDS = vol.All(vol.Coerce(int), vol.Range(min=1, max=999))
TIVO_SERVICE_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Optional(ATTR_ENTITY_ID):
cv.entity_id,
vol.Optional(ATTR_COMMAND):
cv.string,
vol.Optional(ATTR_REPEATS, default=1):
cv.positive_int
})
TIVO_SCHEMA = vol.Schema({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_NAME):
cv.string,
vol.Optional(CONF_FORCEHD, default=False):
cv.boolean,
vol.Optional(CONF_KEEP_CONNECTED, default=False):
cv.boolean,
})
vol.Optional(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT):
cv.port,
vol.Optional(CONF_USERNAME):
cv.string,
})
SERVICE_CALL_METHOD = 'squeezebox_call_method'
DATA_SQUEEZEBOX = 'squeexebox'
ATTR_METHOD = 'method'
SQUEEZEBOX_CALL_METHOD_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
vol.Required(ATTR_METHOD):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string]),
})
SERVICE_TO_METHOD = {
SERVICE_CALL_METHOD: {
'method': 'async_call_method',
'schema': SQUEEZEBOX_CALL_METHOD_SCHEMA
},
}
@asyncio.coroutine
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Set up the squeezebox platform."""
import socket