binding.py

Go to the documentation of this file.

"""Bridge between emulated_roku and Home Assistant."""
 
import logging
 
from emulated_roku import EmulatedRokuCommandHandler, EmulatedRokuServer
 
from homeassistant.const import EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP
from homeassistant.core import CoreState, EventOrigin
 
LOGGER = logging.getLogger(__package__)
 
EVENT_ROKU_COMMAND = "roku_command"
 
ATTR_COMMAND_TYPE = "type"
ATTR_SOURCE_NAME = "source_name"
ATTR_KEY = "key"
ATTR_APP_ID = "app_id"
 
ROKU_COMMAND_KEYDOWN = "keydown"
ROKU_COMMAND_KEYUP = "keyup"
ROKU_COMMAND_KEYPRESS = "keypress"
ROKU_COMMAND_LAUNCH = "launch"
 
 
class EmulatedRoku:
    """Manages an emulated_roku server."""
 
    def __init__(
        self,
        hass,
        name,
        host_ip,
        listen_port,
        advertise_ip,
        advertise_port,
        upnp_bind_multicast,
    ):
        """Initialize the properties."""
        self.hasshass = hass
 
        self.roku_usnroku_usn = name
        self.host_iphost_ip = host_ip
        self.listen_portlisten_port = listen_port
 
        self.advertise_portadvertise_port = advertise_port
        self.advertise_ipadvertise_ip = advertise_ip
 
        self.bind_multicastbind_multicast = upnp_bind_multicast
 
        self._api_server_api_server = None
 
        self._unsub_start_listener_unsub_start_listener = None
        self._unsub_stop_listener_unsub_stop_listener = None
 
    async def setup(self):
        """Start the emulated_roku server."""
 
        class EventCommandHandler(EmulatedRokuCommandHandler):
            """emulated_roku command handler to turn commands into events."""
 
            def __init__(self, hass):
                self.hasshass = hass
 
            def on_keydown(self, roku_usn, key):
                """Handle keydown event."""
                self.hasshass.bus.async_fire(
                    EVENT_ROKU_COMMAND,
                    {
                        ATTR_SOURCE_NAME: roku_usn,
                        ATTR_COMMAND_TYPE: ROKU_COMMAND_KEYDOWN,
                        ATTR_KEY: key,
                    },
                    EventOrigin.local,
                )
 
            def on_keyup(self, roku_usn, key):
                """Handle keyup event."""
                self.hasshass.bus.async_fire(
                    EVENT_ROKU_COMMAND,
                    {
                        ATTR_SOURCE_NAME: roku_usn,
                        ATTR_COMMAND_TYPE: ROKU_COMMAND_KEYUP,
                        ATTR_KEY: key,
                    },
                    EventOrigin.local,
                )
 
            def on_keypress(self, roku_usn, key):
                """Handle keypress event."""
                self.hasshass.bus.async_fire(
                    EVENT_ROKU_COMMAND,
                    {
                        ATTR_SOURCE_NAME: roku_usn,
                        ATTR_COMMAND_TYPE: ROKU_COMMAND_KEYPRESS,
                        ATTR_KEY: key,
                    },
                    EventOrigin.local,
                )
 
            def launch(self, roku_usn, app_id):
                """Handle launch event."""
                self.hasshass.bus.async_fire(
                    EVENT_ROKU_COMMAND,
                    {
                        ATTR_SOURCE_NAME: roku_usn,
                        ATTR_COMMAND_TYPE: ROKU_COMMAND_LAUNCH,
                        ATTR_APP_ID: app_id,
                    },
                    EventOrigin.local,
                )
 
        LOGGER.debug(
            "Initializing emulated_roku %s on %s:%s",
            self.roku_usnroku_usn,
            self.host_iphost_ip,
            self.listen_portlisten_port,
        )
 
        handler = EventCommandHandler(self.hasshass)
 
        self._api_server_api_server = EmulatedRokuServer(
            self.hasshass.loop,
            handler,
            self.roku_usnroku_usn,
            self.host_iphost_ip,
            self.listen_portlisten_port,
            advertise_ip=self.advertise_ipadvertise_ip,
            advertise_port=self.advertise_portadvertise_port,
            bind_multicast=self.bind_multicastbind_multicast,
        )
 
        async def emulated_roku_stop(event):
            """Wrap the call to emulated_roku.close."""
            LOGGER.debug("Stopping emulated_roku %s", self.roku_usnroku_usn)
            self._unsub_stop_listener_unsub_stop_listener = None
            await self._api_server_api_server.close()
 
        async def emulated_roku_start(event):
            """Wrap the call to emulated_roku.start."""
            try:
                LOGGER.debug("Starting emulated_roku %s", self.roku_usnroku_usn)
                self._unsub_start_listener_unsub_start_listener = None
                await self._api_server_api_server.start()
            except OSError:
                LOGGER.exception(
                    "Failed to start Emulated Roku %s on %s:%s",
                    self.roku_usnroku_usn,
                    self.host_iphost_ip,
                    self.listen_portlisten_port,
                )
                # clean up inconsistent state on errors
                await emulated_roku_stop(None)
            else:
                self._unsub_stop_listener_unsub_stop_listener = self.hasshass.bus.async_listen_once(
                    EVENT_HOMEASSISTANT_STOP, emulated_roku_stop
                )
 
        # start immediately if already running
        if self.hasshass.state is CoreState.running:
            await emulated_roku_start(None)
        else:
            self._unsub_start_listener_unsub_start_listener = self.hasshass.bus.async_listen_once(
                EVENT_HOMEASSISTANT_START, emulated_roku_start
            )
 
        return True
 
    async def unload(self):
        """Unload the emulated_roku server."""
        LOGGER.debug("Unloading emulated_roku %s", self.roku_usnroku_usn)
 
        if self._unsub_start_listener_unsub_start_listener:
            self._unsub_start_listener_unsub_start_listener()
            self._unsub_start_listener_unsub_start_listener = None
 
        if self._unsub_stop_listener_unsub_stop_listener:
            self._unsub_stop_listener_unsub_stop_listener()
            self._unsub_stop_listener_unsub_stop_listener = None
 
        await self._api_server_api_server.close()
 
        return True