Vacuum platform

.dependabot/config.yml

@@ -0,0 +1,19 @@
+version: 1
+update_configs:
+  - package_manager: "python"
+    directory: "/"
+    update_schedule: "live"
+    default_reviewers:
+      - postlund
+      - rospogrigio
+      - ultratoto14
+    default_labels:
+      - dependencies
+    default_assignees:
+      - postlund
+      - rospogrigio
+      - ultratoto14
+    automerged_updates:
+      - match:
+          dependency_type: "all"
+          update_type: "all"

.gitignore

@@ -1,4 +1,5 @@
 *~
 __pycache__
 .tox
-tuyadebug/
+tuyadebug/
+.pre-commit-config.yaml

README.md

@@ -10,9 +10,10 @@ The following Tuya device types are currently supported:
 * Lights
 * Covers
 * Fans
+* Vacuum
 * Climates (soon)
 
-Energy monitoring (voltage, current, watts, etc.) is supported for compatible devices. 
+Energy monitoring (voltage, current, watts, etc.) is supported for compatible devices.
 
 This repository's development has substantially started by utilizing and merging code from NameLessJedi, mileperhour and TradeFace, and then was deeply refactored to provide proper integration with Home Assistant environment, adding config flow and other features. Refer to the "Thanks to" section below.
 
@@ -27,6 +28,9 @@ Alternatively, you can install localtuya through HACS by adding this repository.
 
 **NOTE: You must have your Tuya device's Key and ID in order to use localtuya. There are several ways to obtain the localKey depending on your environment and the devices you own. A good place to start getting info is https://github.com/codetheweb/tuyapi/blob/master/docs/SETUP.md .**
 
+
+**NOTE - Nov 2020: If you plan on integrating these devices on a network that has internet and blocking their internet access, you must block DNS requests too (to the local DNS server eg 192.168.1.1). If you only block outbound internet then the device will sit in zombie state, it will refuse / not respond to any connections with the localkey. Connect the devices first with an active internet connection, grab each device localkey and then implement the block.**
+
 Devices can be configured in two ways:
 
 # 1. YAML config files
@@ -52,11 +56,11 @@ localtuya:
         friendly_name: Device Cover
         id: 2
         open_close_cmds: ["on_off","open_close"] # Optional, default: "on_off"
-        positioning_mode: ["none","position","fake"] # Optional, default: "none"
+        positioning_mode: ["none","position","timed"] # Optional, default: "none"
         currpos_dps: 3 # Optional, required only for "position" mode
         setpos_dps: 4  # Optional, required only for "position" mode
-        span_time: 25  # Full movement time: Optional, required only for "fake" mode
-        
+        span_time: 25  # Full movement time: Optional, required only for "timed" mode
+
       - platform: fan
         friendly_name: Device Fan
         id: 3
@@ -67,11 +71,13 @@ localtuya:
         color_mode: 21 # Optional, usually 2 or 21, default: "none"
         brightness: 22 # Optional, usually 3 or 22, default: "none"
         color_temp: 23 # Optional, usually 4 or 23, default: "none"
-        color: 24 # Optional, usually 5 (RGB_HSV) or 24(HSV), default: "none"
+        color: 24 # Optional, usually 5 (RGB_HSV) or 24 (HSV), default: "none"
         brightness_lower: 29 # Optional, usually 0 or 29, default: 29
         brightness_upper: 1000 # Optional, usually 255 or 1000, default: 1000
         color_temp_min_kelvin: 2700 # Optional, default: 2700
         color_temp_max_kelvin: 6500 # Optional, default: 6500
+        scene: 25 # Optional, usually 6 (RGB_HSV) or 25 (HSV), default: "none"
+        music_mode: False # Optional, some use internal mic, others, phone mic. Only internal mic is supported, default: "False"
 
 
       - platform: sensor
@@ -87,8 +93,22 @@ localtuya:
         current: 18 # Optional
         current_consumption: 19 # Optional
         voltage: 20 # Optional
