async def async_start_event_handler(
hass: HomeAssistantType,
server_host: str,
server_port: int,
requester,
callback_url_override: Optional[str] = None):
"""Register notify view."""
hass_data = hass.data[DLNA_DMR_DATA]
if 'event_handler' in hass_data:
return hass_data['event_handler']
# start event handler
from async_upnp_client.aiohttp import AiohttpNotifyServer
server = AiohttpNotifyServer(requester,
listen_port=server_port,
listen_host=server_host,
loop=hass.loop,
callback_url=callback_url_override)
await server.start_server()
_LOGGER.info('UPNP/DLNA event handler listening, url: %s',
server.callback_url)
hass_data['notify_server'] = server
hass_data['event_handler'] = server.event_handler
# register for graceful shutdown
async def async_stop_server(event):
"""Stop server."""
_LOGGER.debug('Stopping UPNP/DLNA event handler')
await server.stop_server()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_stop_server)
return hass_data['event_handler']
async def async_start_event_handler(
hass: HomeAssistantType,
server_host: str,
server_port: int,
requester,
callback_url_override: str | None = None,
):
"""Register notify view."""
hass_data = hass.data[DLNA_DMR_DATA]
if "event_handler" in hass_data:
return hass_data["event_handler"]
# start event handler
server = AiohttpNotifyServer(
requester,
listen_port=server_port,
listen_host=server_host,
callback_url=callback_url_override,
)
await server.start_server()
_LOGGER.info("UPNP/DLNA event handler listening, url: %s",
server.callback_url)
hass_data["notify_server"] = server
hass_data["event_handler"] = server.event_handler
# register for graceful shutdown
async def async_stop_server(event):
"""Stop server."""
_LOGGER.debug("Stopping UPNP/DLNA event handler")
await server.stop_server()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_stop_server)
return hass_data["event_handler"]
async def subscribe(description_url: str, service_names: Any) -> None:
"""Subscribe to service(s) and output updates."""
global event_handler # pylint: disable=global-statement
device = await create_device(description_url)
# start notify server/event handler
host, port = bind_host_port()
server = AiohttpNotifyServer(device.requester, port, listen_host=host)
await server.start_server()
_LOGGER.debug('Listening on: %s', server.callback_url)
# gather all wanted services
if '*' in service_names:
service_names = device.services.keys()
services = []
for service_name in service_names:
service = service_from_device(device, service_name)
if not service:
print('Unknown service: %s' % (service_name, ))
sys.exit(1)
service.on_event = on_event
services.append(service)
# subscribe to services
event_handler = server.event_handler
for service in services:
await event_handler.async_subscribe(service)
# keep the webservice running
while True:
await asyncio.sleep(120)
await event_handler.async_resubscribe_all()
async def async_start_event_handler(hass, server_host, server_port, requester):
"""Register notify view."""
hass_data = hass.data[DLNA_DMR_DATA]
if 'event_handler' in hass_data:
return hass_data['event_handler']
# start event handler
from async_upnp_client.aiohttp import AiohttpNotifyServer
server = AiohttpNotifyServer(requester, server_port, server_host,
hass.loop)
await server.start_server()
_LOGGER.info('UPNP/DLNA event handler listening on: %s',
server.callback_url)
hass_data['notify_server'] = server
hass_data['event_handler'] = server.event_handler
# register for graceful shutdown
async def async_stop_server(event):
"""Stop server."""
_LOGGER.debug('Stopping UPNP/DLNA event handler')
await server.stop_server()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_stop_server)
return hass_data['event_handler']
async def async_start_event_handler(
opp: OpenPeerPower,
server_host: str,
server_port: int,
requester,
callback_url_override: str | None = None,
):
"""Register notify view."""
opp_data = opp.data[DLNA_DMR_DATA]
if "event_handler" in opp_data:
return opp_data["event_handler"]
# start event handler
server = AiohttpNotifyServer(
requester,
listen_port=server_port,
listen_host=server_host,
callback_url=callback_url_override,
)
await server.start_server()
_LOGGER.info("UPNP/DLNA event handler listening, url: %s",
server.callback_url)
opp_data["notify_server"] = server
opp_data["event_handler"] = server.event_handler
# register for graceful shutdown
async def async_stop_server(event):
"""Stop server."""
_LOGGER.debug("Stopping UPNP/DLNA event handler")
await server.stop_server()
opp.bus.async_listen_once(EVENT_OPENPEERPOWER_STOP, async_stop_server)
return opp_data["event_handler"]
async def subscribe(device: UpnpDevice, subscribe_args):
"""Subscribe to service(s) and output updates."""
global event_handler # pylint: disable=global-statement
# start notify server/event handler
host, port = bind_host_port()
server = AiohttpNotifyServer(device.requester, port, listen_host=host)
await server.start_server()
_LOGGER.debug('Listening on: %s', server.callback_url)
# gather all wanted services
services = []
for service_name in subscribe_args:
if service_name == '*':
services += device.services.values()
continue
service = service_from_device(device, service_name)
service.on_event = on_event
services.append(service)
# subscribe to services
event_handler = server.event_handler
for service in services:
await event_handler.async_subscribe(service)
# keep the webservice running
while True:
await asyncio.sleep(120)
await event_handler.async_resubscribe_all()
async def setup_subscriptions(self):
self.server = AiohttpNotifyServer(self.device.requester, 41234)
await self.server.start_server()
print('Listening on: %s', self.server.callback_url)
await self.subscribe(self.product_service)
await self.subscribe(self.volume_service)
await self.subscribe(self.transport_service)
await self.subscribe(self.info_service)
while True:
await asyncio.sleep(120)
await self.server.event_handler.async_resubscribe_all()
async def async_start_event_handler(
self, server_host: str, server_port: int, requester
):
"""Register notify view."""
if dlna_dmr.event_handler:
return dlna_dmr.event_handler
# start event handler
self.server = AiohttpNotifyServer(
requester,
listen_port=server_port,
listen_host=server_host,
)
await self.server.start_server()
self.logger.info(
"UPNP/DLNA event handler listening, url: %s", self.server.callback_url
)
dlna_dmr.event_handler = self.server.event_handler
return dlna_dmr.event_handler
async def async_get_event_notifier(
self, listen_addr: EventListenAddr,
hass: HomeAssistant) -> UpnpEventHandler:
"""Return existing event notifier for the listen_addr, or create one.
Only one event notify server is kept for each listen_addr. Must call
async_release_event_notifier when done to cleanup resources.
"""
LOGGER.debug("Getting event handler for %s", listen_addr)
async with self.lock:
# Stop all servers when HA shuts down, to release resources on devices
if not self.stop_listener_remove:
self.stop_listener_remove = hass.bus.async_listen_once(
EVENT_HOMEASSISTANT_STOP,
self.async_cleanup_event_notifiers)
# Always increment the reference counter, for existing or new event handlers
self.event_notifier_refs[listen_addr] += 1
# Return an existing event handler if we can
if listen_addr in self.event_notifiers:
return self.event_notifiers[listen_addr].event_handler
# Start event handler
source = (listen_addr.host or "0.0.0.0", listen_addr.port)
server = AiohttpNotifyServer(
requester=self.requester,
source=source,
callback_url=listen_addr.callback_url,
loop=hass.loop,
)
await server.async_start_server()
LOGGER.debug("Started event handler at %s", server.callback_url)
self.event_notifiers[listen_addr] = server
return server.event_handler
