Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add config flow to kodi (#38551) 

* Add config flow to kodi

* Fix lint errors

* Remove entry update listener

* Create test_init.py

* Apply suggestions from code review

Co-authored-by: Chris Talkington <chris@talkingtontech.com>

* Update __init__.py

* fix indentation

* Apply suggestions from code review

* Apply suggestions from code review

* Update tests/components/kodi/__init__.py

* Fix init test

* Fix merge

* More review changes

* Apply suggestions from code review

* Apply suggestions from code review

Co-authored-by: Chris Talkington <chris@talkingtontech.com>

* Fix black formatting

* Fix Flake8

* Don't store CONF_ID

* Fall back to entry id

* Apply suggestions from code review

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update __init__.py

* Apply suggestions from code review

* Apply suggestions from code review

Co-authored-by: Chris Talkington <chris@talkingtontech.com>
Co-authored-by: J. Nick Koston <nick@koston.org>
pull/39101/head
On Freund 2020-08-21 07:16:58 +03:00 committed by GitHub
parent e0e31693f5
commit c1ed584f2d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 1362 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CODEOWNERS
View File

@ -224,7 +224,7 @@ homeassistant/components/keenetic_ndms2/* @foxel
homeassistant/components/kef/* @basnijholt
homeassistant/components/keyboard_remote/* @bendavid
homeassistant/components/knx/* @Julius2342
homeassistant/components/kodi/* @armills
homeassistant/components/kodi/* @armills @OnFreund
homeassistant/components/konnected/* @heythisisnate @kit-klein
homeassistant/components/lametric/* @robbiet480
homeassistant/components/launch_library/* @ludeeus

2
homeassistant/components/discovery/__init__.py
View File

@ -70,7 +70,6 @@ SERVICE_HANDLERS = {
"openhome": ("media_player", "openhome"),
"bose_soundtouch": ("media_player", "soundtouch"),
"bluesound": ("media_player", "bluesound"),
"kodi": ("media_player", "kodi"),
"lg_smart_device": ("media_player", "lg_soundbar"),
"nanoleaf_aurora": ("light", "nanoleaf"),
}
@ -87,6 +86,7 @@ MIGRATED_SERVICE_HANDLERS = [
"harmony",
"homekit",
"ikea_tradfri",
"kodi",
"philips_hue",
"sonos",
"songpal",

163
homeassistant/components/kodi/__init__.py
View File

@ -1,89 +1,100 @@
"""The kodi component."""
import asyncio
import logging
import voluptuous as vol
from pykodi import CannotConnectError, InvalidAuthError, Kodi, get_kodi_connection
from homeassistant.components.kodi.const import DOMAIN
from homeassistant.components.media_player.const import DOMAIN as MP_DOMAIN
from homeassistant.const import ATTR_ENTITY_ID, CONF_PLATFORM
from homeassistant.helpers import config_validation as cv
SERVICE_ADD_MEDIA = "add_to_playlist"
SERVICE_CALL_METHOD = "call_method"
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_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.comp_entity_ids})
KODI_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,
}
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
EVENT_HOMEASSISTANT_STOP,
)
KODI_CALL_METHOD_SCHEMA = MEDIA_PLAYER_SCHEMA.extend(
{vol.Required(ATTR_METHOD): cv.string}, extra=vol.ALLOW_EXTRA
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import (
CONF_WS_PORT,
DATA_CONNECTION,
DATA_KODI,
DATA_REMOVE_LISTENER,
DATA_VERSION,
DOMAIN,
)
SERVICE_TO_METHOD = {
SERVICE_ADD_MEDIA: {
"method": "async_add_media_to_playlist",
"schema": KODI_ADD_MEDIA_SCHEMA,
},
SERVICE_CALL_METHOD: {
"method": "async_call_method",
"schema": KODI_CALL_METHOD_SCHEMA,
},
}
_LOGGER = logging.getLogger(__name__)
PLATFORMS = ["media_player"]
async def async_setup(hass, config):
"""Set up the Kodi integration."""
if any((CONF_PLATFORM, DOMAIN) in cfg.items() for cfg in config.get(MP_DOMAIN, [])):
# Register the Kodi media_player services
async def async_service_handler(service):
"""Map services to methods on MediaPlayerEntity."""
method = SERVICE_TO_METHOD.get(service.service)
if not method:
return
params = {
key: value for key, value in service.data.items() if key != "entity_id"
}
entity_ids = service.data.get("entity_id")
if entity_ids:
target_players = [
player
for player in hass.data[DOMAIN].values()
if player.entity_id in entity_ids
]
else:
target_players = hass.data[DOMAIN].values()
update_tasks = []
for player in target_players:
await getattr(player, method["method"])(**params)
for player in target_players:
if player.should_poll:
update_coro = player.async_update_ha_state(True)
update_tasks.append(update_coro)
if update_tasks:
await asyncio.wait(update_tasks)
for service in SERVICE_TO_METHOD:
schema = SERVICE_TO_METHOD[service]["schema"]
hass.services.async_register(
DOMAIN, service, async_service_handler, schema=schema
)
# Return boolean to indicate that initialization was successful.
hass.data.setdefault(DOMAIN, {})
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Set up Kodi from a config entry."""
conn = get_kodi_connection(
entry.data[CONF_HOST],
entry.data[CONF_PORT],
entry.data[CONF_WS_PORT],
entry.data[CONF_USERNAME],
entry.data[CONF_PASSWORD],
entry.data[CONF_SSL],
session=async_get_clientsession(hass),
)
try:
await conn.connect()
kodi = Kodi(conn)
await kodi.ping()
raw_version = (await kodi.get_application_properties(["version"]))["version"]
except CannotConnectError as error:
raise ConfigEntryNotReady from error
except InvalidAuthError as error:
_LOGGER.error(
"Login to %s failed: [%s]", entry.data[CONF_HOST], error,
)
return False
async def _close(event):
await conn.close()
remove_stop_listener = hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _close)
version = f"{raw_version['major']}.{raw_version['minor']}"
hass.data[DOMAIN][entry.entry_id] = {
DATA_CONNECTION: conn,
DATA_KODI: kodi,
DATA_REMOVE_LISTENER: remove_stop_listener,
DATA_VERSION: version,
}
for component in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, component)
)
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Unload a config entry."""
unload_ok = all(
await asyncio.gather(
*[
hass.config_entries.async_forward_entry_unload(entry, component)
for component in PLATFORMS
]
)
)
if unload_ok:
data = hass.data[DOMAIN].pop(entry.entry_id)
await data[DATA_CONNECTION].close()
data[DATA_REMOVE_LISTENER]()
return unload_ok

260
homeassistant/components/kodi/config_flow.py Normal file
View File

@ -0,0 +1,260 @@
"""Config flow for Kodi integration."""
import logging
from pykodi import CannotConnectError, InvalidAuthError, Kodi, get_kodi_connection
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_TIMEOUT,
CONF_USERNAME,
)
from homeassistant.core import callback
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.typing import DiscoveryInfoType, Optional
from .const import (
CONF_WS_PORT,
DEFAULT_PORT,
DEFAULT_SSL,
DEFAULT_TIMEOUT,
DEFAULT_WS_PORT,
)
from .const import DOMAIN # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
async def validate_http(hass: core.HomeAssistant, data):
"""Validate the user input allows us to connect over HTTP."""
host = data[CONF_HOST]
port = data[CONF_PORT]
username = data.get(CONF_USERNAME)
password = data.get(CONF_PASSWORD)
ssl = data.get(CONF_SSL)
session = async_get_clientsession(hass)
_LOGGER.debug("Connecting to %s:%s over HTTP.", host, port)
khc = get_kodi_connection(
host, port, None, username, password, ssl, session=session
)
kodi = Kodi(khc)
try:
await kodi.ping()
except CannotConnectError as error:
raise CannotConnect from error
except InvalidAuthError as error:
raise InvalidAuth from error
async def validate_ws(hass: core.HomeAssistant, data):
"""Validate the user input allows us to connect over WS."""
ws_port = data.get(CONF_WS_PORT)
if not ws_port:
return
host = data[CONF_HOST]
port = data[CONF_PORT]
username = data.get(CONF_USERNAME)
password = data.get(CONF_PASSWORD)
ssl = data.get(CONF_SSL)
session = async_get_clientsession(hass)
_LOGGER.debug("Connecting to %s:%s over WebSocket.", host, ws_port)
kwc = get_kodi_connection(
host, port, ws_port, username, password, ssl, session=session
)
try:
await kwc.connect()
if not kwc.connected:
_LOGGER.warning("Cannot connect to %s:%s over WebSocket.", host, ws_port)
raise CannotConnect()
kodi = Kodi(kwc)
await kodi.ping()
except CannotConnectError as error:
raise CannotConnect from error
class KodiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Kodi."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
def __init__(self):
"""Initialize flow."""
self._host: Optional[str] = None
self._port: Optional[int] = None
self._ws_port: Optional[int] = None
self._name: Optional[str] = None
self._username: Optional[str] = None
self._password: Optional[str] = None
self._ssl: Optional[bool] = DEFAULT_SSL
self._discovery_name: Optional[str] = None
async def async_step_zeroconf(self, discovery_info: DiscoveryInfoType):
"""Handle zeroconf discovery."""
self._host = discovery_info["host"]
self._port = int(discovery_info["port"])
self._name = discovery_info["hostname"][: -len(".local.")]
uuid = discovery_info["properties"]["uuid"]
self._discovery_name = discovery_info["name"]
await self.async_set_unique_id(uuid)
self._abort_if_unique_id_configured(
updates={
CONF_HOST: self._host,
CONF_PORT: self._port,
CONF_NAME: self._name,
}
)
# pylint: disable=no-member # https://github.com/PyCQA/pylint/issues/3167
self.context.update({"title_placeholders": {CONF_NAME: self._name}})
return await self.async_step_discovery_confirm()
async def async_step_discovery_confirm(self, user_input=None):
"""Handle user-confirmation of discovered node."""
if user_input is not None:
return await self.async_step_credentials()
return self.async_show_form(
step_id="discovery_confirm", description_placeholders={"name": self._name}
)
async def async_step_user(self, user_input=None):
"""Handle the initial step."""
return await self.async_step_host(user_input)
async def async_step_host(self, user_input=None, errors=None):
"""Handle host name and port input."""
if not errors:
errors = {}
if user_input is not None:
self._host = user_input[CONF_HOST]
self._port = user_input[CONF_PORT]
self._ssl = user_input[CONF_SSL]
return await self.async_step_credentials()
return self.async_show_form(
step_id="host", data_schema=self._host_schema(), errors=errors
)
async def async_step_credentials(self, user_input=None):
"""Handle username and password input."""
errors = {}
if user_input is not None:
self._username = user_input.get(CONF_USERNAME)
self._password = user_input.get(CONF_PASSWORD)
try:
await validate_http(self.hass, self._get_data())
return await self.async_step_ws_port()
except InvalidAuth:
errors["base"] = "invalid_auth"
except CannotConnect:
if self._discovery_name:
return self.async_abort(reason="cannot_connect")
return await self.async_step_host(errors={"base": "cannot_connect"})
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected exception")
errors["base"] = "unknown"
return self.async_show_form(
step_id="credentials", data_schema=self._credentials_schema(), errors=errors
)
async def async_step_ws_port(self, user_input=None):
"""Handle websocket port of discovered node."""
errors = {}
if user_input is not None:
self._ws_port = user_input.get(CONF_WS_PORT)
try:
await validate_ws(self.hass, self._get_data())
return self._create_entry()
except CannotConnect:
errors["base"] = "cannot_connect"
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected exception")
errors["base"] = "unknown"
return self.async_show_form(
step_id="ws_port", data_schema=self._ws_port_schema(), errors=errors
)
async def async_step_import(self, data):
"""Handle import from YAML."""
# We assume that the imported values work and just create the entry
return self.async_create_entry(title=data[CONF_NAME], data=data)
@callback
def _create_entry(self):
return self.async_create_entry(
title=self._name or self._host, data=self._get_data(),
)
@callback
def _get_data(self):
data = {
CONF_NAME: self._name,
CONF_HOST: self._host,
CONF_PORT: self._port,
CONF_WS_PORT: self._ws_port,
CONF_USERNAME: self._username,
CONF_PASSWORD: self._password,
CONF_SSL: self._ssl,
CONF_TIMEOUT: DEFAULT_TIMEOUT,
}
return data
@callback
def _ws_port_schema(self):
suggestion = self._ws_port or DEFAULT_WS_PORT
return vol.Schema(
{
vol.Optional(
CONF_WS_PORT, description={"suggested_value": suggestion}
): int
}
)
@callback
def _host_schema(self):
default_port = self._port or DEFAULT_PORT
default_ssl = self._ssl or DEFAULT_SSL
return vol.Schema(
{
vol.Required(CONF_HOST, default=self._host): str,
vol.Required(CONF_PORT, default=default_port): int,
vol.Required(CONF_SSL, default=default_ssl): bool,
}
)
@callback
def _credentials_schema(self):
return vol.Schema(
{
vol.Optional(
CONF_USERNAME, description={"suggested_value": self._username}
): str,
vol.Optional(
CONF_PASSWORD, description={"suggested_value": self._password}
): str,
}
)
class CannotConnect(exceptions.HomeAssistantError):
"""Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError):
"""Error to indicate there is invalid auth."""

15
homeassistant/components/kodi/const.py
View File

@ -1,2 +1,17 @@
"""Constants for the Kodi platform."""
DOMAIN = "kodi"
CONF_WS_PORT = "ws_port"
DATA_CONNECTION = "connection"
DATA_KODI = "kodi"
DATA_REMOVE_LISTENER = "remove_listener"
DATA_VERSION = "version"
DEFAULT_PORT = 8080
DEFAULT_SSL = False
DEFAULT_TIMEOUT = 5
DEFAULT_WS_PORT = 9090
EVENT_TURN_OFF = "kodi.turn_off"
EVENT_TURN_ON = "kodi.turn_on"

89
homeassistant/components/kodi/device_trigger.py Normal file
View File

@ -0,0 +1,89 @@
"""Provides device automations for Kodi."""
from typing import List
import voluptuous as vol
from homeassistant.components.automation import AutomationActionType
from homeassistant.components.device_automation import TRIGGER_BASE_SCHEMA
from homeassistant.const import (
ATTR_ENTITY_ID,
CONF_DEVICE_ID,
CONF_DOMAIN,
CONF_ENTITY_ID,
CONF_PLATFORM,
CONF_TYPE,
)
from homeassistant.core import CALLBACK_TYPE, Event, HomeAssistant, callback
from homeassistant.helpers import config_validation as cv, entity_registry
from homeassistant.helpers.typing import ConfigType
from .const import DOMAIN, EVENT_TURN_OFF, EVENT_TURN_ON
TRIGGER_TYPES = {"turn_on", "turn_off"}
TRIGGER_SCHEMA = TRIGGER_BASE_SCHEMA.extend(
{
vol.Required(CONF_ENTITY_ID): cv.entity_id,
vol.Required(CONF_TYPE): vol.In(TRIGGER_TYPES),
}
)
async def async_get_triggers(hass: HomeAssistant, device_id: str) -> List[dict]:
"""List device triggers for Kodi devices."""
registry = await entity_registry.async_get_registry(hass)
triggers = []
# Get all the integrations entities for this device
for entry in entity_registry.async_entries_for_device(registry, device_id):
if entry.domain == "media_player":
triggers.append(
{
CONF_PLATFORM: "device",
CONF_DEVICE_ID: device_id,
CONF_DOMAIN: DOMAIN,
CONF_ENTITY_ID: entry.entity_id,
CONF_TYPE: "turn_on",
}
)
triggers.append(
{
CONF_PLATFORM: "device",
CONF_DEVICE_ID: device_id,
CONF_DOMAIN: DOMAIN,
CONF_ENTITY_ID: entry.entity_id,
CONF_TYPE: "turn_off",
}
)
return triggers
@callback
def _attach_trigger(
hass: HomeAssistant, config: ConfigType, action: AutomationActionType, event_type
):
@callback
def _handle_event(event: Event):
if event.data[ATTR_ENTITY_ID] == config[CONF_ENTITY_ID]:
hass.async_run_job(action({"trigger": config}, context=event.context))
return hass.bus.async_listen(event_type, _handle_event)
async def async_attach_trigger(
hass: HomeAssistant,
config: ConfigType,
action: AutomationActionType,
automation_info: dict,
) -> CALLBACK_TYPE:
"""Attach a trigger."""
config = TRIGGER_SCHEMA(config)
if config[CONF_TYPE] == "turn_on":
return _attach_trigger(hass, config, action, EVENT_TURN_ON)
if config[CONF_TYPE] == "turn_off":
return _attach_trigger(hass, config, action, EVENT_TURN_OFF)
return lambda: None

11
homeassistant/components/kodi/manifest.json
View File

@ -2,6 +2,11 @@
"domain": "kodi",
"name": "Kodi",
"documentation": "https://www.home-assistant.io/integrations/kodi",
"requirements": ["jsonrpc-async==0.6", "jsonrpc-websocket==0.6"],
"codeowners": ["@armills"]
}
"requirements": ["pykodi==0.1"],
"codeowners": [
"@armills",
"@OnFreund"
],
"zeroconf": ["_xbmc-jsonrpc-h._tcp.local."],
"config_flow": true
}

697
homeassistant/components/kodi/media_player.py
View File

@ -1,21 +1,12 @@
"""Support for interfacing with the XBMC/Kodi JSON-RPC API."""
import asyncio
from collections import OrderedDict
from datetime import timedelta
from functools import wraps
import logging
import re
import socket
import urllib
import aiohttp
import jsonrpc_async
import jsonrpc_base
import jsonrpc_websocket
import voluptuous as vol
from homeassistant.components.kodi import SERVICE_CALL_METHOD
from homeassistant.components.kodi.const import DOMAIN
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
@ -38,27 +29,40 @@ from homeassistant.components.media_player.const import (
SUPPORT_VOLUME_SET,
SUPPORT_VOLUME_STEP,
)
from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.const import (
ATTR_ENTITY_ID,
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_PROXY_SSL,
CONF_SSL,
CONF_TIMEOUT,
CONF_USERNAME,
EVENT_HOMEASSISTANT_STOP,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.core import callback
from homeassistant.helpers import config_validation as cv, script
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers import config_validation as cv, entity_platform
from homeassistant.helpers.event import async_track_time_interval
from homeassistant.helpers.template import Template
import homeassistant.util.dt as dt_util
from homeassistant.util.yaml import dump
from .const import (
CONF_WS_PORT,
DATA_CONNECTION,
DATA_KODI,
DATA_VERSION,
DEFAULT_PORT,
DEFAULT_SSL,
DEFAULT_TIMEOUT,
DEFAULT_WS_PORT,
DOMAIN,
EVENT_TURN_OFF,
EVENT_TURN_ON,
)
_LOGGER = logging.getLogger(__name__)
@ -69,13 +73,6 @@ CONF_TURN_ON_ACTION = "turn_on_action"
CONF_TURN_OFF_ACTION = "turn_off_action"
CONF_ENABLE_WEBSOCKET = "enable_websocket"
DEFAULT_NAME = "Kodi"
DEFAULT_PORT = 8080
DEFAULT_TCP_PORT = 9090
DEFAULT_TIMEOUT = 5
DEFAULT_PROXY_SSL = False
DEFAULT_ENABLE_WEBSOCKET = True
DEPRECATED_TURN_OFF_ACTIONS = {
None: None,
"quit": "Application.Quit",
@ -118,15 +115,18 @@ SUPPORT_KODI = (
| SUPPORT_SHUFFLE_SET
| SUPPORT_PLAY
| SUPPORT_VOLUME_STEP
| SUPPORT_TURN_OFF
| SUPPORT_TURN_ON
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
vol.Optional(CONF_TCP_PORT, default=DEFAULT_TCP_PORT): cv.port,
vol.Optional(CONF_PROXY_SSL, default=DEFAULT_PROXY_SSL): cv.boolean,
vol.Optional(CONF_TCP_PORT, default=DEFAULT_WS_PORT): cv.port,
vol.Optional(CONF_PROXY_SSL, default=DEFAULT_SSL): cv.boolean,
vol.Optional(CONF_TURN_ON_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_TURN_OFF_ACTION): vol.Any(
cv.SCRIPT_SCHEMA, vol.In(DEPRECATED_TURN_OFF_ACTIONS)
@ -134,102 +134,93 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
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,
vol.Optional(CONF_ENABLE_WEBSOCKET, default=True): cv.boolean,
}
)
def _check_deprecated_turn_off(hass, turn_off_action):
"""Create an equivalent script for old turn off actions."""
if isinstance(turn_off_action, str):
method = DEPRECATED_TURN_OFF_ACTIONS[turn_off_action]
new_config = OrderedDict(
[
("service", f"{DOMAIN}.{SERVICE_CALL_METHOD}"),
(
"data_template",
OrderedDict([("entity_id", "{{ entity_id }}"), ("method", method)]),
),
]
)
example_conf = dump(OrderedDict([(CONF_TURN_OFF_ACTION, new_config)]))
_LOGGER.warning(
"The '%s' action for turn off Kodi is deprecated and "
"will cease to function in a future release. You need to "
"change it for a generic Home Assistant script sequence, "
"which is, for this turn_off action, like this:\n%s",
turn_off_action,
example_conf,
)
new_config["data_template"] = OrderedDict(
[
(key, Template(value, hass))
for key, value in new_config["data_template"].items()
]
)
turn_off_action = [new_config]
return turn_off_action
SERVICE_ADD_MEDIA = "add_to_playlist"
SERVICE_CALL_METHOD = "call_method"
ATTR_MEDIA_TYPE = "media_type"
ATTR_MEDIA_NAME = "media_name"
ATTR_MEDIA_ARTIST_NAME = "artist_name"
ATTR_MEDIA_ID = "media_id"
ATTR_METHOD = "method"
KODI_ADD_MEDIA_SCHEMA = {
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,
}
KODI_CALL_METHOD_SCHEMA = cv.make_entity_service_schema(
{vol.Required(ATTR_METHOD): cv.string}, extra=vol.ALLOW_EXTRA
)
def find_matching_config_entries_for_host(hass, host):
"""Search existing config entries for one matching the host."""
for entry in hass.config_entries.async_entries(DOMAIN):
if entry.data[CONF_HOST] == host:
return entry
return None
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the Kodi platform."""
if DOMAIN not in hass.data:
hass.data[DOMAIN] = {}
unique_id = None
# Is this a manual configuration?
if discovery_info is None:
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)
tcp_port = config.get(CONF_TCP_PORT)
encryption = config.get(CONF_PROXY_SSL)
websocket = config.get(CONF_ENABLE_WEBSOCKET)
else:
name = f"{DEFAULT_NAME} ({discovery_info.get('hostname')})"
host = discovery_info.get("host")
port = discovery_info.get("port")
tcp_port = DEFAULT_TCP_PORT
encryption = DEFAULT_PROXY_SSL
websocket = DEFAULT_ENABLE_WEBSOCKET
properties = discovery_info.get("properties")
if properties is not None:
unique_id = properties.get("uuid", None)
# Only add a device once, so discovered devices do not override manual
# config.
ip_addr = socket.gethostbyname(host)
if ip_addr in hass.data[DOMAIN]:
if discovery_info:
# Now handled by zeroconf in the config flow
return
# If we got an unique id, check that it does not exist already.
# This is necessary as netdisco does not deterministally return the same
# advertisement when the service is offered over multiple IP addresses.
if unique_id is not None:
for device in hass.data[DOMAIN].values():
if device.unique_id == unique_id:
return
host = config[CONF_HOST]
if find_matching_config_entries_for_host(hass, host):
return
entity = KodiDevice(
hass,
name=name,
host=host,
port=port,
tcp_port=tcp_port,
encryption=encryption,
username=config.get(CONF_USERNAME),
password=config.get(CONF_PASSWORD),
turn_on_action=config.get(CONF_TURN_ON_ACTION),
turn_off_action=config.get(CONF_TURN_OFF_ACTION),
timeout=config.get(CONF_TIMEOUT),
websocket=websocket,
unique_id=unique_id,
websocket = config.get(CONF_ENABLE_WEBSOCKET)
ws_port = config.get(CONF_TCP_PORT) if websocket else None
entry_data = {
CONF_NAME: config.get(CONF_NAME, host),
CONF_HOST: host,
CONF_PORT: config.get(CONF_PORT),
CONF_WS_PORT: ws_port,
CONF_USERNAME: config.get(CONF_USERNAME),
CONF_PASSWORD: config.get(CONF_PASSWORD),
CONF_SSL: config.get(CONF_PROXY_SSL),
CONF_TIMEOUT: config.get(CONF_TIMEOUT),
}
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_IMPORT}, data=entry_data
)
)
hass.data[DOMAIN][ip_addr] = entity
async_add_entities([entity], update_before_add=True)
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the Kodi media player platform."""
platform = entity_platform.current_platform.get()
platform.async_register_entity_service(
SERVICE_ADD_MEDIA, KODI_ADD_MEDIA_SCHEMA, "async_add_media_to_playlist"
)
platform.async_register_entity_service(
SERVICE_CALL_METHOD, KODI_CALL_METHOD_SCHEMA, "async_call_method"
)
data = hass.data[DOMAIN][config_entry.entry_id]
connection = data[DATA_CONNECTION]
version = data[DATA_VERSION]
kodi = data[DATA_KODI]
name = config_entry.data[CONF_NAME]
uid = config_entry.unique_id
if uid is None:
uid = config_entry.entry_id
entity = KodiEntity(connection, kodi, name, uid, version)
async_add_entities([entity])
def cmd(func):
@ -253,97 +244,38 @@ def cmd(func):
return wrapper
class KodiDevice(MediaPlayerEntity):
class KodiEntity(MediaPlayerEntity):
"""Representation of a XBMC/Kodi device."""
def __init__(
self,
hass,
name,
host,
port,
tcp_port,
encryption=False,
username=None,
password=None,
turn_on_action=None,
turn_off_action=None,
timeout=DEFAULT_TIMEOUT,
websocket=True,
unique_id=None,
):
"""Initialize the Kodi device."""
self.hass = hass
def __init__(self, connection, kodi, name, uid, version):
"""Initialize the Kodi entity."""
self._connection = connection
self._kodi = kodi
self._name = name
self._unique_id = unique_id
self._media_position_updated_at = None
self._media_position = None
kwargs = {"timeout": timeout, "session": async_get_clientsession(hass)}
if username is not None:
kwargs["auth"] = aiohttp.BasicAuth(username, password)
image_auth_string = f"{username}:{password}@"
else:
image_auth_string = ""
http_protocol = "https" if encryption else "http"
ws_protocol = "wss" if encryption else "ws"
self._http_url = f"{http_protocol}://{host}:{port}/jsonrpc"
self._image_url = f"{http_protocol}://{image_auth_string}{host}:{port}/image"
self._ws_url = f"{ws_protocol}://{host}:{tcp_port}/jsonrpc"
self._http_server = jsonrpc_async.Server(self._http_url, **kwargs)
if websocket:
# Setup websocket connection
self._ws_server = jsonrpc_websocket.Server(self._ws_url, **kwargs)
# Register notification listeners
self._ws_server.Player.OnPause = self.async_on_speed_event
self._ws_server.Player.OnPlay = self.async_on_speed_event
self._ws_server.Player.OnAVStart = self.async_on_speed_event
self._ws_server.Player.OnAVChange = self.async_on_speed_event
self._ws_server.Player.OnResume = self.async_on_speed_event
self._ws_server.Player.OnSpeedChanged = self.async_on_speed_event
self._ws_server.Player.OnSeek = self.async_on_speed_event
self._ws_server.Player.OnStop = self.async_on_stop
self._ws_server.Application.OnVolumeChanged = self.async_on_volume_changed
self._ws_server.System.OnQuit = self.async_on_quit
self._ws_server.System.OnRestart = self.async_on_quit
self._ws_server.System.OnSleep = self.async_on_quit
def on_hass_stop(event):
"""Close websocket connection when hass stops."""
self.hass.async_create_task(self._ws_server.close())
self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, on_hass_stop)
else:
self._ws_server = None
# Script creation for the turn on/off config options
if turn_on_action is not None:
turn_on_action = script.Script(
self.hass,
turn_on_action,
f"{self.name} turn ON script",
DOMAIN,
change_listener=self.async_update_ha_state(True),
)
if turn_off_action is not None:
turn_off_action = script.Script(
self.hass,
_check_deprecated_turn_off(hass, turn_off_action),
f"{self.name} turn OFF script",
DOMAIN,
)
self._turn_on_action = turn_on_action
self._turn_off_action = turn_off_action
self._enable_websocket = websocket
self._players = []
self._unique_id = uid
self._version = version
self._players = None
self._properties = {}
self._item = {}
self._app_properties = {}
self._media_position_updated_at = None
self._media_position = None
def _reset_state(self, players=None):
self._players = players
self._properties = {}
self._item = {}
self._app_properties = {}
self._media_position_updated_at = None
self._media_position = None
@property
def _kodi_is_off(self):
return self._players is None
@property
def _no_active_players(self):
return not self._players
@callback
def async_on_speed_event(self, sender, data):
@ -363,14 +295,10 @@ class KodiDevice(MediaPlayerEntity):
def async_on_stop(self, sender, data):
"""Handle the stop of the player playback."""
# Prevent stop notifications which are sent after quit notification
if self._players is None:
if self._kodi_is_off:
return
self._players = []
self._properties = {}
self._item = {}
self._media_position_updated_at = None
self._media_position = None
self._reset_state([])
self.async_write_ha_state()
@callback
@ -383,34 +311,31 @@ class KodiDevice(MediaPlayerEntity):
@callback
def async_on_quit(self, sender, data):
"""Reset the player state on quit action."""
self._players = None
self._properties = {}
self._item = {}
self._app_properties = {}
self.hass.async_create_task(self._ws_server.close())
async def _get_players(self):
"""Return the active player objects or None."""
try:
return await self.server.Player.GetActivePlayers()
except jsonrpc_base.jsonrpc.TransportError:
if self._players is not None:
_LOGGER.info("Unable to fetch kodi data")
_LOGGER.debug("Unable to fetch kodi data", exc_info=True)
return None
self._reset_state()
self.hass.async_create_task(self._connection.close())
@property
def unique_id(self):
"""Return the unique id of the device."""
return self._unique_id
@property
def device_info(self):
"""Return device info for this device."""
return {
"identifiers": {(DOMAIN, self.unique_id)},
"name": self.name,
"manufacturer": "Kodi",
"sw_version": self._version,
}
@property
def state(self):
"""Return the state of the device."""
if self._players is None:
if self._kodi_is_off:
return STATE_OFF
if not self._players:
if self._no_active_players:
return STATE_IDLE
if self._properties["speed"] == 0:
@ -418,36 +343,13 @@ class KodiDevice(MediaPlayerEntity):
return STATE_PLAYING
async def async_ws_connect(self):
"""Connect to Kodi via websocket protocol."""
try:
ws_loop_future = await self._ws_server.ws_connect()
except jsonrpc_base.jsonrpc.TransportError:
_LOGGER.info("Unable to connect to Kodi via websocket")
_LOGGER.debug("Unable to connect to Kodi via websocket", exc_info=True)
return
async def ws_loop_wrapper():
"""Catch exceptions from the websocket loop task."""
try:
await ws_loop_future
except jsonrpc_base.TransportError:
# Kodi abruptly ends ws connection when exiting. We will try
# to reconnect on the next poll.
pass
# Update HA state after Kodi disconnects
self.async_write_ha_state()
# Create a task instead of adding a tracking job, since this task will
# run until the websocket connection is closed.
self.hass.loop.create_task(ws_loop_wrapper())
async def async_added_to_hass(self):
"""Connect the websocket if needed."""
if not self._enable_websocket:
if not self._connection.can_subscribe:
return
asyncio.create_task(self.async_ws_connect())
if self._connection.connected:
self._on_ws_connected()
self.async_on_remove(
async_track_time_interval(
@ -457,32 +359,62 @@ class KodiDevice(MediaPlayerEntity):
)
)
@callback
def _on_ws_connected(self):
"""Call after ws is connected."""
self._register_ws_callbacks()
self.async_schedule_update_ha_state(True)
async def _async_ws_connect(self):
"""Connect to Kodi via websocket protocol."""
try:
await self._connection.connect()
self._on_ws_connected()
except jsonrpc_base.jsonrpc.TransportError:
_LOGGER.info("Unable to connect to Kodi via websocket")
_LOGGER.debug("Unable to connect to Kodi via websocket", exc_info=True)
async def _async_connect_websocket_if_disconnected(self, *_):
"""Reconnect the websocket if it fails."""
if not self._ws_server.connected:
await self.async_ws_connect()
if not self._connection.connected:
await self._async_ws_connect()
@callback
def _register_ws_callbacks(self):
self._connection.server.Player.OnPause = self.async_on_speed_event
self._connection.server.Player.OnPlay = self.async_on_speed_event
self._connection.server.Player.OnAVStart = self.async_on_speed_event
self._connection.server.Player.OnAVChange = self.async_on_speed_event
self._connection.server.Player.OnResume = self.async_on_speed_event
self._connection.server.Player.OnSpeedChanged = self.async_on_speed_event
self._connection.server.Player.OnSeek = self.async_on_speed_event
self._connection.server.Player.OnStop = self.async_on_stop
self._connection.server.Application.OnVolumeChanged = (
self.async_on_volume_changed
)
self._connection.server.System.OnQuit = self.async_on_quit
self._connection.server.System.OnRestart = self.async_on_quit
self._connection.server.System.OnSleep = self.async_on_quit
async def async_update(self):
"""Retrieve latest state."""
self._players = await self._get_players()
if self._players is None:
self._properties = {}
self._item = {}
self._app_properties = {}
if not self._connection.connected:
self._reset_state()
return
self._app_properties = await self.server.Application.GetProperties(
["volume", "muted"]
)
self._players = await self._kodi.get_players()
if self._kodi_is_off:
self._reset_state()
return
if self._players:
player_id = self._players[0]["playerid"]
self._app_properties = await self._kodi.get_application_properties(
["volume", "muted"]
)
assert isinstance(player_id, int)
self._properties = await self.server.Player.GetProperties(
player_id, ["time", "totaltime", "speed", "live"]
self._properties = await self._kodi.get_player_properties(
self._players[0], ["time", "totaltime", "speed", "live"]
)
position = self._properties["time"]
@ -490,37 +422,23 @@ class KodiDevice(MediaPlayerEntity):
self._media_position_updated_at = dt_util.utcnow()
self._media_position = position
self._item = (
await self.server.Player.GetItem(
player_id,
[
"title",
"file",
"uniqueid",
"thumbnail",
"artist",
"albumartist",
"showtitle",
"album",
"season",
"episode",
],
)
)["item"]
self._item = await self._kodi.get_playing_item_properties(
self._players[0],
[
"title",
"file",
"uniqueid",
"thumbnail",
"artist",
"albumartist",
"showtitle",
"album",
"season",
"episode",
],
)
else:
self._properties = {}
self._item = {}
self._app_properties = {}
self._media_position = None
self._media_position_updated_at = None
@property
def server(self):
"""Active server for json-rpc requests."""
if self._enable_websocket and self._ws_server.connected:
return self._ws_server
return self._http_server
self._reset_state([])
@property
def name(self):
@ -530,13 +448,13 @@ class KodiDevice(MediaPlayerEntity):
@property
def should_poll(self):
"""Return True if entity has to be polled for state."""
return not (self._enable_websocket and self._ws_server.connected)
return (not self._connection.can_subscribe) or (not self._connection.connected)
@property
def volume_level(self):
"""Volume level of the media player (0..1)."""
if "volume" in self._app_properties:
return self._app_properties["volume"] / 100.0
return int(self._app_properties["volume"]) / 100.0
@property
def is_volume_muted(self):
@ -598,9 +516,7 @@ class KodiDevice(MediaPlayerEntity):
if thumbnail is None:
return None
url_components = urllib.parse.urlparse(thumbnail)
if url_components.scheme == "image":
return f"{self._image_url}/{urllib.parse.quote_plus(thumbnail)}"
return self._kodi.thumbnail_url(thumbnail)
@property
def media_title(self):
@ -650,128 +566,72 @@ class KodiDevice(MediaPlayerEntity):
@property
def supported_features(self):
"""Flag media player features that are supported."""
supported_features = SUPPORT_KODI
return SUPPORT_KODI
if self._turn_on_action is not None:
supported_features |= SUPPORT_TURN_ON
if self._turn_off_action is not None:
supported_features |= SUPPORT_TURN_OFF
return supported_features
@cmd
async def async_turn_on(self):
"""Execute turn_on_action to turn on media player."""
if self._turn_on_action is not None:
await self._turn_on_action.async_run(
variables={"entity_id": self.entity_id}
)
else:
_LOGGER.warning("turn_on requested but turn_on_action is none")
"""Turn the media player on."""
_LOGGER.debug("Firing event to turn on device")
self.hass.bus.async_fire(EVENT_TURN_ON, {ATTR_ENTITY_ID: self.entity_id})
@cmd
async def async_turn_off(self):
"""Execute turn_off_action to turn off media player."""
if self._turn_off_action is not None:
await self._turn_off_action.async_run(
variables={"entity_id": self.entity_id}
)
else:
_LOGGER.warning("turn_off requested but turn_off_action is none")
"""Turn the media player off."""
_LOGGER.debug("Firing event to turn off device")
self.hass.bus.async_fire(EVENT_TURN_OFF, {ATTR_ENTITY_ID: self.entity_id})
@cmd
async def async_volume_up(self):
"""Volume up the media player."""
assert (await self.server.Input.ExecuteAction("volumeup")) == "OK"
await self._kodi.volume_up()
@cmd
async def async_volume_down(self):
"""Volume down the media player."""
assert (await self.server.Input.ExecuteAction("volumedown")) == "OK"
await self._kodi.volume_down()
@cmd
async def async_set_volume_level(self, volume):
"""Set volume level, range 0..1."""
await self.server.Application.SetVolume(int(volume * 100))
await self._kodi.set_volume_level(int(volume * 100))
@cmd
async def async_mute_volume(self, mute):
"""Mute (true) or unmute (false) media player."""
await self.server.Application.SetMute(mute)
async def async_set_play_state(self, state):
"""Handle play/pause/toggle."""
players = await self._get_players()
if players is not None and players:
await self.server.Player.PlayPause(players[0]["playerid"], state)
await self._kodi.mute(mute)
@cmd
async def async_media_play_pause(self):
"""Pause media on media player."""
await self.async_set_play_state("toggle")
await self._kodi.play_pause()
@cmd
async def async_media_play(self):
"""Play media."""
await self.async_set_play_state(True)
await self._kodi.play()
@cmd
async def async_media_pause(self):
"""Pause the media player."""
await self.async_set_play_state(False)
await self._kodi.pause()
@cmd
async def async_media_stop(self):
"""Stop the media player."""
players = await self._get_players()
if players:
await self.server.Player.Stop(players[0]["playerid"])
async def _goto(self, direction):
"""Handle for previous/next track."""
players = await self._get_players()
if players:
if direction == "previous":
# First seek to position 0. Kodi goes to the beginning of the
# current track if the current track is not at the beginning.
await self.server.Player.Seek(players[0]["playerid"], 0)
await self.server.Player.GoTo(players[0]["playerid"], direction)
await self._kodi.stop()
@cmd
async def async_media_next_track(self):
"""Send next track command."""
await self._goto("next")
await self._kodi.next_track()
@cmd
async def async_media_previous_track(self):
"""Send next track command."""
await self._goto("previous")
await self._kodi.previous_track()
@cmd
async def async_media_seek(self, position):
"""Send seek command."""
players = await self._get_players()
time = {}
time["milliseconds"] = int((position % 1) * 1000)
position = int(position)
time["seconds"] = int(position % 60)
position /= 60
time["minutes"] = int(position % 60)
position /= 60
time["hours"] = int(position)
if players:
await self.server.Player.Seek(players[0]["playerid"], time)
await self._kodi.media_seek(position)
@cmd
async def async_play_media(self, media_type, media_id, **kwargs):
@ -779,30 +639,27 @@ class KodiDevice(MediaPlayerEntity):
media_type_lower = media_type.lower()
if media_type_lower == MEDIA_TYPE_CHANNEL:
await self.server.Player.Open({"item": {"channelid": int(media_id)}})
await self._kodi.play_channel(int(media_id))
elif media_type_lower == MEDIA_TYPE_PLAYLIST:
await self.server.Player.Open({"item": {"playlistid": int(media_id)}})
await self._kodi.play_playlist(int(media_id))
elif media_type_lower == "directory":
await self.server.Player.Open({"item": {"directory": str(media_id)}})
elif media_type_lower == "plugin":
await self.server.Player.Open({"item": {"file": str(media_id)}})
await self._kodi.play_directory(str(media_id))
else:
await self.server.Player.Open({"item": {"file": str(media_id)}})
await self._kodi.play_file(str(media_id))
@cmd
async def async_set_shuffle(self, shuffle):
"""Set shuffle mode, for the first player."""
if not self._players:
if self._no_active_players:
raise RuntimeError("Error: No active player.")
await self.server.Player.SetShuffle(
{"playerid": self._players[0]["playerid"], "shuffle": shuffle}
)
await self._kodi.set_shuffle(shuffle)
async def async_call_method(self, method, **kwargs):
"""Run Kodi JSONRPC API method with params."""
_LOGGER.debug("Run API method %s, kwargs=%s", method, kwargs)
result_ok = False
try:
result = await getattr(self.server, method)(**kwargs)
result = self._kodi.call_method(method, **kwargs)
result_ok = True
except jsonrpc_base.jsonrpc.ProtocolError as exc:
result = exc.args[2]["error"]
@ -835,10 +692,14 @@ class KodiDevice(MediaPlayerEntity):
)
return result
async def async_clear_playlist(self):
"""Clear default playlist (i.e. playlistid=0)."""
await self._kodi.clear_playlist()
async def async_add_media_to_playlist(
self, media_type, media_id=None, media_name="ALL", artist_name=""
):
"""Add a media to default playlist (i.e. playlistid=0).
"""Add a media to default playlist.
First the media type must be selected, then
the media can be specified in terms of id or
@ -846,78 +707,43 @@ class KodiDevice(MediaPlayerEntity):
All the albums of an artist can be added with
media_name="ALL"
"""
params = {"playlistid": 0}
if media_type == "SONG":
if media_id is None:
media_id = await self.async_find_song(media_name, artist_name)
media_id = await self._async_find_song(media_name, artist_name)
if media_id:
params["item"] = {"songid": int(media_id)}
self._kodi.add_song_to_playlist(int(media_id))
elif media_type == "ALBUM":
if media_id is None:
if media_name == "ALL":
await self.async_add_all_albums(artist_name)
await self._async_add_all_albums(artist_name)
return
media_id = await self.async_find_album(media_name, artist_name)
media_id = await self._async_find_album(media_name, artist_name)
if media_id:
params["item"] = {"albumid": int(media_id)}
self._kodi.add_album_to_playlist(int(media_id))
else:
raise RuntimeError("Unrecognized media type.")
if media_id is not None:
try:
await self.server.Playlist.Add(params)
except jsonrpc_base.jsonrpc.ProtocolError as exc:
result = exc.args[2]["error"]
_LOGGER.error(
"Run API method %s.Playlist.Add(%s) error: %s",
self.entity_id,
media_type,
result,
)
except jsonrpc_base.jsonrpc.TransportError:
_LOGGER.warning(
"TransportError trying to add playlist to %s", self.entity_id
)
else:
if media_id is None:
_LOGGER.warning("No media detected for Playlist.Add")
async def async_add_all_albums(self, artist_name):
async def _async_add_all_albums(self, artist_name):
"""Add all albums of an artist to default playlist (i.e. playlistid=0).
The artist is specified in terms of name.
"""
artist_id = await self.async_find_artist(artist_name)
artist_id = await self._async_find_artist(artist_name)
albums = await self.async_get_albums(artist_id)
albums = await self._kodi.get_albums(artist_id)
for alb in albums["albums"]:
await self.server.Playlist.Add(
{"playlistid": 0, "item": {"albumid": int(alb["albumid"])}}
)
await self._kodi.add_album_to_playlist(int(alb["albumid"]))
async def async_clear_playlist(self):
"""Clear default playlist (i.e. playlistid=0)."""
return self.server.Playlist.Clear({"playlistid": 0})
async def async_get_artists(self):
"""Get artists list."""
return await self.server.AudioLibrary.GetArtists()
async def async_get_albums(self, artist_id=None):
"""Get albums list."""
if artist_id is None:
return await self.server.AudioLibrary.GetAlbums()
return await self.server.AudioLibrary.GetAlbums(
{"filter": {"artistid": int(artist_id)}}
)
async def async_find_artist(self, artist_name):
async def _async_find_artist(self, artist_name):
"""Find artist by name."""
artists = await self.async_get_artists()
artists = await self._kodi.get_artists()
try:
out = self._find(artist_name, [a["artist"] for a in artists["artists"]])
return artists["artists"][out[0][0]]["artistid"]
@ -925,35 +751,26 @@ class KodiDevice(MediaPlayerEntity):
_LOGGER.warning("No artists were found: %s", artist_name)
return None
async def async_get_songs(self, artist_id=None):
"""Get songs list."""
if artist_id is None:
return await self.server.AudioLibrary.GetSongs()
return await self.server.AudioLibrary.GetSongs(
{"filter": {"artistid": int(artist_id)}}
)
async def async_find_song(self, song_name, artist_name=""):
async def _async_find_song(self, song_name, artist_name=""):
"""Find song by name and optionally artist name."""
artist_id = None
if artist_name != "":
artist_id = await self.async_find_artist(artist_name)
artist_id = await self._async_find_artist(artist_name)
songs = await self.async_get_songs(artist_id)
songs = await self._kodi.get_songs(artist_id)
if songs["limits"]["total"] == 0:
return None
out = self._find(song_name, [a["label"] for a in songs["songs"]])
return songs["songs"][out[0][0]]["songid"]
async def async_find_album(self, album_name, artist_name=""):
async def _async_find_album(self, album_name, artist_name=""):
"""Find album by name and optionally artist name."""
artist_id = None
if artist_name != "":
artist_id = await self.async_find_artist(artist_name)
artist_id = await self._async_find_artist(artist_name)
albums = await self.async_get_albums(artist_id)
albums = await self._kodi.get_albums(artist_id)
try:
out = self._find(album_name, [a["label"] for a in albums["albums"]])
return albums["albums"][out[0][0]]["albumid"]

47
homeassistant/components/kodi/strings.json Normal file
View File

@ -0,0 +1,47 @@
{
"config": {
"flow_title": "Kodi: {name}",
"step": {
"host": {
"description": "Kodi connection information. Please make sure to enable \"Allow control of Kodi via HTTP\" in System/Settings/Network/Services.",
"data": {
"host": "[%key:common::config_flow::data::host%]",
"port": "[%key:common::config_flow::data::port%]",
"ssl": "Connect over SSL"
}
},
"discovery_confirm": {
"description": "Do you want to add Kodi (`{name}`) to Home Assistant?",
"title": "Discovered Kodi"
},
"ws_port": {
"description": "The WebSocket port (sometimes called TCP port in Kodi). In order to connect over WebSocket, you need to enable \"Allow programs ... to control Kodi\" in System/Settings/Network/Services. If WebSocket is not enabled, remove the port and leave empty.",
"data": {
"ws_port": "[%key:common::config_flow::data::port%]"
}
},
"credentials": {
"description": "Please enter your Kodi user name and password. These can be found in System/Settings/Network/Services.",
"data": {
"username": "[%key:common::config_flow::data::username%]",
"password": "[%key:common::config_flow::data::password%]"
}
}
},
"error": {
"cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
"invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
"unknown": "[%key:common::config_flow::error::unknown%]"
},
"abort": {
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
"cannot_connect": "Cannot connect to discovered Kodi"
}
},
"device_automation": {
"trigger_type": {
"turn_on": "{entity_name} was requested to turn on",
"turn_off": "{entity_name} was requested to turn off"
}
}
}

1
homeassistant/generated/config_flows.py
View File

@ -95,6 +95,7 @@ FLOWS = [
"isy994",
"izone",
"juicenet",
"kodi",
"konnected",
"life360",
"lifx",

3
homeassistant/generated/zeroconf.py
View File

@ -67,6 +67,9 @@ ZEROCONF = {
],
"_wled._tcp.local.": [
"wled"
],
"_xbmc-jsonrpc-h._tcp.local.": [
"kodi"
]
}

9
requirements_all.txt
View File

@ -805,12 +805,6 @@ iperf3==0.1.11
# homeassistant.components.verisure
jsonpath==0.82
# homeassistant.components.kodi
jsonrpc-async==0.6
# homeassistant.components.kodi
jsonrpc-websocket==0.6
# homeassistant.components.kaiterra
kaiterra-async-client==0.0.2
@ -1434,6 +1428,9 @@ pyitachip2ir==0.0.7
# homeassistant.components.kira
pykira==0.1.1
# homeassistant.components.kodi
pykodi==0.1
# homeassistant.components.kwb
pykwb==0.0.8

3
requirements_test_all.txt
View File

@ -683,6 +683,9 @@ pyisy==2.0.2
# homeassistant.components.kira
pykira==0.1.1
# homeassistant.components.kodi
pykodi==0.1
# homeassistant.components.lastfm
pylast==3.2.1

41
tests/components/kodi/__init__.py Normal file
View File

@ -0,0 +1,41 @@
"""Tests for the Kodi integration."""
from homeassistant.components.kodi.const import CONF_WS_PORT, DOMAIN
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
)
from .util import MockConnection
from tests.async_mock import patch
from tests.common import MockConfigEntry
async def init_integration(hass) -> MockConfigEntry:
"""Set up the Kodi integration in Home Assistant."""
entry_data = {
CONF_NAME: "name",
CONF_HOST: "1.1.1.1",
CONF_PORT: 8080,
CONF_WS_PORT: 9090,
CONF_USERNAME: "user",
CONF_PASSWORD: "pass",
CONF_SSL: False,
}
entry = MockConfigEntry(domain=DOMAIN, data=entry_data, title="name")
with patch("homeassistant.components.kodi.Kodi.ping", return_value=True), patch(
"homeassistant.components.kodi.Kodi.get_application_properties",
return_value={"version": {"major": 1, "minor": 1}},
), patch(
"homeassistant.components.kodi.get_kodi_connection",
return_value=MockConnection(),
):
entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
return entry

325
tests/components/kodi/test_config_flow.py Normal file
View File

@ -0,0 +1,325 @@
"""Test the Kodi config flow."""
import pytest
from homeassistant import config_entries
from homeassistant.components.kodi.config_flow import (
CannotConnectError,
InvalidAuthError,
)
from homeassistant.components.kodi.const import DEFAULT_TIMEOUT, DOMAIN
from .util import (
TEST_CREDENTIALS,
TEST_DISCOVERY,
TEST_HOST,
TEST_IMPORT,
TEST_WS_PORT,
UUID,
MockConnection,
)
from tests.async_mock import AsyncMock, patch
from tests.common import MockConfigEntry
@pytest.fixture
async def user_flow(hass):
"""Return a user-initiated flow after filling in host info."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == "form"
assert result["errors"] == {}
result = await hass.config_entries.flow.async_configure(
result["flow_id"], TEST_HOST
)
assert result["type"] == "form"
assert result["errors"] == {}
return result["flow_id"]
@pytest.fixture
async def discovery_flow(hass):
"""Return a discovery flow after confirmation."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": "zeroconf"}, data=TEST_DISCOVERY
)
assert result["type"] == "form"
result = await hass.config_entries.flow.async_configure(result["flow_id"], {})
assert result["type"] == "form"
assert result["errors"] == {}
return result["flow_id"]
async def test_user_flow(hass, user_flow):
"""Test a successful user initiated flow."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping", return_value=True,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
), patch(
"homeassistant.components.kodi.async_setup", return_value=True
) as mock_setup, patch(
"homeassistant.components.kodi.async_setup_entry", return_value=True,
) as mock_setup_entry:
result = await hass.config_entries.flow.async_configure(
user_flow, TEST_CREDENTIALS
)
assert result["type"] == "form"
assert result["errors"] == {}
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], TEST_WS_PORT
)
assert result2["type"] == "create_entry"
assert result2["title"] == TEST_HOST["host"]
assert result2["data"] == {
**TEST_HOST,
**TEST_CREDENTIALS,
**TEST_WS_PORT,
"name": None,
"timeout": DEFAULT_TIMEOUT,
}
await hass.async_block_till_done()
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
async def test_form_invalid_auth(hass, user_flow):
"""Test we handle invalid auth."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping",
side_effect=InvalidAuthError,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result = await hass.config_entries.flow.async_configure(
user_flow, TEST_CREDENTIALS
)
assert result["type"] == "form"
assert result["errors"] == {"base": "invalid_auth"}
async def test_form_cannot_connect_http(hass, user_flow):
"""Test we handle cannot connect over HTTP error."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping",
side_effect=CannotConnectError,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result = await hass.config_entries.flow.async_configure(
user_flow, TEST_CREDENTIALS
)
assert result["type"] == "form"
assert result["errors"] == {"base": "cannot_connect"}
async def test_form_exception_http(hass, user_flow):
"""Test we handle generic exception over HTTP."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping", side_effect=Exception,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result = await hass.config_entries.flow.async_configure(
user_flow, TEST_CREDENTIALS
)
assert result["type"] == "form"
assert result["errors"] == {"base": "unknown"}
async def test_form_cannot_connect_ws(hass, user_flow):
"""Test we handle cannot connect over WebSocket error."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping", return_value=True,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result = await hass.config_entries.flow.async_configure(
user_flow, TEST_CREDENTIALS
)
with patch.object(
MockConnection, "connect", AsyncMock(side_effect=CannotConnectError)
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], TEST_WS_PORT
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "cannot_connect"}
with patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(connected=False),
):
result3 = await hass.config_entries.flow.async_configure(
result2["flow_id"], TEST_WS_PORT
)
assert result3["type"] == "form"
assert result3["errors"] == {"base": "cannot_connect"}
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping",
side_effect=CannotConnectError,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result4 = await hass.config_entries.flow.async_configure(
result3["flow_id"], TEST_WS_PORT
)
assert result4["type"] == "form"
assert result4["errors"] == {"base": "cannot_connect"}
async def test_form_exception_ws(hass, user_flow):
"""Test we handle generic exception over WebSocket."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping", return_value=True,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result = await hass.config_entries.flow.async_configure(
user_flow, TEST_CREDENTIALS
)
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping", side_effect=Exception,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], TEST_WS_PORT
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "unknown"}
async def test_discovery(hass, discovery_flow):
"""Test discovery flow works."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping", return_value=True,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
), patch(
"homeassistant.components.kodi.async_setup", return_value=True
) as mock_setup, patch(
"homeassistant.components.kodi.async_setup_entry", return_value=True,
) as mock_setup_entry:
result = await hass.config_entries.flow.async_configure(
discovery_flow, TEST_CREDENTIALS
)
assert result["type"] == "form"
assert result["errors"] == {}
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], TEST_WS_PORT
)
assert result2["type"] == "create_entry"
assert result2["title"] == "hostname"
assert result2["data"] == {
**TEST_HOST,
**TEST_CREDENTIALS,
**TEST_WS_PORT,
"name": "hostname",
"timeout": DEFAULT_TIMEOUT,
}
await hass.async_block_till_done()
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
async def test_discovery_cannot_connect_http(hass, discovery_flow):
"""Test discovery aborts if cannot connect."""
with patch(
"homeassistant.components.kodi.config_flow.Kodi.ping",
side_effect=CannotConnectError,
), patch(
"homeassistant.components.kodi.config_flow.get_kodi_connection",
return_value=MockConnection(),
):
result = await hass.config_entries.flow.async_configure(
discovery_flow, TEST_CREDENTIALS
)
assert result["type"] == "abort"
assert result["reason"] == "cannot_connect"
async def test_discovery_duplicate_data(hass, discovery_flow):
"""Test discovery aborts if same mDNS packet arrives."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": "zeroconf"}, data=TEST_DISCOVERY
)
assert result["type"] == "abort"
assert result["reason"] == "already_in_progress"
async def test_discovery_updates_unique_id(hass):
"""Test a duplicate discovery id aborts and updates existing entry."""
entry = MockConfigEntry(
domain=DOMAIN,
unique_id=UUID,
data={"host": "dummy", "port": 11, "namename": "dummy.local."},
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": "zeroconf"}, data=TEST_DISCOVERY
)
assert result["type"] == "abort"
assert result["reason"] == "already_configured"
assert entry.data["host"] == "1.1.1.1"
assert entry.data["port"] == 8080
assert entry.data["name"] == "hostname"
async def test_form_import(hass):
"""Test we get the form with import source."""
with patch(
"homeassistant.components.kodi.async_setup", return_value=True
) as mock_setup, patch(
"homeassistant.components.kodi.async_setup_entry", return_value=True,
) as mock_setup_entry:
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_IMPORT}, data=TEST_IMPORT,
)
assert result["type"] == "create_entry"
assert result["title"] == TEST_IMPORT["name"]
assert result["data"] == TEST_IMPORT
await hass.async_block_till_done()
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1

129
tests/components/kodi/test_device_trigger.py Normal file
View File

@ -0,0 +1,129 @@
"""The tests for Kodi device triggers."""
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.kodi import DOMAIN
from homeassistant.components.media_player.const import DOMAIN as MP_DOMAIN
from homeassistant.setup import async_setup_component
from . import init_integration
from tests.common import (
MockConfigEntry,
assert_lists_same,
async_get_device_automations,
async_mock_service,
mock_device_registry,
mock_registry,
)
@pytest.fixture
def device_reg(hass):
"""Return an empty, loaded, registry."""
return mock_device_registry(hass)
@pytest.fixture
def entity_reg(hass):
"""Return an empty, loaded, registry."""
return mock_registry(hass)
@pytest.fixture
def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation")
@pytest.fixture
async def kodi_media_player(hass):
"""Get a kodi media player."""
await init_integration(hass)
return f"{MP_DOMAIN}.name"
async def test_get_triggers(hass, device_reg, entity_reg):
"""Test we get the expected triggers from a kodi."""
config_entry = MockConfigEntry(domain=DOMAIN, data={})
config_entry.add_to_hass(hass)
device_entry = device_reg.async_get_or_create(
config_entry_id=config_entry.entry_id, identifiers={(DOMAIN, "host", 1234)},
)
entity_reg.async_get_or_create(MP_DOMAIN, DOMAIN, "5678", device_id=device_entry.id)
expected_triggers = [
{
"platform": "device",
"domain": DOMAIN,
"type": "turn_off",
"device_id": device_entry.id,
"entity_id": f"{MP_DOMAIN}.kodi_5678",
},
{
"platform": "device",
"domain": DOMAIN,
"type": "turn_on",
"device_id": device_entry.id,
"entity_id": f"{MP_DOMAIN}.kodi_5678",
},
]
triggers = await async_get_device_automations(hass, "trigger", device_entry.id)
assert_lists_same(triggers, expected_triggers)
async def test_if_fires_on_state_change(hass, calls, kodi_media_player):
"""Test for turn_on and turn_off triggers firing."""
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": kodi_media_player,
"type": "turn_on",
},
"action": {
"service": "test.automation",
"data_template": {
"some": ("turn_on - {{ trigger.entity_id }}")
},
},
},
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": kodi_media_player,
"type": "turn_off",
},
"action": {
"service": "test.automation",
"data_template": {
"some": ("turn_off - {{ trigger.entity_id }}")
},
},
},
]
},
)
await hass.services.async_call(
MP_DOMAIN, "turn_on", {"entity_id": kodi_media_player}, blocking=True,
)
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].data["some"] == f"turn_on - {kodi_media_player}"
await hass.services.async_call(
MP_DOMAIN, "turn_off", {"entity_id": kodi_media_player}, blocking=True,
)
await hass.async_block_till_done()
assert len(calls) == 2
assert calls[1].data["some"] == f"turn_off - {kodi_media_player}"

25
tests/components/kodi/test_init.py Normal file
View File

@ -0,0 +1,25 @@
"""Test the Kodi integration init."""
from homeassistant.components.kodi.const import DOMAIN
from homeassistant.config_entries import ENTRY_STATE_LOADED, ENTRY_STATE_NOT_LOADED
from . import init_integration
from tests.async_mock import patch
async def test_unload_entry(hass):
"""Test successful unload of entry."""
with patch(
"homeassistant.components.kodi.media_player.async_setup_entry",
return_value=True,
):
entry = await init_integration(hass)
assert len(hass.config_entries.async_entries(DOMAIN)) == 1
assert entry.state == ENTRY_STATE_LOADED
assert await hass.config_entries.async_unload(entry.entry_id)
await hass.async_block_till_done()
assert entry.state == ENTRY_STATE_NOT_LOADED
assert not hass.data.get(DOMAIN)

67
tests/components/kodi/util.py Normal file
View File

@ -0,0 +1,67 @@
"""Test the Kodi config flow."""
from homeassistant.components.kodi.const import DEFAULT_SSL
TEST_HOST = {
"host": "1.1.1.1",
"port": 8080,
"ssl": DEFAULT_SSL,
}
TEST_CREDENTIALS = {"username": "username", "password": "password"}
TEST_WS_PORT = {"ws_port": 9090}
UUID = "11111111-1111-1111-1111-111111111111"
TEST_DISCOVERY = {
"host": "1.1.1.1",
"port": 8080,
"hostname": "hostname.local.",
"type": "_xbmc-jsonrpc-h._tcp.local.",
"name": "hostname._xbmc-jsonrpc-h._tcp.local.",
"properties": {"uuid": UUID},
}
TEST_IMPORT = {
"name": "name",
"host": "1.1.1.1",
"port": 8080,
"ws_port": 9090,
"username": "username",
"password": "password",
"ssl": True,
"timeout": 7,
}
class MockConnection:
"""A mock kodi connection."""
def __init__(self, connected=True):
"""Mock the Kodi connection."""
self._connected = connected
async def connect(self):
"""Mock connect."""
pass
@property
def connected(self):
"""Mock connected."""
return self._connected
@property
def can_subscribe(self):
"""Mock can_subscribe."""
return False
async def close(self):
"""Mock close."""
pass
@property
def server(self):
"""Mock server."""
return None