+
+      - platform: vacuum
+        friendly_name: MyVacuum
+        id: 5
+        commands_set: "smart,standby,chargego"
+        commands_dp: 3
+        idle_status_value: "0"
+        returning_status_value: "4"
+        docked_status_value: "5"
+        battery_dp: 6
+        cleaning_mode_dp: 3
+        cleaning_modes: "smart,random,spiral,wall_follow"
+        fan_speed_dp: 101
+        fan_speeds: "high,nas,low"  
 ```
-   
+
 Note that a single device can contain several different entities. Some examples:
 - a cover device might have 1 (or many) cover entities, plus a switch to control backlight
 - a multi-gang switch will contain several switch entities, one for each gang controlled
@@ -98,12 +118,12 @@ Restart Home Assistant when finished editing.
 # 2. Using config flow
 
 Start by going to Configuration - Integration and pressing the "+" button to create a new Integration, then select LocalTuya in the drop-down menu.
-Wait for 6 seconds for the scanning of the devices in your LAN. Then, a drop-down menu will appear containing the list of detectes devices: you can 
+Wait for 6 seconds for the scanning of the devices in your LAN. Then, a drop-down menu will appear containing the list of detectes devices: you can
 select one of these, or manually input all the parameters.
 
 ![discovery](https://github.com/rospogrigio/localtuya-homeassistant/blob/master/img/1-discovery.png)
 
-If you have selected one entry, you just have to input the Friendly Name of the Device, and the localKey. 
+If you have selected one entry, you just have to input the Friendly Name of the Device, and the localKey.
 Once you press "Submit", the connection will be tested to check that everything works, in order to proceed.
 
 ![device](https://github.com/rospogrigio/localtuya-homeassistant/blob/master/img/2-device.png)
@@ -113,8 +133,8 @@ After you have defined all the needed entities leave the "Do not add more entiti
 
 ![entity_type](https://github.com/rospogrigio/localtuya-homeassistant/blob/master/img/3-entity_type.png)
 
-For each entity, the associated DP has to be selected. All the options requiring to select a DP will provide a drop-down menu showing 
-all the avaliable DPs found on the device (with their current status!!) for an easy identification. Each entity type has different options 
+For each entity, the associated DP has to be selected. All the options requiring to select a DP will provide a drop-down menu showing
+all the avaliable DPs found on the device (with their current status!!) for an easy identification. Each entity type has different options
 to be configured, here is an example for the "switch" entity:
 
 ![entity](https://github.com/rospogrigio/localtuya-homeassistant/blob/master/img/4-entity.png)
@@ -130,23 +150,23 @@ Energy monitoring (voltage, current...) values can be obtained in two different
 1) creating individual sensors, each one with the desired name. Note: Voltage and Consumption usually include the first decimal, so 0.1 as "scaling" parameter shall be used in order to get the correct values.
 2) accessing the voltage/current/current_consumption attributes of a switch, and then defining template sensors like this (please note that in this case the values are already divided by 10 for Voltage and Consumption):
 
-```   
+```
        sensor:
          - platform: template
            sensors:
              tuya-sw01_voltage:
                value_template: >-
                  {{ states.switch.sw01.attributes.voltage }}
-               unit_of_measurement: 'V' 
+               unit_of_measurement: 'V'
              tuya-sw01_current:
-               value_template: >-     
+               value_template: >-
                  {{ states.switch.sw01.attributes.current }}
-               unit_of_measurement: 'mA'      
+               unit_of_measurement: 'mA'
              tuya-sw01_current_consumption:
                value_template: >-
                  {{ states.switch.sw01.attributes.current_consumption }}
-               unit_of_measurement: 'W' 
-```   
+               unit_of_measurement: 'W'
+```
 
 # Debugging
 
@@ -165,9 +185,9 @@ logger:
 
 # To-do list:
 
-* Create a (good and precise) sensor (counter) for Energy (kWh) -not just Power, but based on it-. 
+* Create a (good and precise) sensor (counter) for Energy (kWh) -not just Power, but based on it-.
       Ideas: Use: https://www.home-assistant.io/components/integration/ and https://www.home-assistant.io/components/utility_meter/
-   
+
 * Everything listed in https://github.com/rospogrigio/localtuya-homeassistant/issues/15
 
 # Thanks to:

custom_components/localtuya/__init__.py

@@ -22,11 +22,11 @@
         id: 2
         commands_set: # Optional, default: "on_off_stop"
             ["on_off_stop","open_close_stop","fz_zz_stop","1_2_3"]
-        positioning_mode: ["none","position","fake"] # Optional, default: "none"
+        positioning_mode: ["none","position","timed"] # Optional, default: "none"
         currpos_dp: 3 # Optional, required only for "position" mode
         setpos_dp: 4  # Optional, required only for "position" mode
         position_inverted: [True,False] # Optional, default: False
-        span_time: 25 # Full movement time: Optional, required only for "fake" mode
+        span_time: 25 # Full movement time: Optional, required only for "timed" mode
 
       - platform: fan
         friendly_name: Device Fan
@@ -61,30 +61,51 @@
 """
 import asyncio
 import logging
+from datetime import timedelta
 
+import homeassistant.helpers.config_validation as cv
+import homeassistant.helpers.entity_registry as er
+import voluptuous as vol
 from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
 from homeassistant.const import (
     CONF_DEVICE_ID,
     CONF_ENTITIES,
     CONF_HOST,
+    CONF_ID,
     CONF_PLATFORM,
     EVENT_HOMEASSISTANT_STOP,
     SERVICE_RELOAD,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.reload import async_integration_yaml_config
 
-from .common import TuyaDevice
+from .common import TuyaDevice, async_config_entry_by_device_id
 from .config_flow import config_schema
-from .const import DATA_DISCOVERY, DOMAIN, TUYA_DEVICE
+from .const import CONF_PRODUCT_KEY, DATA_DISCOVERY, DOMAIN, TUYA_DEVICE
 from .discovery import TuyaDiscovery
 
 _LOGGER = logging.getLogger(__name__)
 
 UNSUB_LISTENER = "unsub_listener"
 
+RECONNECT_INTERVAL = timedelta(seconds=60)
+
 CONFIG_SCHEMA = config_schema()
 
+CONF_DP = "dp"
+CONF_VALUE = "value"
+
+SERVICE_SET_DP = "set_dp"
+SERVICE_SET_DP_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_DEVICE_ID): cv.string,
+        vol.Required(CONF_DP): int,
+        vol.Required(CONF_VALUE): object,
+    }
+)
+
 
 @callback
 def _async_update_config_entry_if_from_yaml(hass, entries_by_id, conf):
@@ -122,37 +143,64 @@ async def _handle_reload(service):
 
         await asyncio.gather(*reload_tasks)
 
-    def _entry_by_device_id(device_id):
-        """Look up config entry by device id."""
-        current_entries = hass.config_entries.async_entries(DOMAIN)
-        for entry in current_entries:
-            if entry.data[CONF_DEVICE_ID] == device_id:
-                return entry
-        return None
+    async def _handle_set_dp(event):
+        """Handle set_dp service call."""
+        entry = async_config_entry_by_device_id(hass, event.data[CONF_DEVICE_ID])
+        if not entry:
+            raise HomeAssistantError("unknown device id")
+
+        if entry.entry_id not in hass.data[DOMAIN]:
+            raise HomeAssistantError("device has not been discovered")
+
+        device = hass.data[DOMAIN][entry.entry_id][TUYA_DEVICE]
+        if not device.connected:
+            raise HomeAssistantError("not connected to device")
+
+        await device.set_dp(event.data[CONF_VALUE], event.data[CONF_DP])
 
     def _device_discovered(device):
         """Update address of device if it has changed."""
         device_ip = device["ip"]
         device_id = device["gwId"]
+        product_key = device["productKey"]
 
         # If device is not in cache, check if a config entry exists
         if device_id not in device_cache:
-            entry = _entry_by_device_id(device_id)
+            entry = async_config_entry_by_device_id(hass, device_id)
             if entry:
                 # Save address from config entry in cache to trigger
                 # potential update below
                 device_cache[device_id] = entry.data[CONF_HOST]
 
-        # If device is in cache and address changed...
-        if device_id in device_cache and device_cache[device_id] != device_ip:
-            _LOGGER.debug("Device %s changed IP to %s", device_id, device_ip)
+        if device_id not in device_cache:
+            return
 
-            entry = _entry_by_device_id(device_id)
-            if entry:
-                hass.config_entries.async_update_entry(
-                    entry, data={**entry.data, CONF_HOST: device_ip}
-                )
-                device_cache[device_id] = device_ip
+        entry = async_config_entry_by_device_id(hass, device_id)
+        if entry is None:
+            return
+
+        updates = {}
+
+        if device_cache[device_id] != device_ip:
+            updates[CONF_HOST] = device_ip
+            device_cache[device_id] = device_ip
+
+        if entry.data.get(CONF_PRODUCT_KEY) != product_key:
+            updates[CONF_PRODUCT_KEY] = product_key
+
+        # Update settings if something changed, otherwise try to connect. Updating
+        # settings triggers a reload of the config entry, which tears down the device
+        # so no need to connect in that case.
+        if updates:
+            _LOGGER.debug("Update keys for device %s: %s", device_id, updates)
+            hass.config_entries.async_update_entry(
+                entry, data={**entry.data, **updates}
+            )
+        elif entry.entry_id in hass.data[DOMAIN]:
+            _LOGGER.debug("Device %s found with IP %s", device_id, device_ip)
+
+            device = hass.data[DOMAIN][entry.entry_id][TUYA_DEVICE]
+            device.async_connect()
 
     discovery = TuyaDiscovery(_device_discovered)
 
@@ -164,15 +212,31 @@ def _shutdown(event):
         await discovery.start()
         hass.data[DOMAIN][DATA_DISCOVERY] = discovery
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
-    except Exception:
+    except Exception:  # pylint: disable=broad-except
         _LOGGER.exception("failed to set up discovery")
 
+    async def _async_reconnect(now):
+        """Try connecting to devices not already connected to."""
+        for entry_id, value in hass.data[DOMAIN].items():
+            if entry_id == DATA_DISCOVERY:
+                continue
+
+            device = value[TUYA_DEVICE]
+            if not device.connected:
+                device.async_connect()
+
+    async_track_time_interval(hass, _async_reconnect, RECONNECT_INTERVAL)
+
     hass.helpers.service.async_register_admin_service(
         DOMAIN,
         SERVICE_RELOAD,
         _handle_reload,
     )
 
+    hass.helpers.service.async_register_admin_service(
+        DOMAIN, SERVICE_SET_DP, _handle_set_dp, schema=SERVICE_SET_DP_SCHEMA
+    )
+
     for host_config in config.get(DOMAIN, []):
         hass.async_create_task(
             hass.config_entries.flow.async_init(
@@ -202,7 +266,9 @@ async def setup_entities():
                 for platform in platforms
             ]
         )
-        device.connect()
+        device.async_connect()
+
+    await async_remove_orphan_entities(hass, entry)
 
     hass.async_create_task(setup_entities())
 
@@ -223,7 +289,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
     )
 
     hass.data[DOMAIN][entry.entry_id][UNSUB_LISTENER]()
-    hass.data[DOMAIN][entry.entry_id][TUYA_DEVICE].close()
+    await hass.data[DOMAIN][entry.entry_id][TUYA_DEVICE].close()
     if unload_ok:
         hass.data[DOMAIN].pop(entry.entry_id)
 
@@ -233,3 +299,19 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
 async def update_listener(hass, config_entry):
     """Update listener."""
     await hass.config_entries.async_reload(config_entry.entry_id)
+
+
+async def async_remove_orphan_entities(hass, entry):
+    """Remove entities associated with config entry that has been removed."""
+    ent_reg = await er.async_get_registry(hass)
+    entities = {
+        int(ent.unique_id.split("_")[-1]): ent.entity_id
+        for ent in er.async_entries_for_config_entry(ent_reg, entry.entry_id)
+    }
+
+    for entity in entry.data[CONF_ENTITIES]:
+        if entity[CONF_ID] in entities:
+            del entities[entity[CONF_ID]]
+
+    for entity_id in entities.values():
+        ent_reg.async_remove(entity_id)