Notify Alexa when exposed entities change (#24609)

homeassistant/components/cloud/client.py

@@ -6,19 +6,25 @@ from datetime import timedelta
 import logging
 
 import aiohttp
+import async_timeout
 from hass_nabucasa import cloud_api
 from hass_nabucasa.client import CloudClient as Interface
 
 from homeassistant.core import callback
 from homeassistant.components.alexa import (
     config as alexa_config,
+    errors as alexa_errors,
     smart_home as alexa_sh,
+    entities as alexa_entities,
+    state_report as alexa_state_report,
 )
 from homeassistant.components.google_assistant import (
     helpers as ga_h, smart_home as ga)
 from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
+from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.typing import HomeAssistantType
 from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers import entity_registry
 from homeassistant.util.aiohttp import MockRequest
 from homeassistant.util.dt import utcnow
 
@@ -31,6 +37,9 @@ from .prefs import CloudPreferences
 
 
 _LOGGER = logging.getLogger(__name__)
+# Time to wait when entity preferences have changed before syncing it to
+# the cloud.
+SYNC_DELAY = 1
 
 
 class AlexaConfig(alexa_config.AbstractConfig):
@@ -44,7 +53,20 @@ class AlexaConfig(alexa_config.AbstractConfig):
         self._cloud = cloud
         self._token = None
         self._token_valid = None
-        prefs.async_listen_updates(self.async_prefs_updated)
+        self._cur_entity_prefs = prefs.alexa_entity_configs
+        self._alexa_sync_unsub = None
+        self._endpoint = None
+
+        prefs.async_listen_updates(self._async_prefs_updated)
+        hass.bus.async_listen(
+            entity_registry.EVENT_ENTITY_REGISTRY_UPDATED,
+            self._handle_entity_registry_updated
+        )
+
+    @property
+    def enabled(self):
+        """Return if Alexa is enabled."""
+        return self._prefs.alexa_enabled
 
     @property
     def supports_auth(self):
@@ -59,7 +81,10 @@ class AlexaConfig(alexa_config.AbstractConfig):
     @property
     def endpoint(self):
         """Endpoint for report state."""
-        return None
+        if self._endpoint is None:
+            raise ValueError("No endpoint available. Fetch access token first")
+
+        return self._endpoint
 
     @property
     def entity_config(self):
@@ -91,21 +116,143 @@ class AlexaConfig(alexa_config.AbstractConfig):
             if body['reason'] in ('RefreshTokenNotFound', 'UnknownRegion'):
                 raise RequireRelink
 
-            return None
+            return alexa_errors.NoTokenAvailable
 
         self._token = body['access_token']
+        self._endpoint = body['event_endpoint']
         self._token_valid = utcnow() + timedelta(seconds=body['expires_in'])
         return self._token
 
-    async def async_prefs_updated(self, prefs):
+    async def _async_prefs_updated(self, prefs):
         """Handle updated preferences."""
-        if self.should_report_state == self.is_reporting_states:
+        if self.should_report_state != self.is_reporting_states:
+            if self.should_report_state:
+                await self.async_enable_proactive_mode()
+            else:
+                await self.async_disable_proactive_mode()
+
+        # If entity prefs are the same or we have filter in config.yaml,
+        # don't sync.
+        if (self._cur_entity_prefs is prefs.alexa_entity_configs or
+                not self._config[CONF_FILTER].empty_filter):
             return
 
-        if self.should_report_state:
-            await self.async_enable_proactive_mode()
-        else:
-            await self.async_disable_proactive_mode()
+        if self._alexa_sync_unsub:
+            self._alexa_sync_unsub()
+
+        self._alexa_sync_unsub = async_call_later(
+            self.hass, SYNC_DELAY, self._sync_prefs)
+
+    async def _sync_prefs(self, _now):
+        """Sync the updated preferences to Alexa."""
+        self._alexa_sync_unsub = None
+        old_prefs = self._cur_entity_prefs
+        new_prefs = self._prefs.alexa_entity_configs
+
+        seen = set()
+        to_update = []
+        to_remove = []
+
+        for entity_id, info in old_prefs.items():
+            seen.add(entity_id)
+            old_expose = info.get(PREF_SHOULD_EXPOSE)
+
+            if entity_id in new_prefs:
+                new_expose = new_prefs[entity_id].get(PREF_SHOULD_EXPOSE)
+            else:
+                new_expose = None
+
+            if old_expose == new_expose:
+                continue
+
+            if new_expose:
+                to_update.append(entity_id)
+            else:
+                to_remove.append(entity_id)
+
+        # Now all the ones that are in new prefs but never were in old prefs
+        for entity_id, info in new_prefs.items():
+            if entity_id in seen:
+                continue
+
+            new_expose = info.get(PREF_SHOULD_EXPOSE)
+
+            if new_expose is None:
+                continue
+
+            # Only test if we should expose. It can never be a remove action,
+            # as it didn't exist in old prefs object.
+            if new_expose:
+                to_update.append(entity_id)
+
+        # We only set the prefs when update is successful, that way we will
+        # retry when next change comes in.
+        if await self._sync_helper(to_update, to_remove):
+            self._cur_entity_prefs = new_prefs
+
+    async def async_sync_entities(self):
+        """Sync all entities to Alexa."""
+        to_update = []
+        to_remove = []
+
+        for entity in alexa_entities.async_get_entities(self.hass, self):
+            if self.should_expose(entity.entity_id):
+                to_update.append(entity.entity_id)
+            else:
+                to_remove.append(entity.entity_id)
+
+        return await self._sync_helper(to_update, to_remove)
+
+    async def _sync_helper(self, to_update, to_remove) -> bool:
+        """Sync entities to Alexa.
+
+        Return boolean if it was successful.
+        """
+        if not to_update and not to_remove:
+            return True
+
+        tasks = []
+
+        if to_update:
+            tasks.append(alexa_state_report.async_send_add_or_update_message(
+                self.hass, self, to_update
+            ))
+
+        if to_remove:
+            tasks.append(alexa_state_report.async_send_delete_message(
+                self.hass, self, to_remove
+            ))
+
+        try:
+            with async_timeout.timeout(10):
+                await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)
+
+            return True
+
+        except asyncio.TimeoutError:
+            _LOGGER.warning("Timeout trying to sync entitites to Alexa")
+            return False
+
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Error trying to sync entities to Alexa: %s", err)
+            return False
+
+    async def _handle_entity_registry_updated(self, event):
+        """Handle when entity registry updated."""
+        if not self.enabled:
+            return
+
+        action = event.data['action']
+        entity_id = event.data['entity_id']
+        to_update = []
+        to_remove = []
+
+        if action == 'create' and self.should_expose(entity_id):
+            to_update.append(entity_id)
+        elif action == 'remove' and self.should_expose(entity_id):
+            to_remove.append(entity_id)
+
+        await self._sync_helper(to_update, to_remove)
 
 
 class CloudClient(Interface):