Automation: initial state > restore state (#6911)

* Automation: initial state > restore state

* Clean up code

* Ensure MQTT defaults are used.

* Ensure failed platforms always return None

* Automation: write state to state machine after start

homeassistant/components/automation/__init__.py

@@ -82,8 +82,7 @@ _CONDITION_SCHEMA = vol.All(cv.ensure_list, [cv.CONDITION_SCHEMA])
 
 PLATFORM_SCHEMA = vol.Schema({
     CONF_ALIAS: cv.string,
-    vol.Optional(CONF_INITIAL_STATE,
-                 default=DEFAULT_INITIAL_STATE): cv.boolean,
+    vol.Optional(CONF_INITIAL_STATE): cv.boolean,
     vol.Optional(CONF_HIDE_ENTITY, default=DEFAULT_HIDE_ENTITY): cv.boolean,
     vol.Required(CONF_TRIGGER): _TRIGGER_SCHEMA,
     vol.Optional(CONF_CONDITION): _CONDITION_SCHEMA,
@@ -102,15 +101,13 @@ TRIGGER_SERVICE_SCHEMA = vol.Schema({
 RELOAD_SERVICE_SCHEMA = vol.Schema({})
 
 
-def is_on(hass, entity_id=None):
+def is_on(hass, entity_id):
     """
     Return true if specified automation entity_id is on.
 
-    Check all automation if no entity_id specified.
+    Async friendly.
     """
-    entity_ids = [entity_id] if entity_id else hass.states.entity_ids(DOMAIN)
-    return any(hass.states.is_state(entity_id, STATE_ON)
-               for entity_id in entity_ids)
+    return hass.states.is_state(entity_id, STATE_ON)
 
 
 def turn_on(hass, entity_id=None):
@@ -232,7 +229,6 @@ class AutomationEntity(ToggleEntity):
         self._async_detach_triggers = None
         self._cond_func = cond_func
         self._async_action = async_action
-        self._enabled = False
         self._last_triggered = None
         self._hidden = hidden
         self._initial_state = initial_state
@@ -262,24 +258,26 @@ class AutomationEntity(ToggleEntity):
     @property
     def is_on(self) -> bool:
         """Return True if entity is on."""
-        return self._enabled
+        return self._async_detach_triggers is not None
 
     @asyncio.coroutine
     def async_added_to_hass(self) -> None:
         """Startup with initial state or previous state."""
-        enable_automation = False
+        enable_automation = DEFAULT_INITIAL_STATE
 
-        state = yield from async_get_last_state(self.hass, self.entity_id)
-        if state is None:
-            if self._initial_state:
-                enable_automation = True
+        if self._initial_state is not None:
+            enable_automation = self._initial_state
         else:
-            self._last_triggered = state.attributes.get('last_triggered')
-            if state.state == STATE_ON:
-                enable_automation = True
+            state = yield from async_get_last_state(self.hass, self.entity_id)
+            if state:
+                enable_automation = state.state == STATE_ON
+                self._last_triggered = state.attributes.get('last_triggered')
 
-        # HomeAssistant is on bootstrap
-        if enable_automation and self.hass.state == CoreState.not_running:
+        if not enable_automation:
+            return
+
+        # HomeAssistant is starting up
+        elif self.hass.state == CoreState.not_running:
             @asyncio.coroutine
             def async_enable_automation(event):
                 """Start automation on startup."""
@@ -289,27 +287,25 @@ class AutomationEntity(ToggleEntity):
                 EVENT_HOMEASSISTANT_START, async_enable_automation)
 
         # HomeAssistant is running
-        elif enable_automation:
+        else:
             yield from self.async_enable()
 
     @asyncio.coroutine
     def async_turn_on(self, **kwargs) -> None:
         """Turn the entity on and update the state."""
-        if self._enabled:
+        if self.is_on:
             return
 
         yield from self.async_enable()
-        yield from self.async_update_ha_state()
 
     @asyncio.coroutine
     def async_turn_off(self, **kwargs) -> None:
         """Turn the entity off."""
-        if not self._enabled:
+        if not self.is_on:
             return
 
         self._async_detach_triggers()
         self._async_detach_triggers = None
-        self._enabled = False
         yield from self.async_update_ha_state()
 
     @asyncio.coroutine
@@ -335,12 +331,12 @@ class AutomationEntity(ToggleEntity):
 
         This method is a coroutine.
         """
-        if self._enabled:
+        if self.is_on:
             return
 
         self._async_detach_triggers = yield from self._async_attach_triggers(
             self.async_trigger)
-        self._enabled = True
+        yield from self.async_update_ha_state()
 
 
 @asyncio.coroutine
@@ -359,7 +355,7 @@ def _async_process_config(hass, config, component):
                                                                   list_no)
 
             hidden = config_block[CONF_HIDE_ENTITY]
-            initial_state = config_block[CONF_INITIAL_STATE]
+            initial_state = config_block.get(CONF_INITIAL_STATE)
 
             action = _async_get_action(hass, config_block.get(CONF_ACTION, {}),
                                        name)