diff --git a/.codespellrc b/.codespellrc
new file mode 100644
index 00000000..f5650ad2
--- /dev/null
+++ b/.codespellrc
@@ -0,0 +1,6 @@
+[codespell]
+# Ref: https://github.com/codespell-project/codespell#using-a-config-file
+skip = .git,.codespellrc,translations,resources.py
+check-hidden = true
+# ignore-regex =
+ignore-words-list = hass,aline,laF,visibile
diff --git a/.github/icons/github.png b/.github/icons/github.png
new file mode 100644
index 00000000..d106b363
Binary files /dev/null and b/.github/icons/github.png differ
diff --git a/.github/icons/kofi.png b/.github/icons/kofi.png
new file mode 100644
index 00000000..5d5a61e3
Binary files /dev/null and b/.github/icons/kofi.png differ
diff --git a/.github/icons/paypal.png b/.github/icons/paypal.png
new file mode 100644
index 00000000..ea2d090d
Binary files /dev/null and b/.github/icons/paypal.png differ
diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml
new file mode 100644
index 00000000..eeaceadf
--- /dev/null
+++ b/.github/workflows/codespell.yml
@@ -0,0 +1,23 @@
+# Codespell configuration is within .codespellrc
+---
+name: Codespell
+
+on:
+ push:
+ branches: [master]
+ pull_request:
+ branches: [master]
+
+permissions:
+ contents: read
+
+jobs:
+ codespell:
+ name: Check for spelling errors
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+ - name: Codespell
+ uses: codespell-project/actions-codespell@v2
diff --git a/.gitignore b/.gitignore
index 9a4eb7e4..4971e50c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,4 +3,5 @@
*.pyproj.user
*.sln
/env
-*.zip
\ No newline at end of file
+*.zip
+.idea
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 965ce9f3..af522179 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,2 +1,2 @@
## Contributing
-To submit your changes please fork this repository and open a pull request.
+To submit your changes please fork this repository and open a pull request to dev branch.
diff --git a/README.md b/README.md
index 9c9345a9..db0d88ef 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-[](https://github.com/Tasshack/dreame-vacuum/releases)
+[](https://github.com/Tasshack/dreame-vacuum/releases)
[](https://github.com/hacs/integration)
@@ -18,110 +18,127 @@ Complete app replacement with Home Assistant for Dreame robot vacuums.
## Features
-- [Auto generated device entities](https://github.com/Tasshack/dreame-vacuum/blob/master/docs/entities.md)
-- [Live and multi floor map support](https://github.com/Tasshack/dreame-vacuum/blob/master/docs/map.md)
-- [Customized room cleaning entities](https://github.com/Tasshack/dreame-vacuum/blob/master/docs/room_entities.md)
-- [Services for device and map with examples](https://github.com/Tasshack/dreame-vacuum/blob/master/docs/services.md)
-- [Persistent notifications and error reporting](https://github.com/Tasshack/dreame-vacuum/blob/master/docs/notifications.md)
-- [Events for automations](https://github.com/Tasshack/dreame-vacuum/blob/master/docs/events.md)
-- [Valetudo map card support](#with-valetudo-map-card)
-
-## Supported Devices
-- **Dreame**
- - `dreame.vacuum.p2008` *(F9)*
- - `dreame.vacuum.p2009` *(D9)*
- - `dreame.vacuum.p2259` *(D9 Max)*
- - `dreame.vacuum.p2187` *(D9 Pro)*
- - `dreame.vacuum.r2205` *(D10 Plus)*
- - `dreame.vacuum.p2029` *(L10 Pro)*
- - `dreame.vacuum.p2028a` *(L10 Plus)*
- - `dreame.vacuum.r2228o` *(L10s Ultra)*
- - `dreame.vacuum.r2215o` *(L10s Pro)*
- - `dreame.vacuum.r2216o` *(L10s Pro)*
- - `dreame.vacuum.p2028` *(Z10 Pro)*
- - `dreame.vacuum.p2027` *(W10)*
- - `dreame.vacuum.r2104` *(W10 Pro)*
- - `dreame.vacuum.r2251o` *(W10s)*
- - `dreame.vacuum.r2232a` *(W10s Pro)*
- - `dreame.vacuum.r2228` *(S10)*
- - `dreame.vacuum.r2211o` *(S10+)*
- - `dreame.vacuum.r2233` *(S10 Pro)*
- - `dreame.vacuum.r2247` *(S10 Pro Plus)*
- - `dreame.vacuum.r2246` *(S10 Plus)*
- - `dreame.vacuum.r2215` *(X10)*
- - `dreame.vacuum.r2235` *(X10 Ultra)*
-- **Mijia**
- - `dreame.vacuum.p2036` *(Trouver LDS Finder)*
- - `dreame.vacuum.p2150o` *(Vacuum-Mop)*
- - `dreame.vacuum.p2150a` *(Vacuum-Mop 2 Ultra)*
- - `dreame.vacuum.p2150b` *(Vacuum-Mop 2 Ultra Set)*
- - `dreame.vacuum.p2114o` *(Self-Cleaning Robot Vacuum-Mop)*
- - `dreame.vacuum.p2149o` *(Self-Cleaning Robot Vacuum-Mop Pro)*
- - `dreame.vacuum.r2254` *(1S)*
- - `dreame.vacuum.r2209` *(X10)*
- - `dreame.vacuum.p2114a` *(X10+)*
- - `dreame.vacuum.p2041` *(1T)*
- - `dreame.vacuum.p2140a` *(2C)*
- - `dreame.vacuum.p2140` *(2C)*
- - `dreame.vacuum.p2140q` *(Mi Robot Vacuum-Mop 2)*
- - `dreame.vacuum.p2140p` *(Mi Robot Vacuum-Mop 2)*
- - `dreame.vacuum.p2140o` *(Mi Robot Vacuum-Mop 2)*
- - `dreame.vacuum.p2148o` *(Mi Robot Vacuum Mop Ultra Slim)*
- - `dreame.vacuum.p2041o` *(Mi Robot Vacuum-Mop 2 Pro+)*
-- **MOVA**
- - `dreame.vacuum.p2157` *(L600)*
- - `dreame.vacuum.p2156o` *(MOVA Z500)*
+- [Supported devices](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/supported_devices.md)
+- [Auto generated device entities](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/entities.md)
+- [Live and multi floor map support](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/map.md)
+- [Map obstacle photos](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/map.md#obstacle-photos)
+- [Cleaning and cruising history maps](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/map.md#cleaning-and-cruising-history-maps)
+- [Cloud and local map backup/recovery](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/map.md#backup-and-recovery)
+- [Saved WiFi coverage maps](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/map.md#wifi-map)
+- [Customized room cleaning entities](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/room_entities.md)
+- [Services for device and map with examples](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/services.md)
+- [Persistent notifications and error reporting](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/notifications.md)
+- [Events for automations](https://github.com/Tasshack/dreame-vacuum/blob/dev/docs/events.md)
+- Dreamehome account support
+- Movahome account support
+
## Installation
-### Manually
+#### Manually
-```sh
-wget -O - https://raw.githubusercontent.com/Tasshack/dreame-vacuum/master/install | bash -
+```bash
+wget -O - https://raw.githubusercontent.com/Tasshack/dreame-vacuum/dev/install | bash -
```
-### Via [HACS](https://hacs.xyz/)
+#### Via [HACS](https://hacs.xyz/)
+
## Configuration
+
- Select configuration type:
- 
-
- About map feature
+ - **Mi Home Account**: TODO
+ - **Dreamehome Account**: TODO
+ - **Local**: TODO
- Enter required credentials according to the selected configuration type.
- > Please make sure that the devices are at same subnet for both configuration types. python-miio article about this issue.
+ > Please make sure that the devices are at same subnet for `Mi Home account` and `Local` configuration types. python-miio article about this issue.
- Set your device name and integration settings:
- 
+ TODO
- About notifications feature
About map color schemes
+ About notifications feature
About map color schemes
- Navigate to device page for disabling or enabling entities that you want to use.
- About entities
-
-## How to Use
+ About entities
+
+## How To Use
Integration is compatible with all available Lovelace vacuum cards but if you want to use zone cleaning feature you can prefer the Xiaomi Vacuum Card.
-#### With [Xiaomi Vacuum Map Card](https://github.com/PiotrMachowski/lovelace-xiaomi-vacuum-map-card)
+#### With Dreame Vacuum Card
+
+*Work in progress... #466*
+
+#### With [Xiaomi Vacuum Map Card](https://github.com/PiotrMachowski/lovelace-xiaomi-vacuum-map-card)
+ > Template for room and zone cleaning.
+
```yaml
+{# ----------------- PROVIDE YOUR OWN ENTITY IDS HERE ----------------- #}
+{% set camera_entity = "camera." %}
+{% set vacuum_entity = "vacuum." %}
+{# ------------------- DO NOT CHANGE ANYTHING BELOW ------------------- #}
+{% set attributes = states[camera_entity].attributes %}
+
type: custom:xiaomi-vacuum-map-card
-entity: # Your vacuum entity
+vacuum_platform: default
+entity: {{ vacuum_entity }}
map_source:
- camera: # Map Entity
+ camera: {{ camera_entity }}
calibration_source:
camera: true
-vacuum_platform: Tasshack/dreame-vacuum
+map_modes:
+ - template: vacuum_clean_zone
+ max_selections: 10
+ repeats_type: EXTERNAL
+ max_repeats: 3
+ service_call_schema:
+ service: dreame_vacuum.vacuum_clean_zone
+ service_data:
+ entity_id: '[[entity_id]]'
+ zone: '[[selection]]'
+ repeats: '[[repeats]]'
+ - template: vacuum_clean_segment
+ repeats_type: EXTERNAL
+ max_repeats: 3
+ service_call_schema:
+ service: dreame_vacuum.vacuum_clean_segment
+ service_data:
+ entity_id: '[[entity_id]]'
+ segments: '[[selection]]'
+ repeats: '[[repeats]]'
+ predefined_selections:
+{%- for room_id in attributes.rooms | default([]) %}
+{%- set room = attributes.rooms[room_id] %}
+ - id: {{room_id}}
+ outline:
+ - - {{room["x0"]}}
+ - {{room["y0"]}}
+ - - {{room["x0"]}}
+ - {{room["y1"]}}
+ - - {{room["x1"]}}
+ - {{room["y1"]}}
+ - - {{room["x1"]}}
+ - {{room["y0"]}}
+{%- endfor %}
+ - name: Clean Spot
+ icon: mdi:map-marker-plus
+ max_repeats: 3
+ selection_type: MANUAL_POINT
+ repeats_type: EXTERNAL
+ service_call_schema:
+ service: dreame_vacuum.vacuum_clean_spot
+ service_data:
+ entity_id: '[[entity_id]]'
+ points: '[[selection]]'
+ repeats: '[[repeats]]'
```
-> Open card editor, click "Generate rooms config" button, check (adjust if needed) your config using yaml editor and save changes.
-
-
#### With [Vacuum Card](https://github.com/denysdovhan/vacuum-card)
```yaml
@@ -145,7 +162,7 @@ stats:
subtitle: Sensors
cleaning:
- attribute: cleaned_area
- unit: m²
+ unit: m2
subtitle: Cleaned area
- attribute: cleaning_time
unit: min
@@ -245,30 +262,28 @@ attributes:
```
-#### With Dreame Vacuum Card
-
-*Coming Soon*
-
## To Do
-- Cleaning history map support
-- Map recovery support
+- Integrated custom lovelace map card
+- Shortcut editing
- Schedule editing
-- AI Obstacle image support
-- Custom lovelace card for map editing
+- Furniture editing
+- DnD editing
+- Live camera streaming
+- Backend translations
## Contributing
-Integrations is currently only available on English language and if want you use it on our language it would be very helpful to you to translate files on *translations* folder and share with us.
-
-To submit your changes please fork this repository and open a pull request.
+To submit your changes please fork `dev` branch of this repository and open a pull request.
## Thanks To
- [xiaomi_vacuum](https://github.com/pooyashahidi/xiaomi_vacuum) by [@pooyashahidi](https://github.com/pooyashahidi)
- [Xiaomi MIoT for Home Assistant](https://github.com/ha0y/xiaomi_miot_raw) by [@ha0y](https://github.com/ha0y)
- [Xiaomi Cloud Map Extractor](https://github.com/PiotrMachowski/Home-Assistant-custom-components-Xiaomi-Cloud-Map-Extractor) by [@PiotrMachowski](https://github.com/PiotrMachowski)
-
+ - Dreame cloud authentication by [@kuudori](https://github.com/kuudori)
+ - Mova cloud help by [@r1si](https://github.com/r1si)
+
## Do not forget to support the project!
@@ -276,4 +291,4 @@ To submit your changes please fork this repository and open a pull request.
-
\ No newline at end of file
+
diff --git a/custom_components/dreame_vacuum/__init__.py b/custom_components/dreame_vacuum/__init__.py
index e9c687c2..838b3b7d 100644
--- a/custom_components/dreame_vacuum/__init__.py
+++ b/custom_components/dreame_vacuum/__init__.py
@@ -1,11 +1,13 @@
"""The Dreame Vacuum component."""
+
from __future__ import annotations
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
-from .const import DOMAIN
-from .coordinator import DreameVacuumDataUpdateCoordinator
+from homeassistant.components.frontend import DATA_EXTRA_MODULE_URL
import warnings
+from pathlib import Path
+from .const import DOMAIN
# Suppress python-miio FutureWarning on Python 3.13
warnings.filterwarnings(
@@ -17,6 +19,8 @@
# Suppress RuntimeWarning overflow encountered in scalar add
warnings.filterwarnings("ignore", category=RuntimeWarning)
+from .coordinator import DreameVacuumDataUpdateCoordinator
+
PLATFORMS = (
Platform.VACUUM,
Platform.SENSOR,
@@ -26,6 +30,7 @@
Platform.NUMBER,
Platform.SELECT,
Platform.CAMERA,
+ Platform.TIME,
)
@@ -36,10 +41,22 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
- entry.async_on_unload(entry.add_update_listener(update_listener))
+ # Register frontend
+ # frontend_js = f"/{DOMAIN}/frontend.js"
+ # if DATA_EXTRA_MODULE_URL not in hass.data:
+ # hass.data[DATA_EXTRA_MODULE_URL] = set()
+ # if frontend_js not in (
+ # hass.data[DATA_EXTRA_MODULE_URL].urls
+ # if hasattr(hass.data[DATA_EXTRA_MODULE_URL], "urls")
+ # else hass.data[DATA_EXTRA_MODULE_URL]
+ # ):
+ # hass.data[DATA_EXTRA_MODULE_URL].add(frontend_js)
+ # hass.http.register_static_path(frontend_js, str(Path(Path(__file__).parent / "frontend.js")), True)
# Set up all platforms for this device/entry.
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+ entry.async_on_unload(entry.add_update_listener(update_listener))
return True
@@ -47,9 +64,9 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload Dreame Vacuum config entry."""
if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
coordinator: DreameVacuumDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
- coordinator.device.listen(None)
- coordinator.device.disconnect()
- del coordinator.device
+ coordinator._device.listen(None)
+ coordinator._device.disconnect()
+ del coordinator._device
coordinator._device = None
del hass.data[DOMAIN][entry.entry_id]
diff --git a/custom_components/dreame_vacuum/binary_sensor.py b/custom_components/dreame_vacuum/binary_sensor.py
index b093204f..3b33208d 100644
--- a/custom_components/dreame_vacuum/binary_sensor.py
+++ b/custom_components/dreame_vacuum/binary_sensor.py
@@ -5,6 +5,7 @@
from dataclasses import dataclass
from homeassistant.components.binary_sensor import (
+ ENTITY_ID_FORMAT,
BinarySensorEntity,
BinarySensorEntityDescription,
BinarySensorDeviceClass,
@@ -17,7 +18,8 @@
from .const import DOMAIN
from .coordinator import DreameVacuumDataUpdateCoordinator
-from .entity import DreameVacuumEntity, DreameVacuumEntityDescription
+from .entity import DreameVacuumEntity, DreameVacuumEntityDescription, remove_entities
+from .dreame import DreameVacuumProperty
@dataclass
@@ -26,10 +28,9 @@ class DreameVacuumBinarySensorEntityDescription(DreameVacuumEntityDescription, B
BINARY_SENSORS: tuple[BinarySensorEntityDescription, ...] = (
- ## This entity is need for battery icon to be rendered correctly since vacuum entity attr_charging attribute has been deprecated
+ ## This entity is required for battery icon to be rendered correctly since vacuum entity attr_charging attribute has been deprecated
DreameVacuumBinarySensorEntityDescription(
key="charging_state",
- name="Charging State",
device_class=BinarySensorDeviceClass.BATTERY_CHARGING,
icon_fn=lambda value, device: (
"mdi:power-plug-battery"
@@ -38,6 +39,22 @@ class DreameVacuumBinarySensorEntityDescription(DreameVacuumEntityDescription, B
),
value_fn=lambda value, device: device.status.charging,
),
+ DreameVacuumBinarySensorEntityDescription(
+ property_key=DreameVacuumProperty.ROLLER_COVER_STATUS,
+ icon_fn=lambda value, device: "mdi:circle-off-outline" if bool(value) else "mdi:circle-outline",
+ device_class=BinarySensorDeviceClass.DOOR,
+ value_fn=lambda value, device: not bool(value),
+ exists_fn=lambda description, device: bool(device.capability.roller_cover),
+ ),
+ DreameVacuumBinarySensorEntityDescription(
+ key="lds_status",
+ name="LDS Status",
+ property_key=DreameVacuumProperty.LDS_STATE,
+ icon_fn=lambda value, device: "mdi:upload-circle" if bool(value) else "mdi:download-circle",
+ device_class=BinarySensorDeviceClass.OPENING,
+ value_fn=lambda value, device: bool(value),
+ exists_fn=lambda description, device: bool(device.capability.auto_lds_lifting),
+ ),
)
@@ -48,6 +65,8 @@ async def async_setup_entry(
) -> None:
"""Set up Dreame Vacuum Binary Sensor based on a config entry."""
coordinator: DreameVacuumDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+
+ remove_entities(hass, entry, coordinator, "binary_sensor", BINARY_SENSORS)
async_add_entities(
DreameVacuumBinarySensorEntity(coordinator, description)
for description in BINARY_SENSORS
@@ -65,6 +84,7 @@ def __init__(
) -> None:
"""Initialize a Dreame Vacuum BinarySensor entity."""
super().__init__(coordinator, description)
+ self._generate_entity_id(ENTITY_ID_FORMAT)
@property
def is_on(self) -> bool | None:
diff --git a/custom_components/dreame_vacuum/button.py b/custom_components/dreame_vacuum/button.py
index d934201d..a2159d17 100644
--- a/custom_components/dreame_vacuum/button.py
+++ b/custom_components/dreame_vacuum/button.py
@@ -5,22 +5,26 @@
from typing import Any
from dataclasses import dataclass
from collections.abc import Callable
+from functools import partial
+import copy
from homeassistant.components.button import (
+ ENTITY_ID_FORMAT,
ButtonEntity,
ButtonEntityDescription,
)
from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import EntityCategory
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity import EntityCategory, async_generate_entity_id
from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers import entity_registry
from homeassistant.exceptions import HomeAssistantError
from .const import DOMAIN
from .coordinator import DreameVacuumDataUpdateCoordinator
-from .entity import DreameVacuumEntity, DreameVacuumEntityDescription
+from .entity import DreameVacuumEntity, DreameVacuumEntityDescription, remove_entities
from .dreame import DreameVacuumAction
@@ -28,7 +32,6 @@
class DreameVacuumButtonEntityDescription(DreameVacuumEntityDescription, ButtonEntityDescription):
"""Describes Dreame Vacuum Button entity."""
- parameters_fn: Callable[[object], Any] = None
action_fn: Callable[[object]] = None
@@ -63,17 +66,16 @@ class DreameVacuumButtonEntityDescription(DreameVacuumEntityDescription, ButtonE
action_key=DreameVacuumAction.RESET_SENSOR,
icon="mdi:radar",
entity_category=EntityCategory.DIAGNOSTIC,
- exists_fn=lambda description, device: bool(
- DreameVacuumEntityDescription().exists_fn(description, device)
- and device.status.sensor_dirty_life is not None
- ),
+ exists_fn=lambda description, device: not device.capability.disable_sensor_cleaning,
),
DreameVacuumButtonEntityDescription(
action_key=DreameVacuumAction.RESET_MOP_PAD,
icon="mdi:hydro-power",
entity_category=EntityCategory.DIAGNOSTIC,
exists_fn=lambda description, device: bool(
- DreameVacuumEntityDescription().exists_fn(description, device) and device.status.mop_life is not None
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and not device.capability.disable_mop_consumable
+ and device.status.mop_life is not None
),
),
DreameVacuumButtonEntityDescription(
@@ -90,7 +92,96 @@ class DreameVacuumButtonEntityDescription(DreameVacuumEntityDescription, ButtonE
icon="mdi:chart-bubble",
entity_category=EntityCategory.DIAGNOSTIC,
exists_fn=lambda description, device: bool(
- DreameVacuumEntityDescription().exists_fn(description, device) and device.status.detergent_life is not None
+ DreameVacuumEntityDescription().exists_fn(description, device) and device.capability.detergent
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_SQUEEGEE,
+ icon="mdi:squeegee",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.squeegee
+ and device.status.squeegee_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_ONBOARD_DIRTY_WATER_TANK,
+ icon="mdi:train-car-tank",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.onboard_dirty_water_tank
+ and device.status.onboard_dirty_water_tank_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_DIRTY_WATER_CHANNEL,
+ icon="mdi:cup",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.status.dirty_water_channel_dirty_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_DEODORIZER,
+ icon="mdi:scent",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.deodorizer
+ and device.status.deodorizer_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_SCALE_INHIBITOR,
+ icon="mdi:pipe",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.scale_inhibitor
+ and device.status.scale_inhibitor_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_WHEEL,
+ icon="mdi:tire",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.wheel
+ and device.status.wheel_dirty_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_FLUFFING_ROLLER,
+ icon="mdi:blinds-open",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.fluffing_roller
+ and device.status.fluffing_roller_dirty_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_ROLLER_MOP_FILTER,
+ icon="mdi:filter-settings",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.roller_mop_filter
+ and device.status.roller_mop_filter_dirty_life is not None
+ ),
+ ),
+ DreameVacuumButtonEntityDescription(
+ action_key=DreameVacuumAction.RESET_WATER_OUTLET_FILTER,
+ icon="mdi:filter-settings",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ exists_fn=lambda description, device: bool(
+ DreameVacuumEntityDescription().exists_fn(description, device)
+ and device.capability.water_outlet_filter
+ and device.status.water_outlet_filter_dirty_life is not None
),
),
DreameVacuumButtonEntityDescription(
@@ -101,63 +192,106 @@ class DreameVacuumButtonEntityDescription(DreameVacuumEntityDescription, ButtonE
else "mdi:delete-restore" if device.status.auto_emptying else "mdi:delete-empty"
),
exists_fn=lambda description, device: bool(
- DreameVacuumEntityDescription().exists_fn(description, device) and device.status.auto_empty_base_available
+ DreameVacuumEntityDescription().exists_fn(description, device) and device.capability.auto_empty_base
),
),
DreameVacuumButtonEntityDescription(
action_key=DreameVacuumAction.CLEAR_WARNING,
icon="mdi:clipboard-check-outline",
entity_category=EntityCategory.DIAGNOSTIC,
- parameters_fn=lambda device: [device.status.error.value],
+ action_fn=lambda device: device.clear_warning(),
+ available_fn=lambda device: device.status.has_warning
+ or device.status.low_water
+ or device.status.draining_complete,
),
DreameVacuumButtonEntityDescription(
key="start_fast_mapping",
icon="mdi:map-plus",
entity_category=EntityCategory.CONFIG,
- available_fn=lambda device: device.status.mapping_available,
action_fn=lambda device: device.start_fast_mapping(),
- exists_fn=lambda description, device: device.status.lidar_navigation,
+ exists_fn=lambda description, device: device.capability.lidar_navigation,
),
DreameVacuumButtonEntityDescription(
key="start_mapping",
icon="mdi:broom",
entity_category=EntityCategory.CONFIG,
- available_fn=lambda device: device.status.mapping_available,
action_fn=lambda device: device.start_mapping(),
entity_registry_enabled_default=False,
- exists_fn=lambda description, device: device.status.lidar_navigation,
+ exists_fn=lambda description, device: device.capability.lidar_navigation,
),
DreameVacuumButtonEntityDescription(
- name="Self-Clean",
key="self_clean",
- icon="mdi:washing-machine",
- available_fn=lambda device: bool(
- device.status.washing_available or device.status.returning_to_wash_paused or device.status.washing_paused
+ icon_fn=lambda value, device: (
+ "mdi:dishwasher-off"
+ if not device.status.washing_paused and (device.status.washing or not device.status.washing_available)
+ else "mdi:dishwasher"
+ ),
+ action_fn=lambda device: device.toggle_washing(),
+ exists_fn=lambda description, device: device.capability.self_wash_base,
+ ),
+ DreameVacuumButtonEntityDescription(
+ key="manual_drying",
+ icon_fn=lambda value, device: (
+ "mdi:weather-sunny-off"
+ if device.status.drying or not device.status.drying_available
+ else "mdi:weather-sunny"
),
- action_fn=lambda device: device.start_washing(),
- exists_fn=lambda description, device: device.status.self_wash_base_available,
+ action_fn=lambda device: device.toggle_drying(),
+ exists_fn=lambda description, device: device.capability.self_wash_base,
+ ),
+ DreameVacuumButtonEntityDescription(
+ key="manual_dust_bag_drying",
+ icon_fn=lambda value, device: (
+ "mdi:fire-off"
+ if device.status.dust_bag_drying or not device.status.dust_bag_drying_available or device.status.drying
+ else "mdi:fire"
+ ),
+ action_fn=lambda device: device.toggle_dust_bag_drying(),
+ exists_fn=lambda description, device: device.capability.dust_bag_drying
+ or device.capability.manual_dust_bag_drying,
+ ),
+ DreameVacuumButtonEntityDescription(
+ key="water_tank_draining",
+ icon="mdi:pump",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ action_fn=lambda device: device.start_draining(),
+ exists_fn=lambda description, device: device.capability.drainage,
+ ),
+ DreameVacuumButtonEntityDescription(
+ key="empty_water_tank",
+ icon="mdi:waves-arrow-up",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ action_fn=lambda device: device.start_draining(True),
+ exists_fn=lambda description, device: device.capability.water_tank_draining,
),
DreameVacuumButtonEntityDescription(
- name="Self-Clean Pause",
- key="self_clean_pause",
- icon="mdi:washing-machine-off",
- available_fn=lambda device: device.status.washing,
- action_fn=lambda device: device.pause_washing(),
- exists_fn=lambda description, device: device.status.self_wash_base_available,
+ key="base_station_self_repair",
+ icon_fn=lambda value, device: "mdi:wrench-clock" if device.status.self_repairing else "mdi:wrench-cog",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ action_fn=lambda device: device.start_self_repairing(),
+ exists_fn=lambda description, device: device.capability.self_wash_base,
),
DreameVacuumButtonEntityDescription(
- key="start_drying",
- icon="mdi:weather-sunny",
- available_fn=lambda device: bool(device.status.drying_available and not device.status.drying),
- action_fn=lambda device: device.start_drying(),
- exists_fn=lambda description, device: device.status.self_wash_base_available,
+ key="base_station_cleaning",
+ icon="mdi:car-wash",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ action_fn=lambda device: device.start_station_cleaning(),
+ exists_fn=lambda description, device: device.capability.station_cleaning,
),
DreameVacuumButtonEntityDescription(
- key="stop_drying",
- icon="mdi:weather-sunny-off",
- available_fn=lambda device: bool(device.status.drying_available and device.status.drying),
- action_fn=lambda device: device.stop_drying(),
- exists_fn=lambda description, device: device.status.self_wash_base_available,
+ key="start_recleaning",
+ name="Start Re-Cleaning",
+ icon="mdi:refresh-circle",
+ entity_category=None,
+ action_fn=lambda device: device.start_recleaning(),
+ exists_fn=lambda description, device: device.capability.auto_recleaning and device.capability.map,
+ ),
+ DreameVacuumButtonEntityDescription(
+ key="reload_shortcuts",
+ icon="mdi:motion-play-outline",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ action_fn=lambda device: device.reload_shortcuts(),
+ exists_fn=lambda description, device: device.capability.shortcuts,
),
)
@@ -169,12 +303,95 @@ async def async_setup_entry(
) -> None:
"""Set up Dreame Vacuum Button based on a config entry."""
coordinator: DreameVacuumDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+
+ remove_entities(hass, entry, coordinator, "button", BUTTONS)
async_add_entities(
DreameVacuumButtonEntity(coordinator, description)
for description in BUTTONS
if description.exists_fn(description, coordinator.device)
)
+ if coordinator.device.capability.shortcuts or coordinator.device.capability.backup_map:
+ update_buttons = partial(async_update_buttons, coordinator, {}, {}, async_add_entities)
+ coordinator.async_add_listener(update_buttons)
+ update_buttons()
+
+
+@callback
+def async_update_buttons(
+ coordinator: DreameVacuumDataUpdateCoordinator,
+ current_shortcut: dict[str, list[DreameVacuumShortcutButtonEntity]],
+ current_map: dict[str, list[DreameVacuumMapButtonEntity]],
+ async_add_entities,
+) -> None:
+ new_entities = []
+ if coordinator.device.capability.shortcuts:
+ if coordinator.device.status.shortcuts:
+ new_ids = set([k for k, v in coordinator.device.status.shortcuts.items()])
+ else:
+ new_ids = set([])
+
+ current_ids = set(current_shortcut)
+
+ for shortcut_id in current_ids - new_ids:
+ async_remove_buttons(shortcut_id, coordinator, current_shortcut)
+
+ for shortcut_id in new_ids - current_ids:
+ current_shortcut[shortcut_id] = [
+ DreameVacuumShortcutButtonEntity(
+ coordinator,
+ DreameVacuumButtonEntityDescription(
+ key="shortcut",
+ icon="mdi:play-speed",
+ available_fn=lambda device: not device.status.started
+ and not device.status.shortcut_task
+ and not device.status.draining
+ and not device.status.self_repairing,
+ ),
+ shortcut_id,
+ )
+ ]
+ new_entities = new_entities + current_shortcut[shortcut_id]
+
+ if coordinator.device.capability.backup_map:
+ new_indexes = set([k for k in range(1, len(coordinator.device.status.map_list) + 1)])
+ current_ids = set(current_map)
+
+ for map_index in current_ids - new_indexes:
+ async_remove_buttons(map_index, coordinator, current_map)
+
+ for map_index in new_indexes - current_ids:
+ current_map[map_index] = [
+ DreameVacuumMapButtonEntity(
+ coordinator,
+ DreameVacuumButtonEntityDescription(
+ key="backup",
+ icon="mdi:content-save",
+ entity_category=EntityCategory.DIAGNOSTIC,
+ available_fn=lambda device: not device.status.started and not device.status.map_backup_status,
+ ),
+ map_index,
+ )
+ ]
+
+ new_entities = new_entities + current_map[map_index]
+
+ if new_entities:
+ async_add_entities(new_entities)
+
+
+def async_remove_buttons(
+ id: str,
+ coordinator: DreameVacuumDataUpdateCoordinator,
+ current: dict[str, DreameVacuumButtonEntity],
+) -> None:
+ registry = entity_registry.async_get(coordinator.hass)
+ entities = current[id]
+ for entity in entities:
+ if entity.entity_id in registry.entities:
+ registry.async_remove(entity.entity_id)
+ del current[id]
+
class DreameVacuumButtonEntity(DreameVacuumEntity, ButtonEntity):
"""Defines a Dreame Vacuum Button entity."""
@@ -186,26 +403,145 @@ def __init__(
) -> None:
"""Initialize a Dreame Vacuum Button entity."""
super().__init__(coordinator, description)
+ self._generate_entity_id(ENTITY_ID_FORMAT)
async def async_press(self, **kwargs: Any) -> None:
"""Press the button."""
if not self.available:
raise HomeAssistantError("Entity unavailable")
- parameters = None
- if self.entity_description.parameters_fn is not None:
- parameters = self.entity_description.parameters_fn(self.device)
-
- if self.entity_description.action_key is not None:
+ if self.entity_description.action_fn is not None:
await self._try_command(
"Unable to call %s",
- self.device.call_action,
- self.entity_description.action_key,
- parameters,
+ self.entity_description.action_fn,
+ self.device,
)
- elif self.entity_description.action_fn is not None:
+ elif self.entity_description.action_key is not None:
await self._try_command(
"Unable to call %s",
- self.entity_description.action_fn,
- self.device,
+ self.device.call_action,
+ self.entity_description.action_key,
)
+
+
+class DreameVacuumShortcutButtonEntity(DreameVacuumEntity, ButtonEntity):
+ """Defines a Dreame Vacuum Shortcut Button entity."""
+
+ def __init__(
+ self,
+ coordinator: DreameVacuumDataUpdateCoordinator,
+ description: DreameVacuumButtonEntityDescription,
+ shortcut_id: int,
+ ) -> None:
+ """Initialize a Dreame Vacuum Shortcut Button entity."""
+ self.shortcut_id = shortcut_id
+ self.shortcut = None
+ self.shortcuts = None
+ if coordinator.device and coordinator.device.status.shortcuts:
+ self.shortcuts = copy.deepcopy(coordinator.device.status.shortcuts)
+ self.shortcut = self.shortcuts.get(self.shortcut_id)
+
+ super().__init__(coordinator, description)
+ self.id = shortcut_id
+ if self.id == 25:
+ self.id = 0
+ elif self.id >= 32:
+ self.id = self.id - 31
+ self._attr_unique_id = f"{self.device.mac}_shortcut_{self.id}"
+ self.entity_id = async_generate_entity_id(
+ ENTITY_ID_FORMAT, f"{self.device.name}_shortcut_{self.id}", hass=self.coordinator.hass
+ )
+
+ def _set_id(self) -> None:
+ """Set name of the entity"""
+ key = "shortcut"
+ if self.shortcut:
+ name = self.shortcut.name
+ if name.lower().startswith(key):
+ name = name[8:]
+ name = f"{key}_{name}"
+ else:
+ name = f"{key}_{self.id}"
+
+ self._attr_name = name.replace("_", " ").title()
+
+ @callback
+ def _handle_coordinator_update(self) -> None:
+ if self.shortcuts != self.device.status.shortcuts:
+ self.shortcuts = copy.deepcopy(self.device.status.shortcuts)
+ if self.shortcuts and self.shortcut_id in self.shortcuts:
+ if self.shortcut != self.shortcuts[self.shortcut_id]:
+ self.shortcut = self.shortcuts[self.shortcut_id]
+ self._set_id()
+ elif self.shortcut:
+ self.shortcut = None
+ self._set_id()
+
+ self.async_write_ha_state()
+
+ @property
+ def extra_state_attributes(self) -> dict[str, str] | None:
+ """Return the extra state attributes of the entity."""
+ return self.shortcut.as_dict() if self.shortcut else None
+
+ async def async_press(self, **kwargs: Any) -> None:
+ """Press the button."""
+ if not self.available:
+ raise HomeAssistantError("Entity unavailable")
+
+ await self._try_command(
+ "Unable to call %s",
+ self.device.start_shortcut,
+ self.shortcut_id,
+ )
+
+
+class DreameVacuumMapButtonEntity(DreameVacuumEntity, ButtonEntity):
+ """Defines a Dreame Vacuum Map Button entity."""
+
+ def __init__(
+ self,
+ coordinator: DreameVacuumDataUpdateCoordinator,
+ description: DreameVacuumButtonEntityDescription,
+ map_index: int,
+ ) -> None:
+ """Initialize a Dreame Vacuum Map Button entity."""
+ self.map_index = map_index
+ map_data = coordinator.device.get_map(self.map_index)
+ self._map_name = map_data.custom_name if map_data else None
+ super().__init__(coordinator, description)
+ self._set_id()
+ self._attr_unique_id = f"{self.device.mac}_backup_map_{self.map_index}"
+ self.entity_id = async_generate_entity_id(
+ ENTITY_ID_FORMAT, f"{self.device.name}_backup_map_{self.map_index}", hass=self.coordinator.hass
+ )
+
+ def _set_id(self) -> None:
+ """Set name of the entity"""
+ name = (
+ f"{self.map_index}"
+ if self._map_name is None
+ else f"{self._map_name.replace('_', ' ').replace('-', ' ').title()}"
+ )
+ self._attr_name = f"Backup Saved Map {name}"
+
+ @callback
+ def _handle_coordinator_update(self) -> None:
+ if self.device:
+ map_data = self.device.get_map(self.map_index)
+ if map_data and self._map_name != map_data.custom_name:
+ self._map_name = map_data.custom_name
+ self._set_id()
+
+ self.async_write_ha_state()
+
+ async def async_press(self, **kwargs: Any) -> None:
+ """Press the button."""
+ if not self.available:
+ raise HomeAssistantError("Entity unavailable")
+
+ await self._try_command(
+ "Unable to call %s",
+ self.device.backup_map,
+ self.device.get_map().map_id,
+ )
diff --git a/custom_components/dreame_vacuum/camera.py b/custom_components/dreame_vacuum/camera.py
index a6533fb1..8d837290 100644
--- a/custom_components/dreame_vacuum/camera.py
+++ b/custom_components/dreame_vacuum/camera.py
@@ -1,56 +1,371 @@
from __future__ import annotations
import collections
+from enum import IntEnum
import time
import asyncio
-from typing import Any, Dict
+import traceback
+import gzip
+from typing import Any, Dict, Final
from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timedelta
from functools import partial
from aiohttp import web
-from homeassistant.components.camera import Camera, CameraEntityDescription, ENTITY_ID_FORMAT
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.components.camera import (
+ Camera,
+ CameraEntityDescription,
+ CameraView,
+ ENTITY_ID_FORMAT,
+ DEFAULT_CONTENT_TYPE,
+ TOKEN_CHANGE_INTERVAL,
+)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_UNAVAILABLE, CONTENT_TYPE_MULTIPART
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity import EntityCategory, async_generate_entity_id
from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_platform, entity_registry
+from .recorder import CAMERA_UNRECORDED_ATTRIBUTES
from .const import (
DOMAIN,
CONF_COLOR_SCHEME,
CONF_ICON_SET,
CONF_HIDDEN_MAP_OBJECTS,
- ATTR_CALIBRATION,
- CONTENT_TYPE,
+ CONF_LOW_RESOLUTION,
+ CONF_SQUARE,
+ MAP_OBJECTS,
LOGGER,
)
from .coordinator import DreameVacuumDataUpdateCoordinator
from .entity import DreameVacuumEntity, DreameVacuumEntityDescription
-from .dreame.map import DreameVacuumMapRenderer, DreameVacuumMapDataRenderer
+from .dreame.const import (
+ STATE_UNKNOWN,
+ STATUS_CODE_TO_NAME,
+ ATTR_CALIBRATION,
+ ATTR_SELECTED,
+ ATTR_CLEANING_HISTORY_PICTURE,
+ ATTR_CRUISING_HISTORY_PICTURE,
+ ATTR_OBSTACLE_PICTURE,
+ ATTR_RECOVERY_MAP_PICTURE,
+ ATTR_RECOVERY_MAP_FILE,
+ ATTR_WIFI_MAP_PICTURE,
+ ATTR_MAP_ID,
+ ATTR_SAVED_MAP_ID,
+ ATTR_COLOR_SCHEME,
+)
+from .dreame.types import MAP_ICON_SET_LIST
+from .dreame.map import (
+ DreameVacuumMapRenderer,
+ DreameVacuumMapDataJsonRenderer,
+)
+
+DREAME_TOKEN_CHANGE_INTERVAL: Final = timedelta(minutes=60)
+
+JSON_CONTENT_TYPE: Final = "application/json"
+PNG_CONTENT_TYPE: Final = "image/png"
+
+MAP_IMAGE_URL: Final = "/api/camera_proxy/{0}?token={1}&v={2}"
+HISTORY_MAP_IMAGE_URL: Final = "/api/camera_history_map_proxy/{0}?token={1}&index={2}&v={3}"
+OBSTACLE_IMAGE_URL: Final = "/api/camera_map_obstacle_proxy/{0}?token={1}&index={2}&v={3}"
+RECOVERY_MAP_IMAGE_URL: Final = "/api/camera_recovery_map_proxy/{0}?token={1}&index={2}&v={3}"
+WIFI_MAP_IMAGE_URL: Final = "/api/camera_wifi_map_proxy/{0}?token={1}&v={2}"
+
+
+class DreameVacuumMapType(IntEnum):
+ FLOOR_MAP = 0
+ WIFI_MAP = 1
+ JSON_MAP_DATA = 2
@dataclass
class DreameVacuumCameraEntityDescription(DreameVacuumEntityDescription, CameraEntityDescription):
"""Describes Dreame Vacuum Camera entity."""
- map_data_json: bool = False
+ map_type: DreameVacuumMapType = DreameVacuumMapType.FLOOR_MAP
+
+MAP_ICON = "mdi:map"
CAMERAS: tuple[CameraEntityDescription, ...] = (
- DreameVacuumCameraEntityDescription(key="map", icon="mdi:map"),
+ DreameVacuumCameraEntityDescription(key="map", icon=MAP_ICON),
DreameVacuumCameraEntityDescription(
key="map_data",
- icon="mdi:map",
+ icon=MAP_ICON,
entity_category=EntityCategory.CONFIG,
- map_data_json=True,
+ map_type=DreameVacuumMapType.JSON_MAP_DATA,
entity_registry_enabled_default=False,
),
)
+class CameraDataView(CameraView):
+ """Camera view to serve the map data."""
+
+ url = "/api/camera_map_data_proxy/{entity_id}"
+ name = "api:camera:map_data"
+
+ async def handle(self, request: web.Request, camera: Camera) -> web.Response:
+ """Serve camera data."""
+ resources = request.query.get("resources")
+ saved = request.query.get("saved")
+ file = False
+ object_name = None
+ if saved and (saved == True or saved == "true" or saved == "1"):
+ index = request.query.get("index")
+ if str(index).isnumeric():
+ recovery = request.query.get("recovery")
+ if recovery and (recovery == True or recovery == "true" or recovery == "1"):
+ recovery_index = request.query.get("recovery_index")
+ if str(recovery_index).isnumeric():
+ file = request.query.get("file")
+ file = file and (file == True or file == "true" or file == "1")
+ data, map_url, object_name = await camera.recovery_map_data_string(
+ index,
+ recovery_index,
+ resources and (resources == True or resources == "true" or resources == "1"),
+ file,
+ )
+ else:
+ data = await camera.saved_map_data_string(
+ index, resources and (resources == True or resources == "true" or resources == "1")
+ )
+ else:
+ data = camera.map_data_string(resources and (resources == True or resources == "true" or resources == "1"))
+
+ if data:
+ response = web.Response(
+ body=(
+ data
+ if file
+ else gzip.compress(
+ bytes(
+ data,
+ "utf-8",
+ )
+ )
+ ),
+ content_type=JSON_CONTENT_TYPE,
+ )
+
+ if object_name:
+ response.content_type = "application/x-tar+gzip"
+ response.headers["Content-Disposition"] = (
+ f'attachment; filename={object_name.replace("/", "-").replace(".mb.tbz2", "")}.mb.tbz2'
+ )
+ else:
+ response.headers["Content-Encoding"] = "gzip"
+ return response
+ raise web.HTTPNotFound()
+
+
+class CameraObstacleView(CameraView):
+ """Camera view to serve the map data obstacle image."""
+
+ url = "/api/camera_map_obstacle_proxy/{entity_id}"
+ name = "api:camera:map_obstacle"
+
+ async def handle(self, request: web.Request, camera: Camera) -> web.Response:
+ """Serve camera obstacle image."""
+ if camera.map_index == 0:
+ crop = request.query.get("crop")
+ box = request.query.get("box")
+ color = request.query.get("color")
+ file = request.query.get("file")
+ file = file and (file == True or file == "true" or file == "1")
+ result, object_name = await camera.obstacle_image(
+ request.query.get("index", 1),
+ not box or (box and (box == True or box == "true" or box == "1")),
+ not crop or (crop and (crop == True or crop == "true" or crop == "1")),
+ color,
+ )
+ if result:
+ response = web.Response(
+ body=result,
+ content_type=DEFAULT_CONTENT_TYPE,
+ )
+ if file:
+ response.headers["Content-Disposition"] = (
+ f'attachment; filename={object_name.replace(".jpg","").replace(".jpeg","")}.jpg'
+ )
+ return response
+
+ raise web.HTTPNotFound()
+
+
+class CameraObstacleHistoryView(CameraView):
+ """Camera view to serve the map history data obstacle image."""
+
+ url = "/api/camera_map_obstacle_history_proxy/{entity_id}"
+ name = "api:camera:map_obstacle_history"
+
+ async def handle(self, request: web.Request, camera: Camera) -> web.Response:
+ """Serve camera obstacle image."""
+ if camera.map_index == 0:
+ crop = request.query.get("crop")
+ box = request.query.get("box")
+ color = request.query.get("color")
+ file = request.query.get("file")
+ file = file and (file == True or file == "true" or file == "1")
+ cruising = request.query.get("cruising")
+ result, object_name = await camera.obstacle_history_image(
+ request.query.get("index", 1),
+ request.query.get("history_index", 1),
+ cruising and (cruising == True or cruising == "true" or cruising == "1"),
+ not box or (box and (box == True or box == "true" or box == "1")),
+ not crop or (crop and (crop == True or crop == "true" or crop == "1")),
+ color,
+ )
+ if result:
+ response = web.Response(
+ body=result,
+ content_type=DEFAULT_CONTENT_TYPE,
+ )
+ if file:
+ response.headers["Content-Disposition"] = (
+ f'attachment; filename={object_name.replace(".jpg","").replace(".jpeg","")}.jpg'
+ )
+ return response
+
+ raise web.HTTPNotFound()
+
+
+class CameraHistoryView(CameraView):
+ """Camera view to serve the cleaning or cruising history map."""
+
+ url = "/api/camera_history_map_proxy/{entity_id}"
+ name = "api:camera:history_map"
+
+ async def handle(self, request: web.Request, camera: Camera) -> web.Response:
+ """Serve camera cleaning history or cruising data."""
+ if camera.map_index == 0:
+ data = request.query.get("data")
+ data = data and (data == True or data == "true" or data == "1")
+ cruising = request.query.get("cruising")
+ resources = request.query.get("resources")
+ cleaning = request.query.get("cleaning")
+ wifi = request.query.get("wifi")
+ info = request.query.get("info")
+ result = await camera.history_map_image(
+ request.query.get("index", 1),
+ not info or (info and (info == True or info == "true" or info == "1")),
+ cruising and (cruising == True or cruising == "true" or cruising == "1"),
+ data,
+ cleaning and (cleaning == True or cleaning == "true" or cleaning == "1"),
+ wifi and (wifi == True or wifi == "true" or wifi == "1"),
+ data and resources and (resources == True or resources == "true" or resources == "1"),
+ )
+ if result:
+ response = web.Response(
+ body=gzip.compress(bytes(result, "utf-8")) if data else result,
+ content_type=JSON_CONTENT_TYPE if data else PNG_CONTENT_TYPE,
+ )
+ if data:
+ response.headers["Content-Encoding"] = "gzip"
+ return response
+ raise web.HTTPNotFound()
+
+
+class CameraRecoveryView(CameraView):
+ """Camera view to serve the recovery map."""
+
+ url = "/api/camera_recovery_map_proxy/{entity_id}"
+ name = "api:camera:recovery_map"
+
+ async def handle(self, request: web.Request, camera: Camera) -> web.Response:
+ """Serve camera recovery map data."""
+ index = request.query.get("index", 1)
+ file = request.query.get("file")
+ data = False
+ file = file and (file == True or file == "true" or file == "1")
+ if file:
+ result, map_url, object_name = await camera.recovery_map_file(index)
+ else:
+ data = request.query.get("data")
+ data = data and (data == True or data == "true" or data == "1")
+ resources = request.query.get("resources")
+ info = request.query.get("info")
+ result = await camera.recovery_map(
+ index,
+ not info or (info and (info == True or info == "true" or info == "1")),
+ data,
+ data and resources and (resources == True or resources == "true" or resources == "1"),
+ )
+ if result:
+ response = web.Response(
+ body=gzip.compress(bytes(result, "utf-8")) if data and not file else result,
+ content_type="application/x-tar+gzip" if file else JSON_CONTENT_TYPE if data else PNG_CONTENT_TYPE,
+ )
+ if file:
+ response.headers["Content-Disposition"] = (
+ f'attachment; filename={object_name.replace("/", "-").replace(".mb.tbz2", "")}.mb.tbz2'
+ )
+ elif data:
+ response.headers["Content-Encoding"] = "gzip"
+ return response
+ raise web.HTTPNotFound()
+
+
+class CameraWifiView(CameraView):
+ """Camera view to serve the saved wifi map."""
+
+ url = "/api/camera_wifi_map_proxy/{entity_id}"
+ name = "api:camera:wifi_map"
+
+ async def handle(self, request: web.Request, camera: Camera) -> web.Response:
+ """Serve camera wifi map data."""
+ data = request.query.get("data")
+ data = data and (data == True or data == "true" or data == "1")
+ resources = request.query.get("resources")
+ result = await camera.wifi_map_data(
+ data,
+ data and resources and (resources == True or resources == "true" or resources == "1"),
+ )
+ if result:
+ response = web.Response(
+ body=gzip.compress(bytes(result, "utf-8")) if data else result,
+ content_type=JSON_CONTENT_TYPE if data else PNG_CONTENT_TYPE,
+ )
+ if data:
+ response.headers["Content-Encoding"] = "gzip"
+ return response
+ raise web.HTTPNotFound()
+
+
+class CameraResourcesView(HomeAssistantView):
+ """Camera view to serve the map data resources."""
+
+ url = "/api/camera_resources_proxy/{entity_id}"
+ name = "api:camera:resources"
+
+ requires_auth = False
+
+ def __init__(self, component) -> None:
+ """Initialize camera view."""
+ self.component = component
+
+ async def get(self, request: web.Request, entity_id: str) -> web.StreamResponse:
+ """Serve resources data."""
+ if (camera := self.component.get_entity(entity_id)) is None or camera.map_index != 0 or not camera.device:
+ raise web.HTTPNotFound
+
+ icon_set = request.query.get("icon_set")
+ response = web.Response(
+ body=gzip.compress(
+ bytes(
+ camera.resources(icon_set),
+ "utf-8",
+ )
+ ),
+ content_type=JSON_CONTENT_TYPE,
+ )
+ response.headers["Content-Encoding"] = "gzip"
+ return response
+
+
async def async_setup_entry(
hass: HomeAssistant,
entry: ConfigEntry,
@@ -58,20 +373,54 @@ async def async_setup_entry(
) -> None:
"""Set up Dreame Vacuum Camera based on a config entry."""
coordinator: DreameVacuumDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
- color_scheme = entry.options.get(CONF_COLOR_SCHEME)
- icon_set = entry.options.get(CONF_ICON_SET)
- hidden_map_objects = entry.options.get(CONF_HIDDEN_MAP_OBJECTS, [])
- if coordinator.device.status.map_available:
+ if coordinator.device.capability.map:
+ color_scheme = entry.options.get(CONF_COLOR_SCHEME)
+ icon_set = entry.options.get(CONF_ICON_SET)
+ low_resolution = entry.options.get(CONF_LOW_RESOLUTION, False)
+ square = entry.options.get(CONF_SQUARE, False)
+ hidden_map_objects = entry.options.get(CONF_HIDDEN_MAP_OBJECTS, [])
+
async_add_entities(
- DreameVacuumCameraEntity(coordinator, description, color_scheme, icon_set, hidden_map_objects)
+ DreameVacuumCameraEntity(
+ coordinator,
+ description,
+ color_scheme,
+ icon_set,
+ hidden_map_objects,
+ low_resolution,
+ square,
+ )
for description in CAMERAS
)
- update_map_cameras = partial(
- async_update_map_cameras, coordinator, {}, async_add_entities, color_scheme, icon_set, hidden_map_objects
- )
- coordinator.async_add_listener(update_map_cameras)
- update_map_cameras()
+ update_map_cameras = partial(
+ async_update_map_cameras,
+ coordinator,
+ {},
+ async_add_entities,
+ color_scheme,
+ icon_set,
+ hidden_map_objects,
+ low_resolution,
+ square,
+ )
+ platform = entity_platform.current_platform.get()
+ platform.async_register_entity_service("update", {}, DreameVacuumCameraEntity.async_update.__name__)
+ coordinator.async_add_listener(update_map_cameras)
+ update_map_cameras()
+
+ camera = hass.data["camera"]
+ hass.http.register_view(CameraDataView(camera))
+ hass.http.register_view(CameraObstacleView(camera))
+ hass.http.register_view(CameraObstacleHistoryView(camera))
+ hass.http.register_view(CameraHistoryView(camera))
+ hass.http.register_view(CameraRecoveryView(camera))
+ hass.http.register_view(CameraWifiView(camera))
+ hass.http.register_view(CameraResourcesView(camera))
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+ return True
@callback
@@ -82,6 +431,8 @@ def async_update_map_cameras(
color_scheme: str,
icon_set: str,
hidden_map_objects: list[str],
+ low_resolution: bool,
+ square: bool,
) -> None:
new_indexes = set([k for k in range(1, len(coordinator.device.status.map_list) + 1)])
current_ids = set(current)
@@ -95,15 +446,39 @@ def async_update_map_cameras(
DreameVacuumCameraEntity(
coordinator,
DreameVacuumCameraEntityDescription(
+ key="saved_map",
entity_category=EntityCategory.CONFIG,
icon="mdi:map-search",
),
color_scheme,
icon_set,
hidden_map_objects,
+ low_resolution,
+ square,
map_index,
)
]
+
+ if coordinator.device.capability.wifi_map and not low_resolution:
+ current[map_index].append(
+ DreameVacuumCameraEntity(
+ coordinator,
+ DreameVacuumCameraEntityDescription(
+ key="wifi_map",
+ entity_category=EntityCategory.CONFIG,
+ icon="mdi:wifi-settings",
+ map_type=DreameVacuumMapType.WIFI_MAP,
+ entity_registry_enabled_default=False,
+ ),
+ color_scheme,
+ icon_set,
+ hidden_map_objects,
+ True,
+ square,
+ map_index,
+ )
+ )
+
new_entities = new_entities + current[map_index]
if new_entities:
@@ -120,12 +495,14 @@ def async_remove_map_cameras(
for entity in entities:
if entity.entity_id in registry.entities:
registry.async_remove(entity.entity_id)
+ del entity
del current[map_index]
class DreameVacuumCameraEntity(DreameVacuumEntity, Camera):
"""Defines a Dreame Vacuum Camera entity."""
+ _unrecorded_attributes = frozenset(CAMERA_UNRECORDED_ATTRIBUTES)
_webrtc_provider = None
_legacy_webrtc_provider = None
_supports_native_sync_webrtc = False
@@ -138,12 +515,15 @@ def __init__(
color_scheme: str = None,
icon_set: str = None,
hidden_map_objects: list[str] = None,
+ low_resolution: bool = False,
+ square: bool = False,
map_index: int = 0,
) -> None:
"""Initialize a Dreame Vacuum Camera entity."""
super().__init__(coordinator, description)
- self.content_type = CONTENT_TYPE
+ self.content_type = PNG_CONTENT_TYPE
self.stream = None
+ self._access_token_update_counter = 0
self.access_tokens = collections.deque([], 2)
self.async_update_token()
self._rtsp_to_webrtc = False
@@ -151,81 +531,129 @@ def __init__(
self._last_updated = -1
self._frame_id = -1
self._last_map_request = 0
+ self._last_rendered = -1
self._attr_is_streaming = True
self._calibration_points = None
+ self._device_active = None
+ self._error = None
+ self._proxy_renderer = None
+ self._color_scheme = color_scheme
+ self._icon_set = MAP_ICON_SET_LIST.get(icon_set, 0)
- self._available = self.device.device_connected and self.device.cloud_connected
- if description.map_data_json:
- self._renderer = DreameVacuumMapDataRenderer()
+ if description.map_type == DreameVacuumMapType.JSON_MAP_DATA:
+ self._renderer = DreameVacuumMapDataJsonRenderer()
+ self.content_type = JSON_CONTENT_TYPE
else:
+ if self.wifi_map:
+ objects = list(MAP_OBJECTS.keys())
+ objects.pop(17) ## Charger
+ else:
+ objects = hidden_map_objects
+
self._renderer = DreameVacuumMapRenderer(
- color_scheme, icon_set, hidden_map_objects, self.device.status.robot_shape
+ color_scheme,
+ icon_set,
+ objects,
+ self.device.capability.robot_type,
+ low_resolution,
+ square,
)
-
- self._image = self._renderer.default_map_image
- self._default_map = True
+ if not self.wifi_map:
+ self._proxy_renderer = DreameVacuumMapRenderer(
+ color_scheme,
+ icon_set,
+ hidden_map_objects,
+ self.device.capability.robot_type,
+ low_resolution,
+ square,
+ False,
+ )
+ self._image = None
+ self._default_map = None
+ self._proxy_images = {}
self.map_index = map_index
self._state = STATE_UNAVAILABLE
+ if self.map_index == 0 and not self.map_data_json:
+ self._image = self._renderer.default_map_image
map_data = self._map_data
- if map_data:
- self._map_id = map_data.map_id
+ self._map_id = map_data.map_id if map_data else None
if self.map_index:
if map_data:
self._map_name = map_data.custom_name
else:
self._map_name = None
- self._set_map_name()
- self._attr_unique_id = f"{self.device.mac}_map_{self.map_index}"
+ self._set_map_name(self.wifi_map)
+ self._attr_unique_id = f"{self.device.mac}_{'wifi_' if self.wifi_map else ''}map_{self.map_index}"
self.entity_id = async_generate_entity_id(
- ENTITY_ID_FORMAT,
- f"{self.device.name.lower()}_map_{self.map_index}",
+ ENTITY_ID_FORMAT,
+ f"{self.device.name}_{'wifi_' if self.wifi_map else ''}map_{self.map_index}",
hass=self.coordinator.hass,
)
else:
- self._attr_name = f"Current {description.name}"
- self._attr_unique_id = f"{self.device.mac}_map_{description.key}"
+ self._attr_name = f"Current {'Wifi ' if self.wifi_map else ''}{description.name}"
+ self._attr_unique_id = f"{self.device.mac}_map_{'wifi_' if self.wifi_map else ''}{description.key}"
self.entity_id = async_generate_entity_id(
- ENTITY_ID_FORMAT,
- f"{self.device.name.lower()}_{description.key.lower()}",
+ ENTITY_ID_FORMAT,
+ f"{self.device.name}_{'wifi_' if self.wifi_map else ''}{description.key.lower()}",
hass=self.coordinator.hass,
)
self.update()
- def _set_map_name(self) -> None:
+ def _set_map_name(self, wifi_map) -> None:
name = (
f"{self.map_index}"
if self._map_name is None
else f"{self._map_name.replace('_', ' ').replace('-', ' ').title()}"
)
- self._attr_name = f"Saved Map {name}"
+ self._attr_name = f"Saved {'Wifi ' if wifi_map else ''}Map {name}"
@callback
def _handle_coordinator_update(self) -> None:
"""Fetch state from the device."""
- self._available = self.device.cloud_connected
self._last_map_request = 0
map_data = self._map_data
- if map_data and self.available and (self.map_index > 0 or self.device.status.located):
+ if map_data and self.device.cloud_connected and (self.map_index > 0 or self.device.status.located):
+ if map_data.last_updated:
+ self._state = datetime.fromtimestamp(int(map_data.last_updated))
+ elif map_data.timestamp_ms:
+ self._state = datetime.fromtimestamp(int(map_data.timestamp_ms / 1000))
+ else:
+ self._state = datetime.now()
+
if self.map_index > 0:
if self._map_name != map_data.custom_name:
self._map_name = map_data.custom_name
- self._set_map_name()
+ self._set_map_name(self.wifi_map)
if self._map_id != map_data.map_id:
self._map_id = map_data.map_id
self._frame_id = None
self._last_updated = None
- if self._default_map == True or self._frame_id != map_data.frame_id:
+ if (
+ self._default_map != False
+ or self._frame_id != map_data.frame_id
+ or self._last_updated != map_data.last_updated
+ ):
self._frame_id = map_data.frame_id
- if not self.device.status.active:
+ if (
+ not self.device.status.active
+ or self._device_active != self.device.status.active
+ or self._error != self.device.status.error
+ or self._last_updated is None
+ or self.map_index > 0
+ ):
self.update()
+ elif self._error != self.device.status.error or self._device_active != self.device.status.active:
+ self.update()
+ self._device_active = self.device.status.active
+ self._error = self.device.status.error
else:
self.update()
-
+ self._state = STATE_UNAVAILABLE
self.async_write_ha_state()
async def async_camera_image(self, width: int | None = None, height: int | None = None) -> bytes | None:
@@ -234,9 +662,19 @@ async def async_camera_image(self, width: int | None = None, height: int | None
now = time.time()
if now - self._last_map_request >= self.frame_interval:
self._last_map_request = now
- if self.map_index == 0:
+ if self.map_index == 0 and self.device:
self.device.update_map()
self.update()
+ if (
+ self._last_updated and self._last_rendered != self._last_updated and self._renderer.render_complete
+ ) or (self._default_map != False and self._state != STATE_UNAVAILABLE):
+ self._default_map = False
+ await self._update_image(
+ self.device.get_map_for_render(self._map_data),
+ self.device.status.robot_status,
+ self.device.status.station_status,
+ )
+ self._last_rendered = self._last_updated
self._should_poll = True
return self._image
@@ -266,55 +704,316 @@ async def handle_async_still_stream(self, request: web.Request, interval: float)
+ b"\r\n"
)
last_image = img_bytes
+ if not self.device:
+ break
await asyncio.sleep(interval)
return response
+ @callback
+ def async_update_token(self) -> None:
+ """Update the used token."""
+ if self._access_token_update_counter:
+ self._access_token_update_counter = self._access_token_update_counter + 1
+
+ if not self._access_token_update_counter or self._access_token_update_counter > int(
+ DREAME_TOKEN_CHANGE_INTERVAL.total_seconds() / TOKEN_CHANGE_INTERVAL.total_seconds()
+ ):
+ self._access_token_update_counter = 1
+ super().async_update_token()
+
+ async def async_update(self) -> None:
+ self._frame_id = None
+ self._last_updated = None
+ self.update()
+
+ def __del__(self):
+ if self._renderer:
+ del self._renderer
+ self._renderer = None
+ if self._proxy_renderer:
+ del self._proxy_renderer
+ self._proxy_renderer = None
+
def update(self) -> None:
map_data = self._map_data
- if map_data and self.available and (self.map_index > 0 or self.device.status.located):
- if (
- self.map_index == 0
- and not self.entity_description.map_data_json
- and map_data.last_updated != self._last_updated
- and not self._renderer.render_complete
- ):
- LOGGER.warning("Waiting render complete")
+ if map_data and self.device.cloud_connected and (self.map_index > 0 or self.device.status.located):
+ if self._default_map == True:
+ self._default_map = False
+ self._image = self._renderer.render_map(
+ self.device.get_map_for_render(map_data),
+ self.device.status.robot_status,
+ self.device.status.station_status,
+ )
+ self._last_rendered = map_data.last_updated
+ if not self.map_data_json:
+ self._calibration_points = self._renderer.calibration_points
- if self._renderer.render_complete and map_data.last_updated != self._last_updated:
- if self.map_index == 0 and not self.entity_description.map_data_json:
- LOGGER.debug("Update map")
+ self._device_active = self.device.status.active
+ if map_data.last_updated:
+ self._state = datetime.fromtimestamp(int(map_data.last_updated))
+ elif map_data.timestamp_ms:
+ self._state = datetime.fromtimestamp(int(map_data.timestamp_ms / 1000))
+ if map_data.last_updated != self._last_updated:
self._last_updated = map_data.last_updated
self._frame_id = map_data.frame_id
- self._default_map = False
- if map_data.timestamp_ms and not map_data.saved_map:
- self._state = datetime.fromtimestamp(int(map_data.timestamp_ms / 1000))
- elif map_data.last_updated:
- self._state = datetime.fromtimestamp(int(map_data.last_updated))
-
- self.coordinator.hass.async_create_task(
- self._update_image(self.device.get_map_for_render(self.map_index), self.device.status.robot_status)
- )
elif not self._default_map:
+ self._state = STATE_UNAVAILABLE
self._image = self._default_map_image
self._default_map = True
self._frame_id = -1
self._last_updated = -1
- self._state = STATE_UNAVAILABLE
+ self._last_rendered = -1
+
+ async def obstacle_image(self, index, box=False, crop=False, color=None):
+ if self.map_index == 0:
+ response, obstacle = await self.hass.async_add_executor_job(self.device.obstacle_image, index)
+ if response and obstacle:
+ return (
+ self._get_proxy_obstacle_image(
+ response,
+ obstacle,
+ box,
+ crop,
+ DreameVacuumMapRenderer.color_to_tuple(color) if color else None,
+ "obstacle",
+ ),
+ obstacle.object_name,
+ )
+ return (None, None)
+
+ async def obstacle_history_image(self, index, history_index, cruising, box=False, crop=False, color=None):
+ if self.map_index == 0:
+ response, obstacle = await self.hass.async_add_executor_job(
+ self.device.obstacle_history_image, index, history_index, cruising
+ )
+ if response and obstacle:
+ return (
+ self._get_proxy_obstacle_image(
+ response,
+ obstacle,
+ box,
+ crop,
+ DreameVacuumMapRenderer.color_to_tuple(color) if color else None,
+ "obstacle_history",
+ 1,
+ ),
+ obstacle.object_name,
+ )
+ return (None, None)
+
+ async def history_map_image(self, index, info_text, cruising, data, cleaning_map, wifi_map, include_resources):
+ if self.map_index == 0:
+ map_data = await self.hass.async_add_executor_job(self.device.history_map, index, cruising)
+ if map_data:
+ if not cleaning_map and not cruising and wifi_map:
+ if not map_data.wifi_map_data:
+ return None
+ map_data = self.device.get_map_for_render(map_data.wifi_map_data)
+ else:
+ map_data = (
+ self.device.get_map_for_render(map_data)
+ if cruising or not cleaning_map or map_data.cleaning_map_data is None
+ else map_data.cleaning_map_data
+ )
+
+ if data:
+ return DreameVacuumMapRenderer.get_data(
+ map_data,
+ self.device.capability,
+ self._icon_set,
+ include_resources,
+ )
+ return self._get_proxy_image(
+ index,
+ map_data,
+ info_text,
+ "cruising" if cruising else "cleaning" if cleaning_map else "wifi" if wifi_map else "details",
+ )
+
+ async def recovery_map_file(self, index):
+ if not self.map_data_json and not self.wifi_map:
+ if self.map_index == 0:
+ selected_map = self.device.status.selected_map
+ map_id = selected_map.map_id if selected_map else None
+ else:
+ map_id = self._map_id
+ if map_id:
+ return await self.hass.async_add_executor_job(self.device.recovery_map_file, map_id, index)
+ return (None, None, None)
+
+ async def recovery_map(self, index, info_text, data, include_resources):
+ if not self.map_data_json and not self.wifi_map:
+ if self.map_index == 0:
+ selected_map = self.device.status.selected_map
+ map_data = (
+ await self.hass.async_add_executor_job(self.device.recovery_map, selected_map.map_id, index)
+ if selected_map
+ else None
+ )
+ else:
+ map_data = await self.hass.async_add_executor_job(self.device.recovery_map, self._map_id, index)
+ if map_data:
+ map_data = self.device.get_map_for_render(map_data)
+ if data:
+ return DreameVacuumMapRenderer.get_data(
+ map_data,
+ self.device.capability,
+ self._icon_set,
+ include_resources,
+ )
+ else:
+ return self._get_proxy_image(index, map_data, info_text, "recovery")
+
+ async def wifi_map_data(self, data, include_resources):
+ if not self.wifi_map:
+ map_data = self.device.status.selected_map if self.map_index == 0 else self.device.get_map(self.map_index)
+ if map_data:
+ map_data = map_data.wifi_map_data
+ if map_data:
+ map_data = self.device.get_map_for_render(map_data)
+ if data:
+ return DreameVacuumMapRenderer.get_data(
+ map_data,
+ self.device.capability,
+ self._icon_set,
+ include_resources,
+ )
+ else:
+ return self._get_proxy_image(
+ map_data.map_index if self.map_index == 0 else self.map_index,
+ map_data,
+ False,
+ "wifi",
+ 1,
+ )
+
+ def map_data_string(self, include_resources) -> str:
+ if self._map_data:
+ if self.map_index == 0 and self.device:
+ self._last_map_request = time.time()
+ self.device.update_map()
+ return DreameVacuumMapRenderer.get_data(
+ self.device.get_map_for_render(self._map_data),
+ self.device.capability,
+ self._icon_set,
+ include_resources,
+ self.device.status.robot_status,
+ self.device.status.station_status,
+ )
+
+ async def saved_map_data_string(self, index, include_resources) -> str:
+ if self.device:
+ data = None
+ for v in self.device.status.map_data_list.values():
+ if v.map_index == int(index):
+ data = v
+
+ if data:
+ return DreameVacuumMapRenderer.get_data(
+ self.device.get_map_for_render(data),
+ self.device.capability,
+ self._icon_set,
+ include_resources,
+ )
+
+ async def recovery_map_data_string(self, index, recovery_index, include_resources, file) -> str:
+ if self.device:
+ data = None
+ for v in self.device.status.map_data_list.values():
+ if v.map_index == int(index):
+ data = v
+
+ if data:
+ map_list = data.recovery_map_list
+ if map_list:
+ if file:
+ return await self.hass.async_add_executor_job(
+ self.device.recovery_map_file, data.map_id, recovery_index
+ )
+ else:
+ data = await self.hass.async_add_executor_job(
+ self.device.recovery_map, data.map_id, recovery_index
+ )
+ if data:
+ return (
+ DreameVacuumMapRenderer.get_data(
+ self.device.get_map_for_render(data),
+ self.device.capability,
+ self._icon_set,
+ include_resources,
+ ),
+ None,
+ None,
+ )
+
+ def resources(self, icon_set=None) -> str:
+ return (
+ DreameVacuumMapRenderer.get_resources(
+ self.device.capability,
+ self._icon_set if icon_set is None or not str(icon_set).isdecimal() else int(icon_set),
+ True,
+ )
+ if self.device
+ else "{}"
+ )
+
+ async def _update_image(self, map_data, robot_status, station_status) -> None:
+ try:
+ self._image = self._renderer.render_map(map_data, robot_status, station_status)
+ if not self.map_data_json and self._calibration_points != self._renderer.calibration_points:
+ self._calibration_points = self._renderer.calibration_points
+ self.coordinator.set_updated_data()
+ except Exception:
+ LOGGER.warning("Map render Failed: %s", traceback.format_exc())
- async def _update_image(self, map_data, robot_status) -> None:
- self._image = self._renderer.render_map(map_data, robot_status)
- if not self.entity_description.map_data_json and self._calibration_points != self._renderer.calibration_points:
- self._calibration_points = self._renderer.calibration_points
- self.coordinator.set_updated_data()
+ def _get_proxy_image(self, index, map_data, info_text, cache_key, max_item=2):
+ item_key = f"i{index}_t{int(info_text)}_d{int(map_data.last_updated)}"
+ if cache_key not in self._proxy_images:
+ self._proxy_images[cache_key] = {}
+ if item_key in self._proxy_images[cache_key]:
+ return self._proxy_images[cache_key][item_key]
+ image = self._proxy_renderer.render_map(map_data, 0, 0, info_text)
+ if image:
+ while len(self._proxy_images[cache_key]) >= max_item:
+ del self._proxy_images[cache_key][next(iter(self._proxy_images[cache_key]))]
+ self._proxy_images[cache_key][item_key] = image
+ return image
+
+ def _get_proxy_obstacle_image(self, data, obstacle, box, crop, color, cache_key, max_item=3):
+ item_key = f"b{int(box)}_c{int(crop)}_l{color}_d{obstacle.id}"
+ if cache_key not in self._proxy_images:
+ self._proxy_images[cache_key] = {}
+ if item_key in self._proxy_images[cache_key]:
+ return self._proxy_images[cache_key][item_key]
+ image = self._renderer.render_obstacle_image(
+ data, obstacle, self.device.capability.obstacle_image_crop, box, crop, color
+ )
+ if image:
+ while len(self._proxy_images[cache_key]) >= max_item:
+ del self._proxy_images[cache_key][next(iter(self._proxy_images[cache_key]))]
+ self._proxy_images[cache_key][item_key] = image
+ return image
+
+ @property
+ def wifi_map(self) -> bool:
+ return bool(self.entity_description.map_type == DreameVacuumMapType.WIFI_MAP)
+
+ @property
+ def map_data_json(self) -> bool:
+ return bool(self.entity_description.map_type == DreameVacuumMapType.JSON_MAP_DATA)
@property
def _map_data(self) -> Any:
- return self.device.get_map(self.map_index)
+ if self.device:
+ map_data = self.device.get_map(self.map_index)
+ if self.wifi_map and map_data:
+ return map_data.wifi_map_data
+ return map_data
@property
def _default_map_image(self) -> Any:
- if self._image and (not self.device.device_connected or not self.device.cloud_connected):
+ if self.device and self._image and not self.device.cloud_connected:
return self._renderer.disconnected_map_image
return self._renderer.default_map_image
@@ -330,18 +1029,158 @@ def state(self) -> str:
@property
def available(self) -> bool:
"""Return True if entity is available."""
- return self._available
+ return True
+
+ @property
+ def entity_picture(self) -> str:
+ """Return a link to the camera feed as entity picture."""
+ map_data = self._map_data
+ return MAP_IMAGE_URL.format(
+ self.entity_id,
+ self.access_tokens[-1],
+ int(map_data.last_updated) if map_data and map_data.last_updated else 0,
+ )
@property
def extra_state_attributes(self) -> Dict[str, Any]:
- if not self.entity_description.map_data_json:
- map_data = self._map_data
- if map_data and not map_data.empty_map and (self.map_index > 0 or self.device.status.located):
+ map_data = self._map_data
+ attributes = None
+ if not self.map_data_json:
+ if (
+ map_data
+ and self.device.cloud_connected
+ and not map_data.empty_map
+ and (self.map_index > 0 or self.device.status.located)
+ ):
attributes = map_data.as_dict()
- if attributes:
- attributes[ATTR_CALIBRATION] = (
- self._calibration_points if self._calibration_points else self._renderer.calibration_points
+ if not attributes:
+ attributes = {}
+
+ attributes[ATTR_CALIBRATION] = (
+ self._calibration_points if self._calibration_points else self._renderer.calibration_points
+ )
+ elif self.device.cloud_connected:
+ attributes = {ATTR_CALIBRATION: self._renderer.default_calibration_points}
+
+ if not attributes:
+ attributes = {}
+
+ if self.map_index:
+ attributes[ATTR_SELECTED] = (
+ self.device.status.selected_map and self.device.status.selected_map.map_index == self.map_index
+ )
+
+ token = self.access_tokens[-1]
+ if self.map_index == 0:
+ attributes[ATTR_COLOR_SCHEME] = self._color_scheme
+
+ def get_key(index, history):
+ return f"{index}: {time.strftime("%m/%d/%y %H:%M" if datetime.now().year != history.date.year else "%m/%d %H:%M", time.localtime(history.date.timestamp()))} - {'Second ' if history.second_cleaning else ''}{STATUS_CODE_TO_NAME.get(history.status, STATE_UNKNOWN).replace('_', ' ').title()} {'(Completed)' if history.completed else '(Interrupted)'}"
+
+ if self.device.status._cleaning_history is not None:
+ cleaning_history = {}
+ index = 1
+ for history in self.device.status._cleaning_history:
+ key = get_key(index, history)
+ cleaning_history[key] = HISTORY_MAP_IMAGE_URL.format(
+ self.entity_id,
+ token,
+ index,
+ int(history.date.timestamp()),
+ )
+ index = index + 1
+ attributes[ATTR_CLEANING_HISTORY_PICTURE] = cleaning_history
+
+ if self.device.status._cruising_history is not None:
+ cruising_history = {}
+ index = 1
+ for history in self.device.status._cruising_history:
+ key = get_key(index, history)
+ cruising_history[key] = (
+ f"{HISTORY_MAP_IMAGE_URL.format(self.entity_id, token, index, int(history.date.timestamp()))}&cruising=1"
+ )
+ index = index + 1
+ attributes[ATTR_CRUISING_HISTORY_PICTURE] = cruising_history
+
+ if map_data and map_data.obstacles:
+ obstacles = {}
+ total = len(map_data.obstacles)
+ if total:
+ index = total
+ for k in reversed(map_data.obstacles):
+ obstacle = map_data.obstacles[k]
+ if (
+ (obstacle.type.value == 158 and self.device.status.ai_pet_detection == 0)
+ or (
+ self.device.capability.fluid_detection
+ and (
+ obstacle.type.value == 139
+ or obstacle.type.value == 206
+ or obstacle.type.value == 202
+ or obstacle.type.value == 169
+ )
+ and not self.device.status.ai_fluid_detection
+ )
+ or (obstacle.picture_status is not None and obstacle.picture_status.value != 2)
+ ):
+ index = index - 1
+ continue
+
+ key = f"{index}: {obstacle.type.name.replace('_', ' ').title()}"
+ if obstacle.possibility:
+ key = f"{key} %{obstacle.possibility}"
+ if obstacle.segment:
+ key = f"{key} ({obstacle.segment})"
+ if obstacle.ignore_status and int(obstacle.ignore_status) > 0:
+ key = f"{key} ({obstacle.ignore_status.name.replace('_', ' ').title()})"
+
+ obstacles[key] = OBSTACLE_IMAGE_URL.format(self.entity_id, token, k, obstacle.id)
+ index = index - 1
+
+ attributes[ATTR_OBSTACLE_PICTURE] = obstacles
+
+ if not self.wifi_map and map_data:
+ if self.map_index == 0:
+ selected_map = self.device.status.selected_map
+ recovery_map_list = selected_map.recovery_map_list if selected_map else None
+ else:
+ recovery_map_list = map_data.recovery_map_list
+
+ if recovery_map_list is not None:
+ recovery_map = {}
+ recovery_file = {}
+ index = len(recovery_map_list)
+ for map in reversed(recovery_map_list):
+ key = f"{time.strftime('%x %X', time.localtime(map.date.timestamp()))}: Map{index} ({map.map_type.name.title()})"
+ recovery_map[key] = RECOVERY_MAP_IMAGE_URL.format(
+ self.entity_id, token, index, int(map.date.timestamp())
+ )
+ recovery_file[key] = f"{recovery_map[key]}&file=1"
+ index = index - 1
+ attributes[ATTR_RECOVERY_MAP_PICTURE] = recovery_map
+ attributes[ATTR_RECOVERY_MAP_FILE] = recovery_file
+
+ if self.map_index == 0:
+ selected_map = self.device.status.selected_map
+ wifi_map_data = selected_map.wifi_map_data if selected_map else None
+ else:
+ wifi_map_data = map_data.wifi_map_data
+
+ if wifi_map_data:
+ attributes[ATTR_WIFI_MAP_PICTURE] = WIFI_MAP_IMAGE_URL.format(
+ self.entity_id,
+ token,
+ int(wifi_map_data.last_updated if wifi_map_data.last_updated else map_data.last_updated),
)
- return attributes
- elif self.available:
- return {ATTR_CALIBRATION: self._renderer.default_calibration_points}
+ elif (
+ map_data
+ and self.device.cloud_connected
+ and not map_data.empty_map
+ and (self.map_index > 0 or self.device.status.located)
+ ):
+ return {
+ ATTR_MAP_ID: map_data.map_id,
+ ATTR_SAVED_MAP_ID: map_data.saved_map_id,
+ ATTR_COLOR_SCHEME: self._color_scheme,
+ }
+ return attributes
diff --git a/custom_components/dreame_vacuum/config_flow.py b/custom_components/dreame_vacuum/config_flow.py
index a0ffc6af..2e2b21ad 100644
--- a/custom_components/dreame_vacuum/config_flow.py
+++ b/custom_components/dreame_vacuum/config_flow.py
@@ -1,8 +1,11 @@
-"""Config flow for Dremae Vacuum."""
+"""Config flow for Dreame Vacuum."""
from __future__ import annotations
from typing import Any, Final
import re
+import zlib
+import base64
+import json
import voluptuous as vol
import homeassistant.helpers.config_validation as cv
from collections.abc import Mapping
@@ -22,7 +25,7 @@
OptionsFlow,
)
-from .dreame import DreameVacuumProtocol, MAP_COLOR_SCHEME_LIST, MAP_ICON_SET_LIST, VERSION
+from .dreame import DreameVacuumProtocol, MAP_COLOR_SCHEME_LIST, MAP_ICON_SET_LIST, DEVICE_INFO, VERSION
from .const import (
DOMAIN,
@@ -37,6 +40,8 @@
CONF_AUTH_KEY,
CONF_HIDDEN_MAP_OBJECTS,
CONF_PREFER_CLOUD,
+ CONF_LOW_RESOLUTION,
+ CONF_SQUARE,
CONF_DONATED,
CONF_VERSION,
NOTIFICATION,
@@ -44,79 +49,19 @@
SPONSOR,
)
+
+ACCOUNT_TYPE_DREAME = "dreame"
+ACCOUNT_TYPE_MOVA = "mova"
ACCOUNT_TYPE_MI = "mi"
+ACCOUNT_TYPE_TROUVER = "trouver"
ACCOUNT_TYPE_LOCAL = "local"
-DREAME_MODELS = [
- "dreame.vacuum.r2205",
- "dreame.vacuum.r2243",
- "dreame.vacuum.r2240",
- "dreame.vacuum.r2250",
- "dreame.vacuum.p2009",
- "dreame.vacuum.r2312",
- "dreame.vacuum.p2259",
- "dreame.vacuum.r2312a",
- "dreame.vacuum.r2322",
- "dreame.vacuum.p2187",
- "dreame.vacuum.r2328",
- "dreame.vacuum.p2028a",
- # "dreame.vacuum.r2251a", Map private key missing
- "dreame.vacuum.p2029",
- "dreame.vacuum.r2257o",
- "dreame.vacuum.r2215o",
- "dreame.vacuum.r2216o",
- "dreame.vacuum.r2228o",
- "dreame.vacuum.r2228",
- "dreame.vacuum.r2246",
- "dreame.vacuum.r2233",
- "dreame.vacuum.r2247",
- "dreame.vacuum.r2211o",
- "dreame.vacuum.r2316",
- "dreame.vacuum.r2316p",
- "dreame.vacuum.r2313",
- "dreame.vacuum.r2355",
- "dreame.vacuum.r2332",
- "dreame.vacuum.p2027",
- "dreame.vacuum.r2104",
- "dreame.vacuum.r2251o",
- "dreame.vacuum.r2232a",
- "dreame.vacuum.r2317",
- "dreame.vacuum.r2345a",
- "dreame.vacuum.r2345h",
- "dreame.vacuum.r2215",
- "dreame.vacuum.r2235",
- "dreame.vacuum.r2263",
- "dreame.vacuum.r2253",
- "dreame.vacuum.p2028",
- "dreame.vacuum.p2157",
- "dreame.vacuum.p2156o",
-]
-
-MIJIA_MODELS = [
- "dreame.vacuum.p2041",
- "dreame.vacuum.p2036",
- "dreame.vacuum.p2140",
- "dreame.vacuum.p2140a",
- "dreame.vacuum.p2114a",
- "dreame.vacuum.p2114o",
- # "dreame.vacuum.r2210", Map private key missing
- "dreame.vacuum.p2149o",
- "dreame.vacuum.p2150a",
- "dreame.vacuum.p2150b",
- "dreame.vacuum.p2150o",
- "dreame.vacuum.r2209",
- "dreame.vacuum.p2008",
- "dreame.vacuum.p2148o",
- "dreame.vacuum.p2140o",
- "dreame.vacuum.r2254",
- "dreame.vacuum.p2140p",
- "dreame.vacuum.p2140q",
- "dreame.vacuum.p2041o",
-]
-
ACCOUNT_TYPE: Final = {
- "With map (Automatic)": ACCOUNT_TYPE_MI,
- "Without map (Manual)": ACCOUNT_TYPE_LOCAL,
+ "Dreamehome Account": ACCOUNT_TYPE_DREAME,
+ "Xiaomi Home Account": ACCOUNT_TYPE_MI,
+ "Movahome Account": ACCOUNT_TYPE_MOVA,
+ "Trouver Account": ACCOUNT_TYPE_TROUVER,
+ "Manual Connection (Without map)": ACCOUNT_TYPE_LOCAL,
}
@@ -155,6 +100,11 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Flo
CONF_HIDDEN_MAP_OBJECTS,
default=self._config_entry.options.get(CONF_HIDDEN_MAP_OBJECTS, []),
): cv.multi_select(MAP_OBJECTS),
+ vol.Required(CONF_SQUARE, default=self._config_entry.options.get(CONF_SQUARE, False)): bool,
+ vol.Required(
+ CONF_LOW_RESOLUTION,
+ default=self._config_entry.options.get(CONF_LOW_RESOLUTION, False),
+ ): bool,
}
)
if self._config_entry.data.get(CONF_ACCOUNT_TYPE, ACCOUNT_TYPE_MI) == ACCOUNT_TYPE_MI:
@@ -167,14 +117,14 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Flo
}
)
- data_schema = data_schema.extend(
- {
- vol.Required(
- CONF_DONATED,
- default=self._config_entry.options.get(CONF_DONATED, False),
- ): bool
- }
- )
+ data_schema = data_schema.extend(
+ {
+ vol.Required(
+ CONF_DONATED,
+ default=self._config_entry.options.get(CONF_DONATED, False),
+ ): bool
+ }
+ )
return self.async_show_form(
step_id="init",
@@ -202,6 +152,8 @@ def __init__(self) -> None:
self.account_type: str = ACCOUNT_TYPE_MI
self.device_id: int | None = None
self.prefer_cloud: bool = True
+ self.low_resolution: bool = False
+ self.square: bool = False
self.options: dict[str, dict[str, Any]] = {}
self.protocol: DreameVacuumProtocol | None = None
self.models: dict[str, int] = None
@@ -260,26 +212,32 @@ async def async_step_connect(self, user_input: dict[str, Any] | None = None) ->
error = None
if self.prefer_cloud or (self.token and len(self.token) == 32):
try:
- if self.protocol is not None:
- self.protocol.disconnect()
-
- self.protocol = DreameVacuumProtocol(
- self.host,
- self.token,
- self.username,
- self.password,
- self.country,
- self.prefer_cloud,
- self.device_id,
- self.protocol.cloud.auth_key if self.protocol and self.protocol.cloud else None,
- )
+ if (
+ self.account_type != ACCOUNT_TYPE_DREAME
+ and self.account_type != ACCOUNT_TYPE_MOVA
+ and self.account_type != ACCOUNT_TYPE_TROUVER
+ ):
+ if self.protocol is not None:
+ self.protocol.disconnect()
+
+ self.protocol = DreameVacuumProtocol(
+ self.host,
+ self.token,
+ self.username,
+ self.password,
+ self.country,
+ self.prefer_cloud,
+ self.account_type,
+ self.device_id,
+ self.protocol.cloud.auth_key if self.protocol and self.protocol.cloud else None,
+ )
- info = await self.hass.async_add_executor_job(self.protocol.connect, None, None, 3)
- if info:
- self.mac = info["mac"]
- self.model = info["model"]
+ info = await self.hass.async_add_executor_job(self.protocol.connect, None, None, 3)
+ if info:
+ self.mac = info["mac"]
+ self.model = info["model"]
- self.protocol.disconnect()
+ self.protocol.disconnect()
except:
error = "cannot_connect"
else:
@@ -355,6 +313,12 @@ async def async_step_local(
async def async_step_login(self, error=None):
if self.account_type == ACCOUNT_TYPE_MI:
return await self.async_step_mi(error=error)
+ if self.account_type == ACCOUNT_TYPE_DREAME:
+ return await self.async_step_dreame(error=error)
+ if self.account_type == ACCOUNT_TYPE_MOVA:
+ return await self.async_step_mova(error=error)
+ if self.account_type == ACCOUNT_TYPE_TROUVER:
+ return await self.async_step_trouver(error=error)
return await self.async_step_local(error=error)
async def async_step_mi(
@@ -382,6 +346,7 @@ async def async_step_mi(
password=self.password,
country=self.country,
prefer_cloud=self.prefer_cloud,
+ account_type=self.account_type,
)
await self.hass.async_add_executor_job(self.protocol.cloud.login)
@@ -399,7 +364,7 @@ async def async_step_mi(
elif error:
errors["base"] = error
devices = ""
- if error == "no_devices" and self.unsupported_devices:
+ if error == "no_devices" and self.unsupported_devices and not self.reauth:
for device in self.unsupported_devices:
devices = f"{devices} ({device.get("model", "unknown")})"
@@ -470,6 +435,82 @@ async def async_step_captcha(self, user_input: dict[str, Any] | None = None, err
errors=errors,
)
+ async def async_step_dreame(
+ self,
+ user_input: dict[str, Any] | None = None,
+ errors: dict[str, Any] | None = {},
+ error: str | None = None,
+ ) -> FlowResult:
+ """Configure a dreame vacuum device through the Dreame Cloud."""
+
+ description_placeholders = {}
+ if user_input is not None:
+ username = user_input.get(CONF_USERNAME)
+ password = user_input.get(CONF_PASSWORD)
+ country = user_input.get(CONF_COUNTRY, self.country)
+
+ if username and password and country:
+ self.username = username
+ self.password = password
+ self.country = country
+ self.prefer_cloud = True
+
+ if self.protocol is not None:
+ self.protocol.disconnect()
+
+ self.protocol = DreameVacuumProtocol(
+ username=self.username,
+ password=self.password,
+ country=self.country,
+ prefer_cloud=self.prefer_cloud,
+ account_type=self.account_type,
+ )
+ await self.hass.async_add_executor_job(self.protocol.cloud.login)
+
+ if self.protocol.cloud.logged_in is False:
+ errors["base"] = "login_error"
+ elif self.protocol.cloud.logged_in:
+ return await self.async_step_devices()
+ else:
+ errors["base"] = "credentials_incomplete"
+ elif error:
+ errors["base"] = error
+ devices = ""
+ if error == "no_devices" and self.unsupported_devices and not self.reauth:
+ for device in self.unsupported_devices:
+ devices = f"{devices} ({device.get("model", "unknown")})"
+
+ description_placeholders = {"devices": devices}
+ else:
+ errors = {}
+
+ return self.async_show_form(
+ step_id=self.account_type,
+ data_schema=self.login_schema,
+ description_placeholders=description_placeholders,
+ errors=errors,
+ )
+
+ async def async_step_mova(
+ self,
+ user_input: dict[str, Any] | None = None,
+ errors: dict[str, Any] | None = {},
+ error: str | None = None,
+ ) -> FlowResult:
+ """Configure a dreame vacuum device through the Mova Cloud."""
+
+ return await self.async_step_dreame(user_input, errors, error)
+
+ async def async_step_trouver(
+ self,
+ user_input: dict[str, Any] | None = None,
+ errors: dict[str, Any] | None = {},
+ error: str | None = None,
+ ) -> FlowResult:
+ """Configure a dreame vacuum device through the Trouver Cloud."""
+
+ return await self.async_step_dreame(user_input, errors, error)
+
async def async_step_devices(self, user_input: dict[str, Any] | None = None) -> FlowResult:
"""Handle Dreame Vacuum devices found."""
@@ -477,20 +518,29 @@ async def async_step_devices(self, user_input: dict[str, Any] | None = None) ->
if not self.devices:
self.load_devices()
supported_devices, self.unsupported_devices = await self.hass.async_add_executor_job(
- self.protocol.cloud.get_supported_devices, self.models, self.host, self.mac
+ self.protocol.cloud.get_supported_devices, self.models, self.host, self.mac, self.device_id
)
if not supported_devices:
return await self.async_step_login(error="no_devices")
self.devices = {}
for device in supported_devices:
- if self.reauth or not self.hass.config_entries.async_entry_for_domain_unique_id(
+ key = f"{device.get("name", device["model"])} - {device["mac"]}"
+ if self.reauth:
+ if (
+ (self.mac and device["mac"].lower() == self.mac.lower())
+ or (self.device_id and device["did"] == self.device_id)
+ or (self.host and "localip" in device and device["localip"] == self.host)
+ ):
+ self.devices[key] = device
+ break
+ elif not self.hass.config_entries.async_entry_for_domain_unique_id(
self.handler, format_mac(device["mac"])
):
- self.devices[f"{device.get("name", device["model"])} - {device["mac"]}"] = device
+ self.devices[key] = device
if not self.devices:
- if self.unsupported_devices:
+ if self.unsupported_devices or self.reauth:
return await self.async_step_login(error="no_devices")
raise AbortFlow("already_configured")
@@ -517,6 +567,8 @@ async def async_step_options(self, user_input: dict[str, Any] | None = None) ->
CONF_COLOR_SCHEME: user_input.get(CONF_COLOR_SCHEME),
CONF_ICON_SET: user_input.get(CONF_ICON_SET),
CONF_HIDDEN_MAP_OBJECTS: user_input.get(CONF_HIDDEN_MAP_OBJECTS),
+ CONF_SQUARE: user_input.get(CONF_SQUARE),
+ CONF_LOW_RESOLUTION: user_input.get(CONF_LOW_RESOLUTION),
CONF_PREFER_CLOUD: self.prefer_cloud,
}
@@ -534,12 +586,14 @@ async def async_step_options(self, user_input: dict[str, Any] | None = None) ->
if self.models[self.model] == 1:
default_color_scheme = "Mijia Light"
default_icon_set = "Mijia"
+ hidden_map_objects.append("name_background")
hidden_map_objects.append("icon")
else:
default_color_scheme = "Dreame Light"
default_icon_set = "Dreame"
model = re.sub(r"[^0-9]", "", self.model)
- if not (model.isnumeric() and int(model) >= 2215):
+ if (not (model.isnumeric() and int(model) >= 2215)) or self.models[self.model] == 3:
+ hidden_map_objects.append("name_background")
hidden_map_objects.append("name")
if self.account_type != ACCOUNT_TYPE_LOCAL:
@@ -550,6 +604,8 @@ async def async_step_options(self, user_input: dict[str, Any] | None = None) ->
),
vol.Required(CONF_ICON_SET, default=default_icon_set): vol.In(list(MAP_ICON_SET_LIST.keys())),
vol.Required(CONF_HIDDEN_MAP_OBJECTS, default=hidden_map_objects): cv.multi_select(MAP_OBJECTS),
+ vol.Required(CONF_SQUARE, default=False): bool,
+ vol.Required(CONF_LOW_RESOLUTION, default=False): bool,
}
)
@@ -592,24 +648,49 @@ async def async_step_donation(self, user_input: dict[str, Any] | None = None) ->
def extract_info(self, device_info: dict[str, Any]) -> None:
"""Extract the device info."""
- if self.host is None:
- self.host = device_info["localip"]
- if self.mac is None:
- self.mac = device_info["mac"]
- if self.model is None:
- self.model = device_info["model"]
- if self.name is None:
- self.name = device_info["name"]
- self.token = device_info["token"]
- self.device_id = device_info["did"]
+
+ if self.account_type == ACCOUNT_TYPE_MI:
+ if self.host is None:
+ self.host = device_info["localip"]
+ if self.mac is None:
+ self.mac = device_info["mac"]
+ if self.model is None:
+ self.model = device_info["model"]
+ if self.name is None:
+ self.name = device_info["name"]
+ self.token = device_info["token"]
+ self.device_id = device_info["did"]
+ elif (
+ self.account_type == ACCOUNT_TYPE_DREAME
+ or self.account_type == ACCOUNT_TYPE_MOVA
+ or self.account_type == ACCOUNT_TYPE_TROUVER
+ ):
+ if self.token is None:
+ self.token = " "
+ if self.host is None:
+ self.host = device_info["bindDomain"]
+ if self.mac is None:
+ self.mac = device_info["mac"]
+ if self.model is None:
+ self.model = device_info["model"]
+ if self.name is None:
+ self.name = (
+ device_info["customName"]
+ if device_info["customName"] and len(device_info["customName"]) > 0
+ else device_info["deviceInfo"]["displayName"]
+ )
+ self.device_id = device_info["did"]
def load_devices(self):
if self.models is None:
self.models = {}
- for k in DREAME_MODELS:
- self.models[k] = 0
- for k in MIJIA_MODELS:
- self.models[k] = 1
+ device_info = json.loads(zlib.decompress(base64.b64decode(DEVICE_INFO), zlib.MAX_WBITS | 32))
+ for k in device_info[3]:
+ info = device_info[0][device_info[3][k]]
+ if info:
+ self.models[
+ f"{"xiaomi" if info[0] == 1 else ACCOUNT_TYPE_MOVA if info[0] == 2 else ACCOUNT_TYPE_TROUVER if info[0] == 3 else ACCOUNT_TYPE_DREAME}.vacuum.{k}"
+ ] = info[1]
@property
def login_schema(self):
@@ -621,13 +702,30 @@ def login_schema(self):
}
)
+ if self.account_type == ACCOUNT_TYPE_MI:
+ return vol.Schema(
+ {
+ vol.Required(CONF_USERNAME, default=self.username): str,
+ vol.Required(CONF_PASSWORD, default=self.password): str,
+ vol.Required(CONF_COUNTRY, default=("de" if self.country == "eu" else self.country)): vol.In(
+ ["de", "cn", "us", "ru", "tw", "sg", "in", "i2"]
+ ),
+ vol.Optional(CONF_PREFER_CLOUD, default=self.prefer_cloud): bool,
+ }
+ )
+
+ country_list = ["eu", "cn", "us", "ru", "sg"]
+ if self.account_type == ACCOUNT_TYPE_MOVA:
+ country_list.pop(3)
+ elif self.account_type == ACCOUNT_TYPE_TROUVER:
+ country_list.pop(1)
+ elif self.account_type == ACCOUNT_TYPE_DREAME:
+ country_list.append("kr")
+
return vol.Schema(
{
vol.Required(CONF_USERNAME, default=self.username): str,
vol.Required(CONF_PASSWORD, default=self.password): str,
- vol.Required(CONF_COUNTRY, default=("de" if self.country == "eu" else self.country)): vol.In(
- ["de", "cn", "us", "ru", "tw", "sg", "in", "i2"]
- ),
- vol.Optional(CONF_PREFER_CLOUD, default=self.prefer_cloud): bool,
+ vol.Required(CONF_COUNTRY, default=self.country): vol.In(country_list),
}
)
diff --git a/custom_components/dreame_vacuum/const.py b/custom_components/dreame_vacuum/const.py
index 7cd1cc84..9674a702 100644
--- a/custom_components/dreame_vacuum/const.py
+++ b/custom_components/dreame_vacuum/const.py
@@ -11,9 +11,6 @@
UNIT_AREA: Final = "m²"
UNIT_TIMES: Final = "x"
-ATTR_VALUE: Final = "value"
-ATTR_CALIBRATION = "calibration_points"
-
CONF_NOTIFY: Final = "notify"
CONF_COLOR_SCHEME: Final = "color_scheme"
CONF_ICON_SET: Final = "icon_set"
@@ -25,6 +22,8 @@
CONF_MAP_OBJECTS: Final = "map_objects"
CONF_HIDDEN_MAP_OBJECTS: Final = "hidden_map_objects"
CONF_PREFER_CLOUD: Final = "prefer_cloud"
+CONF_LOW_RESOLUTION: Final = "low_resolution"
+CONF_SQUARE: Final = "square"
CONF_ACCOUNT_TYPE: Final = "account_type"
CONF_DONATED: Final = "donated"
CONF_VERSION: Final = "version"
@@ -35,22 +34,32 @@
"color": "Room Colors",
"icon": "Room Icons",
"name": "Room Names",
+ "name_background": "Room Name Background",
"order": "Room Order",
"suction_level": "Room Suction Level",
"water_volume": "Room Water Volume",
"cleaning_times": "Room Cleaning Times",
"cleaning_mode": "Room Cleaning Mode",
+ "mopping_mode": "Room Mopping Mode",
"path": "Path",
"no_go": "No Go Zones",
"no_mop": "No Mop Zones",
"virtual_wall": "Virtual Walls",
+ "pathway": "Virtual Thresholds",
"active_area": "Active Areas",
"active_point": "Active Points",
"charger": "Charger Icon",
"robot": "Robot Icon",
"cleaning_direction": "Cleaning Direction",
"obstacle": "AI Obstacle",
+ "pet": "Pet",
"carpet": "Carpet Area",
+ "material": "Floor Material",
+ "low_lying_area": "Low-Lying Areas",
+ "furniture": "Furniture",
+ "ramp": "Ramp",
+ "curtain": "Curtain",
+ "cruise_point": "Cruise Points",
}
NOTIFICATION: Final = {
"cleanup_completed": "Cleanup Completed",
@@ -72,12 +81,30 @@
SERVICE_CLEAN_ZONE: Final = "vacuum_clean_zone"
SERVICE_CLEAN_SEGMENT: Final = "vacuum_clean_segment"
SERVICE_CLEAN_SPOT: Final = "vacuum_clean_spot"
+SERVICE_GOTO: Final = "vacuum_goto"
+SERVICE_FOLLOW_PATH: Final = "vacuum_follow_path"
+SERVICE_START_SHORTCUT: Final = "vacuum_start_shortcut"
SERVICE_REQUEST_MAP: Final = "vacuum_request_map"
SERVICE_SELECT_MAP: Final = "vacuum_select_map"
SERVICE_DELETE_MAP: Final = "vacuum_delete_map"
SERVICE_SET_RESTRICTED_ZONE: Final = "vacuum_set_restricted_zone"
+SERVICE_SET_CARPET_AREA: Final = "vacuum_set_carpet_area"
+SERVICE_SET_CARPET_TYPE: Final = "vacuum_set_carpet_type"
+SERVICE_SET_SEGMENT_TYPE: Final = "vacuum_set_segment_type"
+SERVICE_SET_HIDDEN_SEGMENTS: Final = "vacuum_set_hidden_segments"
+SERVICE_SET_FLOOR_MATERIAL: Final = "vacuum_set_floor_material"
+SERVICE_SET_LOW_LYING_AREA: Final = "vacuum_set_low_lying_area"
+SERVICE_SET_FURNITURE: Final = "vacuum_set_furniture"
+SERVICE_SET_CURTAIN: Final = "vacuum_set_curtain"
+SERVICE_SET_MOP_TYPE: Final = "vacuum_set_mop_type"
+SERVICE_SET_VIRTUAL_THRESHOLD: Final = "vacuum_set_virtual_threshold"
+SERVICE_SET_THRESHOLD: Final = "vacuum_set_threshold"
+SERVICE_SET_PREDEFINED_POINTS: Final = "vacuum_set_predefined_points"
SERVICE_MOVE_REMOTE_CONTROL_STEP: Final = "vacuum_remote_control_move_step"
SERVICE_RENAME_MAP: Final = "vacuum_rename_map"
+SERVICE_RESTORE_MAP: Final = "vacuum_restore_map"
+SERVICE_RESTORE_MAP_FROM_FILE: Final = "vacuum_restore_map_from_file"
+SERVICE_BACKUP_MAP: Final = "vacuum_backup_map"
SERVICE_SAVE_TEMPORARY_MAP: Final = "vacuum_save_temporary_map"
SERVICE_DISCARD_TEMPORARY_MAP: Final = "vacuum_discard_temporary_map"
SERVICE_REPLACE_TEMPORARY_MAP: Final = "vacuum_replace_temporary_map"
@@ -86,9 +113,16 @@
SERVICE_RENAME_SEGMENT: Final = "vacuum_rename_segment"
SERVICE_SET_CLEANING_SEQUENCE: Final = "vacuum_set_cleaning_sequence"
SERVICE_SET_CUSTOM_CLEANING: Final = "vacuum_set_custom_cleaning"
-SERVICE_SET_DND: Final = "vacuum_set_dnd"
+SERVICE_SET_CUSTOM_CARPET_CLEANING: Final = "vacuum_set_custom_carpet_cleaning"
SERVICE_INSTALL_VOICE_PACK: Final = "vacuum_install_voice_pack"
SERVICE_RESET_CONSUMABLE: Final = "vacuum_reset_consumable"
+SERVICE_RENAME_SHORTCUT: Final = "vacuum_rename_shortcut"
+SERVICE_DELETE_SHORTCUT: Final = "vacuum_delete_shortcut"
+SERVICE_SET_OBSTACLE_IGNORE: Final = "vacuum_set_obstacle_ignore"
+SERVICE_SET_ROUTER_POSITION: Final = "vacuum_set_router_position"
+SERVICE_SET_PROPERTY: Final = "vacuum_set_property"
+SERVICE_CALL_ACTION: Final = "vacuum_call_action"
+
SERVICE_SELECT_NEXT = "select_select_next"
SERVICE_SELECT_PREVIOUS = "select_select_previous"
SERVICE_SELECT_FIRST = "select_select_first"
@@ -98,11 +132,24 @@
INPUT_VELOCITY: Final = "velocity"
INPUT_MAP_ID: Final = "map_id"
INPUT_MAP_NAME: Final = "map_name"
-INPUT_MAP_URL: Final = "map_url"
+INPUT_FILE_URL: Final = "file_url"
+INPUT_RECOVERY_MAP_INDEX: Final = "recovery_map_index"
INPUT_WALL_ARRAY: Final = "walls"
INPUT_ZONE: Final = "zone"
INPUT_ZONE_ARRAY: Final = "zones"
+INPUT_CARPET_ARRAY: Final = "carpets"
+INPUT_DELETED_CARPET_ARRAY: Final = "deleted_carpets"
+INPUT_VIRTUAL_THRESHOLD_ARRAY: Final = "virtual_thresholds"
+INPUT_PASSABLE_THRESHOLD_ARRAY: Final = "passable_thresholds"
+INPUT_IMPASSABLE_THRESHOLD_ARRAY: Final = "impassable_thresholds"
+INPUT_RAMP_ARRAY: Final = "ramps"
INPUT_REPEATS: Final = "repeats"
+INPUT_CLEANING_MODE: Final = "cleaning_mode"
+INPUT_CUSTOM_MOPPING_ROUTE: Final = "custom_mopping_route"
+INPUT_CLEANING_ROUTE: Final = "cleaning_route"
+INPUT_WETNESS_LEVEL: Final = "wetness_level"
+INPUT_MOP_TEMPERATURE: Final = "mop_temperature"
+INPUT_MOP_PRESSURE: Final = "mop_pressure"
INPUT_SEGMENTS_ARRAY: Final = "segments"
INPUT_SEGMENT: Final = "segment"
INPUT_SEGMENT_ID: Final = "segment_id"
@@ -117,60 +164,82 @@
INPUT_MD5: Final = "md5"
INPUT_SIZE: Final = "size"
INPUT_CLEANING_SEQUENCE: Final = "cleaning_sequence"
-INPUT_DND_ENABLED: Final = "dnd_enabled"
-INPUT_DND_START: Final = "dnd_start"
-INPUT_DND_END: Final = "dnd_end"
INPUT_WATER_VOLUME: Final = "water_volume"
INPUT_CONSUMABLE: Final = "consumable"
INPUT_CYCLE: Final = "cycle"
INPUT_POINTS: Final = "points"
+INPUT_SHORTCUT_ID: Final = "shortcut_id"
+INPUT_SHORTCUT_NAME: Final = "shortcut_name"
+INPUT_X: Final = "x"
+INPUT_Y: Final = "y"
+INPUT_OBSTACLE_IGNORED: Final = "obstacle_ignored"
+INPUT_KEY: Final = "key"
+INPUT_VALUE: Final = "value"
+INPUT_PARAMS: Final = "params"
+INPUT_ID: Final = "id"
+INPUT_TYPE: Final = "type"
+INPUT_OBJECT_TYPE: Final = "object_type"
+INPUT_CARPET_TYPE: Final = "carpet_type"
+INPUT_MATERIAL: Final = "material"
+INPUT_CARPET_CLEANING: Final = "carpet_cleaning"
+INPUT_CARPET_PREFERENCES: Final = "carpet_preferences"
+INPUT_AREA: Final = "area"
+INPUT_FURNITURE_ARRAY: Final = "furnitures"
+INPUT_CURTAIN_ARRAY: Final = "curtains"
+INPUT_MOP_TYPE: Final = "mop_type"
CONSUMABLE_MAIN_BRUSH = "main_brush"
CONSUMABLE_SIDE_BRUSH = "side_brush"
CONSUMABLE_FILTER = "filter"
-CONSUMABLE_SECONDARY_FILTER = "secondary_filter"
+CONSUMABLE_TANK_FILTER = "tank_filter"
CONSUMABLE_SENSOR = "sensor"
CONSUMABLE_MOP_PAD = "mop_pad"
CONSUMABLE_SILVER_ION = "silver_ion"
CONSUMABLE_DETERGENT = "detergent"
+CONSUMABLE_SQUEEGEE = "squeegee"
+CONSUMABLE_ONBOARD_DIRTY_WATER_TANK = "onboard_dirty_water_tank"
+CONSUMABLE_DIRTY_WATER_CHANNEL = "dirty_water_channel"
+CONSUMABLE_DEODORIZER = "deodorizer"
+CONSUMABLE_WHEEL = "wheel"
+CONSUMABLE_SCALE_INHIBITOR = "scale_inhibitor"
+CONSUMABLE_FLUFFING_ROLLER = "fluffing_roller"
+CONSUMABLE_ROLLER_MOP_FILTER = "roller_mop_filter"
+CONSUMABLE_WATER_OUTLET_FILTER = "water_outlet_filter"
NOTIFICATION_ID_DUST_COLLECTION: Final = "dust_collection"
NOTIFICATION_ID_CLEANING_PAUSED: Final = "cleaning_paused"
NOTIFICATION_ID_REPLACE_MAIN_BRUSH: Final = "replace_main_brush"
NOTIFICATION_ID_REPLACE_SIDE_BRUSH: Final = "replace_side_brush"
NOTIFICATION_ID_REPLACE_FILTER: Final = "replace_filter"
+NOTIFICATION_ID_REPLACE_TANK_FILTER: Final = "replace_tank_filter"
NOTIFICATION_ID_CLEAN_SENSOR: Final = "clean_sensor"
NOTIFICATION_ID_REPLACE_MOP: Final = "replace_mop"
NOTIFICATION_ID_SILVER_ION: Final = "silver_ion"
NOTIFICATION_ID_REPLACE_DETERGENT: Final = "replace_detergent"
+NOTIFICATION_ID_REPLACE_SQUEEGEE: Final = "replace_squeegee"
+NOTIFICATION_ID_CLEAN_ONBOARD_DIRTY_WATER_TANK: Final = "clean_onboard_dirty_water_tank"
+NOTIFICATION_ID_CLEAN_DIRTY_WATER_CHANNEL: Final = "clean_dirty_water_channel"
+NOTIFICATION_ID_REPLACE_DEODORIZER = "replace_deodorizer"
+NOTIFICATION_ID_CLEAN_WHEEL = "clean_wheel"
+NOTIFICATION_ID_REPLACE_SCALE_INHIBITOR = "replace_scale_inhibitor"
+NOTIFICATION_ID_CLEAN_FLUFFING_ROLLER = "clean_fluffing_roller"
+NOTIFICATION_ID_CLEAN_ROLLER_MOP_FILTER = "clean_roller_mop_filter"
+NOTIFICATION_ID_CLEAN_WATER_OUTLET_FILTER = "clean_water_outlet_filter"
NOTIFICATION_ID_CLEANUP_COMPLETED: Final = "cleanup_completed"
NOTIFICATION_ID_WARNING: Final = "warning"
+NOTIFICATION_ID_ERROR: Final = "error"
NOTIFICATION_ID_INFORMATION: Final = "information"
NOTIFICATION_ID_CONSUMABLE: Final = "consumable"
-NOTIFICATION_ID_ERROR: Final = "error"
NOTIFICATION_ID_REPLACE_TEMPORARY_MAP: Final = "replace_temporary_map"
+NOTIFICATION_ID_LOW_WATER: Final = "low_water"
+NOTIFICATION_ID_DRAINAGE_STATUS: Final = "drainage_status"
NOTIFICATION_CLEANUP_COMPLETED: Final = "### Cleanup completed"
-NOTIFICATION_MAIN_BRUSH_NO_LIFE_LEFT: Final = (
- "### Main brush must be replaced\nChange main brush and reset the counter."
-)
-NOTIFICATION_SIDE_BRUSH_NO_LIFE_LEFT: Final = (
- "### Side brush must be replaced\nChange side brush and reset the counter."
-)
-NOTIFICATION_FILTER_NO_LIFE_LEFT: Final = "### Filter must be replaced\nChange filter and reset the counter."
-NOTIFICATION_SENSOR_NO_LIFE_LEFT: Final = "### Sensors must be cleaned\nClean sensors and reset the counter."
-NOTIFICATION_MOP_NO_LIFE_LEFT: Final = "### Mop pad must be replaced\nChange mop pad and reset the counter."
-NOTIFICATION_SILVER_ION_LIFE_LEFT: Final = (
- "### Silver Ion Sterilizer Deteriorated.\nPlease replace the silver ion sterilizer and reset the counter."
-)
-NOTIFICATION_DETERGENT_NO_LIFE_LEFT: Final = (
- "### The multi-surface floor cleaner performs well in the deep cleaning of the mop pad and floors, as well as removing dirt, grime and sticky messes.\nThe cleaner will be added automatically while cleaning. It is recommended to check the remaining amount through the app and replace it promptly."
-)
NOTIFICATION_DUST_COLLECTION_NOT_PERFORMED: Final = (
"### Dust collecting (Auto-empty) task not performed\nThe robot will not perform auto-empty tasks during the DND period."
)
NOTIFICATION_RESUME_CLEANING: Final = (
- "### Low battery\nThe robot will automatically resume unfinished cleaning tasks after charging its battery to 80%."
+ "### Resume Cleaning Mode\nThe robot will automatically resume unfinished cleaning tasks after charging its battery to 80%."
)
NOTIFICATION_RESUME_CLEANING_NOT_PERFORMED: Final = (
"### The robot is in the DND period\nRobot will resume cleaning after the DND period ends."
@@ -179,10 +248,14 @@
NOTIFICATION_REPLACE_MULTI_MAP: Final = (
"### A new map has been generated\nMulti-floor maps that can be saved have reached the upper limit. You need to replace or discard map before using it."
)
+NOTIFICATION_DRAINAGE_COMPLETED: Final = "### Drainage completed"
+NOTIFICATION_DRAINAGE_FAILED: Final = "### Drainage failed"
NOTIFICATION_SPONSOR: Final = f"## Do not forget to support the project.{SPONSOR}"
EVENT_TASK_STATUS: Final = "task_status"
EVENT_CONSUMABLE: Final = "consumable"
EVENT_WARNING: Final = "warning"
EVENT_ERROR: Final = "error"
+EVENT_LOW_WATER: Final = "low_water"
EVENT_INFORMATION: Final = "information"
+EVENT_DRAINAGE_STATUS: Final = "drainage_status"
diff --git a/custom_components/dreame_vacuum/coordinator.py b/custom_components/dreame_vacuum/coordinator.py
index 043ab717..ceb5ddde 100644
--- a/custom_components/dreame_vacuum/coordinator.py
+++ b/custom_components/dreame_vacuum/coordinator.py
@@ -3,18 +3,30 @@
from __future__ import annotations
import math
+import time
import traceback
from homeassistant.components import persistent_notification
from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_NAME, CONF_HOST, CONF_TOKEN, CONF_PASSWORD, CONF_USERNAME, ATTR_ENTITY_ID
+from homeassistant.const import (
+ CONF_NAME,
+ CONF_HOST,
+ CONF_TOKEN,
+ CONF_PASSWORD,
+ CONF_USERNAME,
+ ATTR_ENTITY_ID,
+)
from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryError
+from homeassistant.exceptions import ConfigEntryAuthFailed
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import generate_entity_id
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .dreame import DreameVacuumDevice, DreameVacuumProperty, VERSION
-from .dreame.resources import CONSUMABLE_IMAGE
+from .dreame.resources import (
+ CONSUMABLE_IMAGE,
+ DRAINAGE_STATUS_SUCCESS,
+ DRAINAGE_STATUS_FAIL,
+)
from .const import (
DOMAIN,
LOGGER,
@@ -23,63 +35,80 @@
CONF_MAC,
CONF_DID,
CONF_AUTH_KEY,
+ CONF_ACCOUNT_TYPE,
CONF_PREFER_CLOUD,
CONF_MAP_OBJECTS,
CONF_HIDDEN_MAP_OBJECTS,
- CONF_ACCOUNT_TYPE,
CONF_DONATED,
CONF_VERSION,
MAP_OBJECTS,
CONTENT_TYPE,
NOTIFICATION_CLEANUP_COMPLETED,
- NOTIFICATION_MAIN_BRUSH_NO_LIFE_LEFT,
- NOTIFICATION_SIDE_BRUSH_NO_LIFE_LEFT,
- NOTIFICATION_FILTER_NO_LIFE_LEFT,
- NOTIFICATION_SENSOR_NO_LIFE_LEFT,
- NOTIFICATION_MOP_NO_LIFE_LEFT,
- NOTIFICATION_SILVER_ION_LIFE_LEFT,
- NOTIFICATION_DETERGENT_NO_LIFE_LEFT,
NOTIFICATION_DUST_COLLECTION_NOT_PERFORMED,
NOTIFICATION_RESUME_CLEANING,
NOTIFICATION_RESUME_CLEANING_NOT_PERFORMED,
NOTIFICATION_REPLACE_MULTI_MAP,
NOTIFICATION_REPLACE_MAP,
+ NOTIFICATION_DRAINAGE_COMPLETED,
+ NOTIFICATION_DRAINAGE_FAILED,
NOTIFICATION_SPONSOR,
NOTIFICATION_ID_DUST_COLLECTION,
NOTIFICATION_ID_CLEANING_PAUSED,
NOTIFICATION_ID_REPLACE_MAIN_BRUSH,
NOTIFICATION_ID_REPLACE_SIDE_BRUSH,
NOTIFICATION_ID_REPLACE_FILTER,
+ NOTIFICATION_ID_REPLACE_TANK_FILTER,
NOTIFICATION_ID_CLEAN_SENSOR,
NOTIFICATION_ID_REPLACE_MOP,
NOTIFICATION_ID_SILVER_ION,
NOTIFICATION_ID_REPLACE_DETERGENT,
+ NOTIFICATION_ID_REPLACE_SQUEEGEE,
+ NOTIFICATION_ID_CLEAN_ONBOARD_DIRTY_WATER_TANK,
+ NOTIFICATION_ID_CLEAN_DIRTY_WATER_CHANNEL,
+ NOTIFICATION_ID_REPLACE_DEODORIZER,
+ NOTIFICATION_ID_CLEAN_WHEEL,
+ NOTIFICATION_ID_REPLACE_SCALE_INHIBITOR,
+ NOTIFICATION_ID_CLEAN_FLUFFING_ROLLER,
+ NOTIFICATION_ID_CLEAN_ROLLER_MOP_FILTER,
+ NOTIFICATION_ID_CLEAN_WATER_OUTLET_FILTER,
NOTIFICATION_ID_CLEANUP_COMPLETED,
NOTIFICATION_ID_WARNING,
NOTIFICATION_ID_ERROR,
NOTIFICATION_ID_INFORMATION,
NOTIFICATION_ID_CONSUMABLE,
NOTIFICATION_ID_REPLACE_TEMPORARY_MAP,
+ NOTIFICATION_ID_LOW_WATER,
+ NOTIFICATION_ID_DRAINAGE_STATUS,
EVENT_TASK_STATUS,
EVENT_CONSUMABLE,
EVENT_WARNING,
EVENT_ERROR,
EVENT_INFORMATION,
+ EVENT_LOW_WATER,
+ EVENT_DRAINAGE_STATUS,
CONSUMABLE_MAIN_BRUSH,
CONSUMABLE_SIDE_BRUSH,
CONSUMABLE_FILTER,
+ CONSUMABLE_TANK_FILTER,
CONSUMABLE_SENSOR,
CONSUMABLE_MOP_PAD,
CONSUMABLE_SILVER_ION,
CONSUMABLE_DETERGENT,
+ CONSUMABLE_SQUEEGEE,
+ CONSUMABLE_ONBOARD_DIRTY_WATER_TANK,
+ CONSUMABLE_DIRTY_WATER_CHANNEL,
+ CONSUMABLE_DEODORIZER,
+ CONSUMABLE_WHEEL,
+ CONSUMABLE_SCALE_INHIBITOR,
+ CONSUMABLE_FLUFFING_ROLLER,
+ CONSUMABLE_ROLLER_MOP_FILTER,
+ CONSUMABLE_WATER_OUTLET_FILTER,
)
class DreameVacuumDataUpdateCoordinator(DataUpdateCoordinator[DreameVacuumDevice]):
"""Class to manage fetching Dreame Vacuum data from single endpoint."""
- config_entry: ConfigEntry
-
def __init__(
self,
hass: HomeAssistant,
@@ -87,6 +116,7 @@ def __init__(
entry: ConfigEntry,
) -> None:
"""Initialize global Dreame Vacuum data updater."""
+ self._device: DreameVacuumDevice = None
self._token = entry.data[CONF_TOKEN]
self._host = entry.data[CONF_HOST]
self._notify = entry.options.get(CONF_NOTIFY, True)
@@ -96,11 +126,11 @@ def __init__(
self._available = False
self._has_warning = False
self._has_temporary_map = None
+ self._low_water = False
+ self._drainage_status = None
+ self._washing = None
LOGGER.info("Integration loading: %s", entry.data[CONF_NAME])
-
- if CONF_ACCOUNT_TYPE in self._entry.data and self._entry.data[CONF_ACCOUNT_TYPE] != "mi":
- raise ConfigEntryError(f"Account type '{self._entry.data[CONF_ACCOUNT_TYPE]}' is not supported with this version of the integration!")
if entry.options.get(CONF_VERSION) != VERSION:
options = entry.options.copy()
@@ -109,7 +139,7 @@ def __init__(
if CONF_MAP_OBJECTS in entry.options and CONF_HIDDEN_MAP_OBJECTS not in options:
options[CONF_HIDDEN_MAP_OBJECTS] = []
for key in list(MAP_OBJECTS.keys()):
- if key not in options[CONF_MAP_OBJECTS]:
+ if key not in options[CONF_MAP_OBJECTS] and key != "curtain" and key != "ramp":
options[CONF_HIDDEN_MAP_OBJECTS].append(key)
del options[CONF_MAP_OBJECTS]
@@ -123,7 +153,7 @@ def __init__(
)
hass.config_entries.async_update_entry(entry=entry, options=options)
- self.device = DreameVacuumDevice(
+ self._device = DreameVacuumDevice(
entry.data[CONF_NAME],
self._host,
self._token,
@@ -131,23 +161,27 @@ def __init__(
entry.data.get(CONF_USERNAME),
entry.data.get(CONF_PASSWORD),
entry.data.get(CONF_COUNTRY),
- entry.options.get(CONF_PREFER_CLOUD, True),
+ entry.options.get(CONF_PREFER_CLOUD, False),
+ entry.data.get(CONF_ACCOUNT_TYPE, "mi"),
entry.data.get(CONF_DID),
self._auth_key,
)
- self.device.listen(self._dust_collection_changed, DreameVacuumProperty.DUST_COLLECTION)
- self.device.listen(self._error_changed, DreameVacuumProperty.ERROR)
- self.device.listen(self._task_status_changed, DreameVacuumProperty.TASK_STATUS)
- self.device.listen(self._cleaning_paused_changed, DreameVacuumProperty.CLEANING_PAUSED)
- self.device.listen(self.set_updated_data)
- self.device.listen_error(self.set_update_error)
-
- super().__init__(
- hass,
- LOGGER,
- name=DOMAIN,
+ self._device.listen(self._dust_collection_changed, DreameVacuumProperty.DUST_COLLECTION)
+ self._device.listen(self._error_changed, DreameVacuumProperty.ERROR)
+ self._device.listen(self._task_status_changed, DreameVacuumProperty.TASK_STATUS)
+ self._device.listen(self._cleaning_paused_changed, DreameVacuumProperty.CLEANING_PAUSED)
+ self._device.listen(self._low_water_warning_changed, DreameVacuumProperty.LOW_WATER_WARNING)
+ self._device.listen(self._drainage_status_changed, DreameVacuumProperty.DRAINAGE_STATUS)
+ self._device.listen(
+ self._self_wash_base_status_changed,
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
)
+ self._device.listen(self.set_updated_data)
+ self._device.listen_error(self.set_update_error)
+
+ super().__init__(hass, LOGGER, name=DOMAIN)
+
async_dispatcher_connect(
hass,
persistent_notification.SIGNAL_PERSISTENT_NOTIFICATIONS_UPDATED,
@@ -155,29 +189,34 @@ def __init__(
)
def _dust_collection_changed(self, previous_value=None) -> None:
- if previous_value is not None:
- if self.device.status.auto_emptying_not_performed:
- self._fire_event(EVENT_INFORMATION, {EVENT_INFORMATION: NOTIFICATION_ID_DUST_COLLECTION})
+ if self._device.status.auto_emptying_not_performed:
+ self._fire_event(EVENT_INFORMATION, {EVENT_INFORMATION: NOTIFICATION_ID_DUST_COLLECTION})
- self._create_persistent_notification(
- NOTIFICATION_DUST_COLLECTION_NOT_PERFORMED,
- NOTIFICATION_ID_DUST_COLLECTION,
- )
- else:
- self._remove_persistent_notification(NOTIFICATION_ID_DUST_COLLECTION)
+ self._create_persistent_notification(
+ NOTIFICATION_DUST_COLLECTION_NOT_PERFORMED,
+ NOTIFICATION_ID_DUST_COLLECTION,
+ )
+ else:
+ self._remove_persistent_notification(NOTIFICATION_ID_DUST_COLLECTION)
def _cleaning_paused_changed(self, previous_value=None) -> None:
- if previous_value is not None and self.device.status.cleaning_paused:
+ if self._device.status.cleaning_paused:
notification = NOTIFICATION_RESUME_CLEANING
- if self.device.status.battery_level >= 80:
- dnd_remaining = self.device.status.dnd_remaining
+ if self._device.status.battery_level >= 80:
+ dnd_remaining = self._device.status.dnd_remaining
if dnd_remaining:
hour = math.floor(dnd_remaining / 3600)
minute = math.floor((dnd_remaining - hour * 3600) / 60)
notification = f"{NOTIFICATION_RESUME_CLEANING_NOT_PERFORMED}\n## Cleaning will start in {hour} hour(s) and {minute} minutes(s)"
- self._fire_event(EVENT_INFORMATION, {EVENT_INFORMATION: NOTIFICATION_ID_CLEANING_PAUSED})
+ self._fire_event(
+ EVENT_INFORMATION,
+ {EVENT_INFORMATION: NOTIFICATION_ID_CLEANING_PAUSED},
+ )
else:
- self._fire_event(EVENT_INFORMATION, {EVENT_INFORMATION: NOTIFICATION_ID_CLEANING_PAUSED})
+ self._fire_event(
+ EVENT_INFORMATION,
+ {EVENT_INFORMATION: NOTIFICATION_ID_CLEANING_PAUSED},
+ )
self._create_persistent_notification(notification, NOTIFICATION_ID_CLEANING_PAUSED)
else:
@@ -185,88 +224,56 @@ def _cleaning_paused_changed(self, previous_value=None) -> None:
def _task_status_changed(self, previous_value=None) -> None:
if previous_value is not None:
- if self.device.cleanup_completed:
- self._fire_event(EVENT_TASK_STATUS, self.device.status.job)
+ if self._device.status.cleanup_completed:
+ self._fire_event(EVENT_TASK_STATUS, self._device.status.job)
self._create_persistent_notification(NOTIFICATION_CLEANUP_COMPLETED, NOTIFICATION_ID_CLEANUP_COMPLETED)
+ self._check_consumables()
- if self.device.status.main_brush_life == 0:
- self._create_persistent_notification(
- f"{NOTIFICATION_MAIN_BRUSH_NO_LIFE_LEFT}\n})",
- NOTIFICATION_ID_REPLACE_MAIN_BRUSH,
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_MAIN_BRUSH})
- if self.device.status.side_brush_life == 0:
- self._create_persistent_notification(
- f"{NOTIFICATION_SIDE_BRUSH_NO_LIFE_LEFT}\n})",
- NOTIFICATION_ID_REPLACE_SIDE_BRUSH,
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_SIDE_BRUSH})
- if self.device.status.filter_life == 0:
- self._create_persistent_notification(
- f"{NOTIFICATION_FILTER_NO_LIFE_LEFT}\n})",
- NOTIFICATION_ID_REPLACE_FILTER,
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_FILTER})
- if self.device.status.sensor_dirty_life == 0:
- self._create_persistent_notification(
- f"{NOTIFICATION_SENSOR_NO_LIFE_LEFT}\n})",
- NOTIFICATION_ID_CLEAN_SENSOR,
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_SENSOR})
- if self.device.status.mop_life == 0:
- self._create_persistent_notification(
- f"{NOTIFICATION_MOP_NO_LIFE_LEFT}\n})",
- NOTIFICATION_ID_REPLACE_MOP,
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_MOP_PAD})
- if self.device.status.silver_ion_life == 0:
- self._create_persistent_notification(
- f"{NOTIFICATION_SILVER_ION_LIFE_LEFT}\n})",
- NOTIFICATION_ID_SILVER_ION,
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_SILVER_ION})
- if self.device.status.detergent_life == 0:
- self._create_persistent_notification(
- NOTIFICATION_DETERGENT_NO_LIFE_LEFT, NOTIFICATION_ID_REPLACE_DETERGENT
- )
- self._fire_event(EVENT_CONSUMABLE, {EVENT_CONSUMABLE: CONSUMABLE_DETERGENT})
-
- elif previous_value == 0 and not self.device.status.fast_mapping:
- self._fire_event(EVENT_TASK_STATUS, self.device.status.job)
+ elif previous_value == 0 and not self._device.status.fast_mapping and not self._device.status.cruising:
+ self._fire_event(EVENT_TASK_STATUS, self._device.status.job)
+ else:
+ self._check_consumables()
def _error_changed(self, previous_value=None) -> None:
- has_warning = self.device.status.has_warning
+ has_warning = self._device.status.has_warning
+ description = self._device.status.error_description
if has_warning:
+ content = description[0]
self._fire_event(
EVENT_WARNING,
- {EVENT_WARNING: self.device.status.error_description[0], "code": self.device.status.error.value},
+ {EVENT_WARNING: content, "code": self._device.status.error.value},
)
- self._create_persistent_notification(self.device.status.error_description[0], NOTIFICATION_ID_WARNING)
+ if len(description[1]) > 2:
+ content = f"### {content}\n{description[1]}"
+
+ image = self._device.status.error_image
+ if image:
+ content = f"{content}"
+ self._create_persistent_notification(content, NOTIFICATION_ID_WARNING)
elif self._has_warning:
- self._has_warning = False
self._remove_persistent_notification(NOTIFICATION_ID_WARNING)
- if self.device.status.has_error:
- description = self.device.status.error_description
- self._fire_event(EVENT_ERROR, {EVENT_ERROR: description[0], "code": self.device.status.error.value})
+ if self._device.status.has_error:
+ self._fire_event(
+ EVENT_ERROR,
+ {EVENT_ERROR: description[0], "code": self._device.status.error.value},
+ )
- description = f"### {description[0]}\n{description[1]}"
- image = self.device.status.error_image
+ content = f"### {description[0]}\n{description[1]}"
+ image = self._device.status.error_image
if image:
- description = f"{description}"
- self._create_persistent_notification(
- description, f"{NOTIFICATION_ID_ERROR}_{self.device.status.error.value}"
- )
+ content = f"{content}"
+ self._create_persistent_notification(content, f"{NOTIFICATION_ID_ERROR}_{self._device.status.error.value}")
self._has_warning = has_warning
def _has_temporary_map_changed(self, previous_value=None) -> None:
- if self.device.status.has_temporary_map:
+ if self._device.status.has_temporary_map:
self._fire_event(EVENT_WARNING, {EVENT_WARNING: NOTIFICATION_REPLACE_MULTI_MAP})
self._create_persistent_notification(
- NOTIFICATION_REPLACE_MULTI_MAP if self.device.status.multi_map else NOTIFICATION_REPLACE_MAP,
+ NOTIFICATION_REPLACE_MULTI_MAP if self._device.status.multi_map else NOTIFICATION_REPLACE_MAP,
NOTIFICATION_ID_REPLACE_TEMPORARY_MAP,
)
else:
@@ -274,13 +281,172 @@ def _has_temporary_map_changed(self, previous_value=None) -> None:
self._remove_persistent_notification(NOTIFICATION_ID_REPLACE_TEMPORARY_MAP)
+ def _low_water_warning_changed(self, previous_value=None) -> None:
+ low_water_warning = self._device.status.low_water_warning
+ if low_water_warning.value > 0 and (not previous_value or low_water_warning.value > 1):
+ low_water_warning_description = self._device.status.low_water_warning_name_description
+ self._fire_event(
+ EVENT_LOW_WATER,
+ {EVENT_LOW_WATER: low_water_warning_description[0], "code": low_water_warning.value},
+ )
+
+ description = f"### {low_water_warning_description[0]}"
+ if len(low_water_warning_description[1]) > 2:
+ description = f"{description}\n{low_water_warning_description[1]}"
+ self._create_persistent_notification(description, NOTIFICATION_ID_LOW_WATER)
+ elif self._low_water:
+ self._remove_persistent_notification(NOTIFICATION_ID_LOW_WATER)
+
+ self._low_water = self._device.status.low_water
+
+ def _drainage_status_changed(self, previous_value=None) -> None:
+ if self._device.status.draining_complete:
+ success = bool(self._device.status.drainage_status.value == 2)
+ if success:
+ description = f"{NOTIFICATION_DRAINAGE_COMPLETED}\n"
+ else:
+ description = (
+ f"{NOTIFICATION_DRAINAGE_FAILED}\n"
+ )
+
+ self._fire_event(EVENT_DRAINAGE_STATUS, {EVENT_DRAINAGE_STATUS: success})
+ self._create_persistent_notification(description, NOTIFICATION_ID_DRAINAGE_STATUS)
+ elif self._drainage_status:
+ self._remove_persistent_notification(NOTIFICATION_ID_DRAINAGE_STATUS)
+
+ self._drainage_status = self._device.status.draining_complete
+
+ def _self_wash_base_status_changed(self, previous_self_wash_base_status=None) -> None:
+ if self._washing is not None and self._device.status.washing != self._washing and self._device.status.started:
+ self._check_consumables()
+ self._washing = self._device.status.washing
+
+ def _check_consumable(self, consumable, notification_id, property):
+ description = self._device.status.consumable_life_warning_description(property)
+ if description:
+ image = CONSUMABLE_IMAGE.get(consumable)
+ notification = f"### {description[0]}\n{description[1]}"
+ if image:
+ notification = f"{notification}\n"
+ self._create_persistent_notification(
+ notification,
+ notification_id,
+ )
+
+ self._fire_event(
+ EVENT_CONSUMABLE,
+ {
+ EVENT_CONSUMABLE: consumable,
+ "life_left": self._device.get_property(property),
+ },
+ )
+
+ def _check_consumables(self):
+ self._check_consumable(
+ CONSUMABLE_MAIN_BRUSH,
+ NOTIFICATION_ID_REPLACE_MAIN_BRUSH,
+ DreameVacuumProperty.MAIN_BRUSH_LEFT,
+ )
+ self._check_consumable(
+ CONSUMABLE_SIDE_BRUSH,
+ NOTIFICATION_ID_REPLACE_SIDE_BRUSH,
+ DreameVacuumProperty.SIDE_BRUSH_LEFT,
+ )
+ self._check_consumable(
+ CONSUMABLE_FILTER,
+ NOTIFICATION_ID_REPLACE_FILTER,
+ DreameVacuumProperty.FILTER_LEFT,
+ )
+ self._check_consumable(
+ CONSUMABLE_TANK_FILTER,
+ NOTIFICATION_ID_REPLACE_TANK_FILTER,
+ DreameVacuumProperty.TANK_FILTER_LEFT,
+ )
+ if not self._device.capability.disable_sensor_cleaning:
+ self._check_consumable(
+ CONSUMABLE_SENSOR,
+ NOTIFICATION_ID_CLEAN_SENSOR,
+ DreameVacuumProperty.SENSOR_DIRTY_LEFT,
+ )
+ if not self._device.capability.disable_mop_consumable:
+ self._check_consumable(
+ CONSUMABLE_MOP_PAD,
+ NOTIFICATION_ID_REPLACE_MOP,
+ DreameVacuumProperty.MOP_PAD_LEFT,
+ )
+ if self._device.capability.squeegee:
+ self._check_consumable(
+ CONSUMABLE_SQUEEGEE,
+ NOTIFICATION_ID_REPLACE_SQUEEGEE,
+ DreameVacuumProperty.SQUEEGEE_LEFT,
+ )
+ self._check_consumable(
+ CONSUMABLE_ONBOARD_DIRTY_WATER_TANK,
+ NOTIFICATION_ID_CLEAN_ONBOARD_DIRTY_WATER_TANK,
+ DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_LEFT,
+ )
+ self._check_consumable(
+ CONSUMABLE_DIRTY_WATER_CHANNEL,
+ NOTIFICATION_ID_CLEAN_DIRTY_WATER_CHANNEL,
+ DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_LEFT,
+ )
+ if self._device.capability.self_wash_base:
+ self._check_consumable(
+ CONSUMABLE_SILVER_ION,
+ NOTIFICATION_ID_SILVER_ION,
+ DreameVacuumProperty.SILVER_ION_LEFT,
+ )
+ if self._device.capability.detergent:
+ self._check_consumable(
+ CONSUMABLE_DETERGENT,
+ NOTIFICATION_ID_REPLACE_DETERGENT,
+ DreameVacuumProperty.DETERGENT_LEFT,
+ )
+ if self._device.capability.deodorizer:
+ self._check_consumable(
+ CONSUMABLE_DEODORIZER,
+ NOTIFICATION_ID_REPLACE_DEODORIZER,
+ DreameVacuumProperty.DEODORIZER_LEFT,
+ )
+ if self._device.capability.wheel:
+ self._check_consumable(
+ CONSUMABLE_WHEEL,
+ NOTIFICATION_ID_CLEAN_WHEEL,
+ DreameVacuumProperty.WHEEL_DIRTY_LEFT,
+ )
+ if self._device.capability.scale_inhibitor:
+ self._check_consumable(
+ CONSUMABLE_SCALE_INHIBITOR,
+ NOTIFICATION_ID_REPLACE_SCALE_INHIBITOR,
+ DreameVacuumProperty.SCALE_INHIBITOR_LEFT,
+ )
+ if self._device.capability.fluffing_roller:
+ self._check_consumable(
+ CONSUMABLE_FLUFFING_ROLLER,
+ NOTIFICATION_ID_CLEAN_FLUFFING_ROLLER,
+ DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_LEFT,
+ )
+ if self._device.capability.roller_mop_filter:
+ self._check_consumable(
+ CONSUMABLE_ROLLER_MOP_FILTER,
+ NOTIFICATION_ID_CLEAN_ROLLER_MOP_FILTER,
+ DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_LEFT,
+ )
+ if self._device.capability.water_outlet_filter:
+ self._check_consumable(
+ CONSUMABLE_WATER_OUTLET_FILTER,
+ NOTIFICATION_ID_CLEAN_WATER_OUTLET_FILTER,
+ DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_LEFT,
+ )
+
def _create_persistent_notification(self, content, notification_id) -> None:
- if not self.device.disconnected and self.device.device_connected and self._notify:
+ if not self._device.disconnected and self._device.device_connected and self._notify:
if isinstance(self._notify, list):
if notification_id == NOTIFICATION_ID_CLEANUP_COMPLETED:
if NOTIFICATION_ID_CLEANUP_COMPLETED not in self._notify:
return
- elif NOTIFICATION_ID_WARNING in notification_id:
+ notification_id = f"{notification_id}_{int(time.time())}"
+ elif NOTIFICATION_ID_WARNING in notification_id or NOTIFICATION_ID_LOW_WATER in notification_id:
if NOTIFICATION_ID_WARNING not in self._notify:
return
elif NOTIFICATION_ID_ERROR in notification_id:
@@ -292,31 +458,46 @@ def _create_persistent_notification(self, content, notification_id) -> None:
):
if NOTIFICATION_ID_INFORMATION not in self._notify:
return
- elif notification_id != NOTIFICATION_ID_REPLACE_TEMPORARY_MAP:
+ elif (
+ notification_id != NOTIFICATION_ID_REPLACE_TEMPORARY_MAP
+ and notification_id != NOTIFICATION_ID_DRAINAGE_STATUS
+ ):
if NOTIFICATION_ID_CONSUMABLE not in self._notify:
return
persistent_notification.create(
- self.hass,
- content,
- title=self.device.name,
- notification_id=f"{DOMAIN}_{self.device.mac}_{notification_id}",
+ hass=self.hass,
+ message=content,
+ title=self._device.name,
+ notification_id=f"{DOMAIN}_{self._device.mac}_{notification_id}",
)
def _remove_persistent_notification(self, notification_id) -> None:
- persistent_notification.dismiss(self.hass, f"{DOMAIN}_{self.device.mac}_{notification_id}")
+ persistent_notification.dismiss(self.hass, f"{DOMAIN}_{self._device.mac}_{notification_id}")
def _notification_dismiss_listener(self, type, data) -> None:
- if type == persistent_notification.UpdateType.REMOVED and self.device:
+ if type == persistent_notification.UpdateType.REMOVED and self._device:
notifications = self.hass.data.get(persistent_notification.DOMAIN)
if self._has_warning:
- if f"{DOMAIN}_{self.device.mac}_{NOTIFICATION_ID_WARNING}" not in notifications:
+ if f"{DOMAIN}_{self._device.mac}_{NOTIFICATION_ID_WARNING}" not in notifications:
+ if NOTIFICATION_ID_WARNING in self._notify:
+ self._device.clear_warning()
+ self._has_warning = self._device.status.has_warning
+
+ if self._low_water:
+ if f"{DOMAIN}_{self._device.mac}_{NOTIFICATION_ID_LOW_WATER}" not in notifications:
+ if NOTIFICATION_ID_WARNING in self._notify:
+ self._device.clear_warning()
+ self._low_water = self._device.status.low_water
+
+ if self._drainage_status:
+ if f"{DOMAIN}_{self._device.mac}_{NOTIFICATION_ID_DRAINAGE_STATUS}" not in notifications:
if NOTIFICATION_ID_WARNING in self._notify:
- self.device.clear_warning()
- self._has_warning = self.device.status.has_warning
+ self._device.clear_warning()
+ self._drainage_status = self._device.status.draining_complete
def _fire_event(self, event_id, data) -> None:
- event_data = {ATTR_ENTITY_ID: generate_entity_id("vacuum.{}", self.device.name, hass=self.hass)}
+ event_data = {ATTR_ENTITY_ID: generate_entity_id("vacuum.{}", self._device.name, hass=self.hass)}
if data:
event_data.update(data)
self.hass.bus.fire(f"{DOMAIN}_{event_id}", event_data)
@@ -325,27 +506,31 @@ async def _async_update_data(self) -> DreameVacuumDevice:
"""Handle device update. This function is only called once when the integration is added to Home Assistant."""
try:
LOGGER.info("Integration starting...")
- await self.hass.async_add_executor_job(self.device.update)
- if self.device and not self.device.disconnected:
- if self.device.auth_failed:
- self.device.listen(None)
- self.device.disconnect()
+ await self.hass.async_add_executor_job(self._device.update)
+ if self._device and not self._device.disconnected:
+ if self._device.auth_failed:
+ self._device.listen(None)
+ self._device.disconnect()
raise ConfigEntryAuthFailed() from None
- self.device.schedule_update()
+ self._device.schedule_update()
self.async_set_updated_data()
- return self.device
+ return self._device
except Exception as ex:
- if self.device.auth_failed:
+ if self._device.auth_failed:
raise ConfigEntryAuthFailed("Authentication Failed!") from ex
LOGGER.warning("Integration start failed: %s", traceback.format_exc())
- if self.device is not None:
- self.device.listen(None)
- self.device.disconnect()
- del self.device
- self.device = None
+ if self._device is not None:
+ self._device.listen(None)
+ self._device.disconnect()
+ del self._device
+ self._device = None
raise UpdateFailed(ex) from ex
+ @property
+ def device(self) -> DreameVacuumDevice:
+ return self._device
+
def set_update_error(self, ex=None) -> None:
self.hass.loop.call_soon_threadsafe(self.async_set_update_error, ex)
@@ -354,38 +539,40 @@ def set_updated_data(self, device=None) -> None:
@callback
def async_set_updated_data(self, device=None) -> None:
- if self._has_temporary_map != self.device.status.has_temporary_map:
+ if not self._device or not self._device.status:
+ return
+ if self._has_temporary_map != self._device.status.has_temporary_map:
self._has_temporary_map_changed(self._has_temporary_map)
- self._has_temporary_map = self.device.status.has_temporary_map
+ self._has_temporary_map = self._device.status.has_temporary_map
if not self._ready:
self._ready = True
- if (self.device.token and self.device.token != self._token) or (
- self.device.host and self.device.host != self._host
+ if (self._device.token and self._device.token != self._token) or (
+ self._device.host and self._device.host != self._host
):
data = self._entry.data.copy()
- self._host = self.device.host
- self._token = self.device.token
+ self._host = self._device.host
+ self._token = self._device.token
data[CONF_HOST] = self._host
data[CONF_TOKEN] = self._token
+ LOGGER.info("Update Host Config: %s", self._host)
self.hass.config_entries.async_update_entry(self._entry, data=data)
- if self.device._protocol.cloud and self.device._protocol.cloud.auth_key != self._auth_key:
- self._auth_key = self.device._protocol.cloud.auth_key
+ if self._device._protocol.cloud and self._device._protocol.cloud.auth_key != self._auth_key:
+ self._auth_key = self._device._protocol.cloud.auth_key
data = self._entry.data.copy()
data[CONF_AUTH_KEY] = self._auth_key
self.hass.config_entries.async_update_entry(self._entry, data=data)
- elif self.device.auth_failed:
+ elif self._device.auth_failed:
## Reload entry to trigger reauth and unload
self.hass.config_entries.async_schedule_reload(self._entry.entry_id)
return
- self._available = self.device.available
-
- super().async_set_updated_data(self.device)
+ self._available = self._device and self._device.available
+ super().async_set_updated_data(self._device)
@callback
def async_set_update_error(self, ex) -> None:
if self._available:
- self._available = self.device.available
+ self._available = self._device and self._device.available
super().async_set_update_error(ex)
diff --git a/custom_components/dreame_vacuum/dreame/__init__.py b/custom_components/dreame_vacuum/dreame/__init__.py
index 54f8d169..eb387d14 100644
--- a/custom_components/dreame_vacuum/dreame/__init__.py
+++ b/custom_components/dreame_vacuum/dreame/__init__.py
@@ -1,7 +1,10 @@
-VERSION = "v1.0.8"
+VERSION = "v2.0.0b22"
from .types import (
DreameVacuumProperty,
+ DreameVacuumAutoSwitchProperty,
+ DreameVacuumStrAIProperty,
+ DreameVacuumAIProperty,
DreameVacuumAction,
DreameVacuumRelocationStatus,
DreameVacuumAutoEmptyStatus,
@@ -10,24 +13,68 @@
DreameVacuumWaterVolume,
DreameVacuumMopPadHumidity,
DreameVacuumCarpetSensitivity,
+ DreameVacuumCarpetCleaning,
DreameVacuumTaskStatus,
DreameVacuumState,
- DreameVacuumSelfCleanArea,
DreameVacuumMopWashLevel,
+ DreameVacuumMopCleanFrequency,
DreameVacuumMoppingType,
+ DreameVacuumStreamStatus,
+ DreameVacuumVoiceAssistantLanguage,
+ DreameVacuumMopPressure,
+ DreameVacuumMopTemperature,
+ DreameVacuumLowLyingAreaFrequency,
+ DreameVacuumScraperFrequency,
+ DreameVacuumWiderCornerCoverage,
+ DreameVacuumMopPadSwing,
+ DreameVacuumMopExtendFrequency,
+ DreameVacuumSecondCleaning,
+ DreameVacuumCleaningRoute,
+ DreameVacuumCustomMoppingRoute,
+ DreameVacuumSelfCleanFrequency,
+ DreameVacuumAutoEmptyMode,
+ DreameVacuumAutoEmptyModeV2,
+ DreameVacuumCleanGenius,
+ DreameVacuumCleanGeniusMode,
+ DreameVacuumFloorMaterial,
+ DreameVacuumFloorMaterialDirection,
+ DreameVacuumSegmentVisibility,
+ DreameVacuumDrainageStatus,
+ DreameVacuumLowWaterWarning,
+ DreameVacuumTaskType,
+ DreameVacuumWashingMode,
+ DreameVacuumWaterTemperature,
+ DreameVacuumAutoLDSCoverage,
PROPERTY_AVAILABILITY,
ACTION_AVAILABILITY,
MAP_COLOR_SCHEME_LIST,
MAP_ICON_SET_LIST,
)
from .const import (
+ DEVICE_INFO,
SUCTION_LEVEL_CODE_TO_NAME,
WATER_VOLUME_CODE_TO_NAME,
MOP_PAD_HUMIDITY_CODE_TO_NAME,
+ CLEANING_MODE_CODE_TO_NAME,
+ FLOOR_MATERIAL_CODE_TO_NAME,
+ FLOOR_MATERIAL_DIRECTION_CODE_TO_NAME,
+ SEGMENT_VISIBILITY_CODE_TO_NAME,
PROPERTY_TO_NAME,
ACTION_TO_NAME,
SUCTION_LEVEL_QUIET,
+ STATUS_CODE_TO_NAME,
+ CUSTOM_MOPPING_ROUTE_TO_NAME,
+ CLEANING_ROUTE_TO_NAME,
+ MOP_PRESSURE_TO_NAME,
+ MOP_TEMPERATURE_TO_NAME,
+ LOW_LYING_AREA_FREQUENCY_TO_NAME,
+ SCRAPER_FREQUENCY_TO_NAME,
)
from .device import DreameVacuumDevice
from .protocol import DreameVacuumProtocol
-from .exceptions import DeviceException, DeviceUpdateFailedException, InvalidActionException, InvalidValueException
+from .exceptions import (
+ DeviceException,
+ DeviceUpdateFailedException,
+ InvalidActionException,
+ InvalidValueException,
+)
\ No newline at end of file
diff --git a/custom_components/dreame_vacuum/dreame/const.py b/custom_components/dreame_vacuum/dreame/const.py
index 6dad7e1e..c9f320ef 100644
--- a/custom_components/dreame_vacuum/dreame/const.py
+++ b/custom_components/dreame_vacuum/dreame/const.py
@@ -5,20 +5,59 @@
DreameVacuumState,
DreameVacuumWaterTank,
DreameVacuumCarpetSensitivity,
+ DreameVacuumCarpetCleaning,
DreameVacuumStatus,
DreameVacuumErrorCode,
DreameVacuumRelocationStatus,
DreameVacuumDustCollection,
DreameVacuumAutoEmptyStatus,
+ DreameVacuumMapRecoveryStatus,
+ DreameVacuumMapBackupStatus,
DreameVacuumSelfWashBaseStatus,
DreameVacuumSuctionLevel,
DreameVacuumWaterVolume,
DreameVacuumMopPadHumidity,
DreameVacuumCleaningMode,
- DreameVacuumSelfCleanArea,
DreameVacuumMopWashLevel,
+ DreameVacuumMopCleanFrequency,
DreameVacuumMoppingType,
+ DreameVacuumStreamStatus,
+ DreameVacuumVoiceAssistantLanguage,
+ DreameVacuumMopPressure,
+ DreameVacuumMopTemperature,
+ DreameVacuumLowLyingAreaFrequency,
+ DreameVacuumScraperFrequency,
+ DreameVacuumWiderCornerCoverage,
+ DreameVacuumMopPadSwing,
+ DreameVacuumMopExtendFrequency,
+ DreameVacuumSecondCleaning,
+ DreameVacuumCleaningRoute,
+ DreameVacuumCustomMoppingRoute,
+ DreameVacuumSelfCleanFrequency,
+ DreameVacuumAutoEmptyMode,
+ DreameVacuumAutoEmptyModeV2,
+ DreameVacuumCleanGenius,
+ DreameVacuumCleanGeniusMode,
+ DreameVacuumWashingMode,
+ DreameVacuumWaterTemperature,
+ DreameVacuumAutoLDSCoverage,
+ DreameVacuumFloorMaterial,
+ DreameVacuumFloorMaterialDirection,
+ DreameVacuumSegmentVisibility,
+ DreameVacuumDrainageStatus,
+ DreameVacuumLowWaterWarning,
+ DreameVacuumTaskType,
+ DreameVacuumCleanWaterTankStatus,
+ DreameVacuumDirtyWaterTankStatus,
+ DreameVacuumDustBagStatus,
+ DreameVacuumDetergentStatus,
+ DreameVacuumHotWaterStatus,
+ DreameVacuumStationDrainageStatus,
+ DreameVacuumDustBagDryingStatus,
DreameVacuumProperty,
+ DreameVacuumAIProperty,
+ DreameVacuumStrAIProperty,
+ DreameVacuumAutoSwitchProperty,
DreameVacuumAction,
)
@@ -38,7 +77,9 @@
CLEANING_MODE_SWEEPING: Final = "sweeping"
CLEANING_MODE_MOPPING: Final = "mopping"
CLEANING_MODE_SWEEPING_AND_MOPPING: Final = "sweeping_and_mopping"
+CLEANING_MODE_MOPPING_AFTER_SWEEPING: Final = "mopping_after_sweeping"
+STATE_NOT_SET: Final = "not_set"
STATE_UNKNOWN: Final = "unknown"
STATE_SWEEPING: Final = "sweeping"
STATE_IDLE: Final = "idle"
@@ -49,12 +90,50 @@
STATE_MOPPING: Final = "mopping"
STATE_DRYING: Final = "drying"
STATE_WASHING: Final = "washing"
-STATE_RETURNING_WASHING: Final = "returning_to_washing"
+STATE_RETURNING_WASH: Final = "returning_to_wash"
STATE_BUILDING: Final = "building"
STATE_SWEEPING_AND_MOPPING: Final = "sweeping_and_mopping"
STATE_CHARGING_COMPLETED: Final = "charging_completed"
STATE_UPGRADING: Final = "upgrading"
+STATE_CLEAN_SUMMON: Final = "clean_summon"
+STATE_STATION_RESET: Final = "station_reset"
+STATE_RETURNING_INSTALL_MOP: Final = "returning_install_mop"
+STATE_RETURNING_REMOVE_MOP: Final = "returning_remove_mop"
+STATE_WATER_CHECK: Final = "water_check"
+STATE_CLEAN_ADD_WATER: Final = "clean_add_water"
+STATE_WASHING_PAUSED: Final = "washing_paused"
+STATE_AUTO_EMPTYING: Final = "auto_emptying"
+STATE_REMOTE_CONTROL: Final = "remote_control"
+STATE_SMART_CHARGING: Final = "smart_charging"
+STATE_SECOND_CLEANING: Final = "second_cleaning"
+STATE_HUMAN_FOLLOWING: Final = "human_following"
+STATE_SPOT_CLEANING: Final = "spot_cleaning"
+STATE_RETURNING_AUTO_EMPTY: Final = "returning_auto_empty"
+STATE_WAITING_FOR_TASK: Final = "waiting_for_task"
+STATE_STATION_CLEANING: Final = "station_cleaning"
+STATE_RETURNING_TO_DRAIN: Final = "returning_to_drain"
+STATE_DRAINING: Final = "draining"
+STATE_AUTO_WATER_DRAINING: Final = "auto_water_draining"
+STATE_EMPTYING: Final = "emptying"
+STATE_DUST_BAG_DRYING: Final = "dust_bag_drying"
+STATE_DUST_BAG_DRYING_PAUSED: Final = "dust_bag_drying_paused"
+STATE_HEADING_TO_EXTRA_CLEANING: Final = "heading_to_extra_cleaning"
+STATE_EXTRA_CLEANING: Final = "extra_cleaning"
+STATE_FINDING_PET_PAUSED: Final = "finding_pet_paused"
+STATE_FINDING_PET: Final = "finding_pet"
+STATE_SHORTCUT: Final = "shortcut"
+STATE_MONITORING: Final = "monitoring"
+STATE_MONITORING_PAUSED: Final = "monitoring_paused"
+STATE_INITIAL_DEEP_CLEANING: Final = "initial_deep_cleaning"
+STATE_INITIAL_DEEP_CLEANING_PAUSED: Final = "initial_deep_cleaning_paused"
+STATE_SANITIZING: Final = "sanitizing"
+STATE_SANITIZING_WITH_DRY: Final = "sanitizing_with_dry"
+STATE_CHANGING_MOP: Final = "changing_mop"
+STATE_CHANGING_MOP_PAUSED: Final = "changing_mop_paused"
+STATE_FLOOR_MAINTAINING: Final = "floor_maintaining"
+STATE_FLOOR_MAINTAINING_PAUSED: Final = "floor_maintaining_paused"
STATE_UNAVAILABLE: Final = "unavailable"
+STATE_OFF: Final = "off"
STATE_CLEANING: Final = "cleaning"
STATE_DOCKED: Final = "docked"
@@ -74,13 +153,18 @@
TASK_STATUS_ZONE_MOPPING_PAUSE: Final = "zone_mopping_paused"
TASK_STATUS_SEGMENT_MOPPING_PAUSE: Final = "room_mopping_paused"
TASK_STATUS_AUTO_MOPPING_PAUSE: Final = "mopping_paused"
-TASK_STATUS_MONITOR_CRUISE: Final = "monitor_cruise"
-TASK_STATUS_MONITOR_CRUISE_PAUSE: Final = "monitor_cruise_pause"
-TASK_STATUS_MONITOR_SPOT: Final = "monitor_spot"
-TASK_STATUS_MONITOR_SPOT_PAUSE: Final = "monitor_spot_pause"
-TASK_STATUS_SUMMON_CLEAN_PAUSE: Final = "summon_clean_pause"
+TASK_STATUS_CRUISING_PATH: Final = "cruising_path"
+TASK_STATUS_CRUISING_PATH_PAUSED: Final = "cruising_path_paused"
+TASK_STATUS_CRUISING_POINT: Final = "cruising_point"
+TASK_STATUS_CRUISING_POINT_PAUSED: Final = "cruising_point_paused"
+TASK_STATUS_SUMMON_CLEAN_PAUSED: Final = "summon_clean_paused"
TASK_STATUS_RETURNING_INSTALL_MOP: Final = "returning_to_install_mop"
TASK_STATUS_RETURNING_REMOVE_MOP: Final = "returning_to_remove_mop"
+TASK_STATUS_STATION_CLEANING: Final = "station_cleaning"
+TASK_STATUS_PET_FINDING: Final = "pet_finding"
+TASK_STATUS_AUTO_CLEANING_WASHING_PAUSED: Final = "auto_cleaning_washing_paused"
+TASK_STATUS_AREA_CLEANING_WASHING_PAUSED: Final = "area_cleaning_washing_paused"
+TASK_STATUS_CUSTOM_CLEANING_WASHING_PAUSED: Final = "custom_cleaning_washing_paused"
STATUS_CLEANING: Final = "cleaning"
STATUS_FOLLOW_WALL: Final = "follow_wall_cleaning"
@@ -93,16 +177,19 @@
STATUS_ERROR: Final = "error"
STATUS_REMOTE_CONTROL: Final = "remote_control"
STATUS_SLEEP: Final = "sleeping"
-STATUS_SELF_TEST: Final = "self_test"
+STATUS_SELF_REPAIR: Final = "self_repair"
STATUS_FACTORY_FUNC_TEST: Final = "factory_test"
STATUS_STANDBY: Final = "standby"
STATUS_SEGMENT_CLEANING: Final = "room_cleaning"
STATUS_ZONE_CLEANING: Final = "zone_cleaning"
STATUS_SPOT_CLEANING: Final = "spot_cleaning"
STATUS_FAST_MAPPING: Final = "fast_mapping"
-STATUS_MONITOR_CRUISE: Final = "monitor_cruise"
-STATUS_MONITOR_SPOT: Final = "monitor_spot"
+STATUS_CRUISING_PATH: Final = "cruising_path"
+STATUS_CRUISING_POINT: Final = "cruising_point"
STATUS_SUMMON_CLEAN: Final = "summon_clean"
+STATUS_SHORTCUT: Final = "shortcut"
+STATUS_PERSON_FOLLOW: Final = "person_follow"
+STATUS_WATER_CHECK: Final = "water_check"
RELOCATION_STATUS_LOCATED: Final = "located"
RELOCATION_STATUS_LOCATING: Final = "locating"
@@ -120,6 +207,14 @@
AUTO_EMPTY_STATUS_ACTIVE: Final = "active"
AUTO_EMPTY_STATUS_NOT_PERFORMED: Final = "not_performed"
+MAP_RECOVERY_STATUS_RUNNING: Final = "running"
+MAP_RECOVERY_STATUS_SUCCESS: Final = "success"
+MAP_RECOVERY_STATUS_FAIL: Final = "fail"
+
+MAP_BACKUP_STATUS_RUNNING: Final = "running"
+MAP_BACKUP_STATUS_SUCCESS: Final = "success"
+MAP_BACKUP_STATUS_FAIL: Final = "fail"
+
SELF_WASH_BASE_STATUS_WASHING: Final = "washing"
SELF_WASH_BASE_STATUS_DRYING: Final = "drying"
SELF_WASH_BASE_STATUS_PAUSED: Final = "paused"
@@ -127,27 +222,180 @@
SELF_WASH_BASE_STATUS_CLEAN_ADD_WATER: Final = "clean_add_water"
SELF_WASH_BASE_STATUS_ADDING_WATER: Final = "adding_water"
-SELF_AREA_CLEAN_FIVE_SQUARE_METERS: Final = "five_square_meters"
-SELF_AREA_CLEAN_TEN_SQUARE_METERS: Final = "ten_square_meters"
-SELF_AREA_CLEAN_FIFTEEN_SQUARE_METERS: Final = "fifteen_square_meters"
-SELF_AREA_CLEAN_SINGLE_ZONE: Final = "single_zone"
-
MOP_WASH_LEVEL_DEEP: Final = "deep"
MOP_WASH_LEVEL_DAILY: Final = "daily"
MOP_WASH_LEVEL_WATER_SAVING: Final = "water_saving"
+MOP_CLEAN_FREQUENCY_BY_ROOM: Final = "by_room"
+MOP_CLEAN_FREQUENCY_FIVE_SQUARE_METERS: Final = "5m²"
+MOP_CLEAN_FREQUENCY_EIGHT_SQUARE_METERS: Final = "8m²"
+MOP_CLEAN_FREQUENCY_TEN_SQUARE_METERS: Final = "10m²"
+MOP_CLEAN_FREQUENCY_FIFTEEN_SQUARE_METERS: Final = "15m²"
+MOP_CLEAN_FREQUENCY_TWENTY_SQUARE_METERS: Final = "20m²"
+MOP_CLEAN_FREQUENCY_TWENTYFIVE_SQUARE_METERS: Final = "25m²"
+
MOPPING_TYPE_DEEP: Final = "deep"
MOPPING_TYPE_DAILY: Final = "daily"
MOPPING_TYPE_ACCURATE: Final = "accurate"
+STREAM_STATUS_VIDEO: Final = "video"
+STREAM_STATUS_AUDIO: Final = "audio"
+STREAM_STATUS_RECORDING: Final = "recording"
+
+VOICE_ASSISTANT_LANGUAGE_DEFAULT: Final = "default"
+VOICE_ASSISTANT_LANGUAGE_ENGLISH: Final = "english"
+VOICE_ASSISTANT_LANGUAGE_GERMAN: Final = "german"
+VOICE_ASSISTANT_LANGUAGE_RUSSIAN: Final = "russian"
+VOICE_ASSISTANT_LANGUAGE_ITALIAN: Final = "italian"
+VOICE_ASSISTANT_LANGUAGE_FRENCH: Final = "french"
+VOICE_ASSISTANT_LANGUAGE_KOREAN: Final = "korean"
+VOICE_ASSISTANT_LANGUAGE_CHINESE: Final = "chinese"
+
WATER_TANK_INSTALLED: Final = "installed"
WATER_TANK_NOT_INSTALLED: Final = "not_installed"
WATER_TANK_MOP_INSTALLED: Final = "mop_installed"
+WATER_TANK_MOP_IN_STATION: Final = "mop_in_station"
CARPET_SENSITIVITY_LOW: Final = "low"
CARPET_SENSITIVITY_MEDIUM: Final = "medium"
CARPET_SENSITIVITY_HIGH: Final = "high"
+CARPET_CLEANING_AVOIDANCE: Final = "avoidance"
+CARPET_CLEANING_ADAPTATION: Final = "adaptation"
+CARPET_CLEANING_REMOVE_MOP: Final = "remove_mop"
+CARPET_CLEANING_ADAPTATION_WITHOUT_ROUTE: Final = "adaptation_without_route"
+CARPET_CLEANING_VACUUM_AND_MOP: Final = "vacuum_and_mop"
+CARPET_CLEANING_IGNORE: Final = "ignore"
+CARPET_CLEANING_CROSS: Final = "cross"
+
+WIDER_CORNER_COVERAGE_LOW_FREQUENCY: Final = "low_frequency"
+WIDER_CORNER_COVERAGE_HIGH_FREQUENCY: Final = "high_frequency"
+
+MOP_PAD_SWING_AUTO: Final = "auto"
+MOP_PAD_SWING_DAILY: Final = "daily"
+MOP_PAD_SWING_WEEKLY: Final = "weekly"
+
+MOP_EXTEND_FREQUENCY_STANDARD: Final = "standard"
+MOP_EXTEND_FREQUENCY_INTELLIGENT: Final = "intelligent"
+MOP_EXTEND_FREQUENCY_HIGH: Final = "high"
+
+SECOND_CLEANING_IN_DEEP_MODE: Final = "in_deep_mode"
+SECOND_CLEANING_IN_ALL_MODES: Final = "in_all_modes"
+
+ROUTE_QUICK: Final = "quick"
+ROUTE_STANDARD: Final = "standard"
+ROUTE_INTENSIVE: Final = "intensive"
+ROUTE_DEEP: Final = "deep"
+ROUTE_OFF: Final = "off"
+
+CLEANGENIUS_ROUTINE_CLEANING: Final = "routine_cleaning"
+CLEANGENIUS_DEEP_CLEANING: Final = "deep_cleaning"
+
+CLEANGENIUS_MODE_VACUUM_AND_MOP: Final = "vacuum_and_mop"
+CLEANGENIUS_MODE_MOP_AFTER_VACUUM: Final = "mop_after_vacuum"
+
+WASHING_MODE_LIGHT: Final = "light"
+WASHING_MODE_STANDARD: Final = "standard"
+WASHING_MODE_DEEP: Final = "deep"
+WASHING_MODE_ULTRA_WASHING: Final = "ultra_washing"
+
+WATER_TEMPERATURE_NORMAL: Final = "normal"
+WATER_TEMPERATURE_MILD: Final = "mild"
+WATER_TEMPERATURE_WARM: Final = "warm"
+WATER_TEMPERATURE_HOT: Final = "hot"
+WATER_TEMPERATURE_MAX: Final = "max"
+
+SELF_CLEAN_FREQUENCY_BY_AREA: Final = "by_area"
+SELF_CLEAN_FREQUENCY_BY_TIME: Final = "by_time"
+SELF_CLEAN_FREQUENCY_BY_ROOM: Final = "by_room"
+SELF_CLEAN_FREQUENCY_INTELLIGENT: Final = "intelligent"
+
+AUTO_EMPTY_MODE_STANDARD: Final = "standard"
+AUTO_EMPTY_MODE_HIGH_FREQUENCY: Final = "high_frequency"
+AUTO_EMPTY_MODE_LOW_FREQUENCY: Final = "low_frequency"
+AUTO_EMPTY_MODE_CUSTOM_FREQUENCY: Final = "custom_frequency"
+AUTO_EMPTY_MODE_INTELLIGENT: Final = "intelligent"
+
+FLOOR_MATERIAL_NONE: Final = "none"
+FLOOR_MATERIAL_TILE: Final = "tile"
+FLOOR_MATERIAL_WOOD: Final = "wood"
+FLOOR_MATERIAL_MEDIUM_PILE_CARPET: Final = "medium_pile_carpet"
+FLOOR_MATERIAL_LOW_PILE_CARPET: Final = "low_pile_carpet"
+FLOOR_MATERIAL_CARPET: Final = "carpet"
+
+FLOOR_MATERIAL_DIRECTION_VERTICAL: Final = "vertical"
+FLOOR_MATERIAL_DIRECTION_HORIZONTAL: Final = "horizontal"
+
+SEGMENT_VISIBILITY_VISIBLE: Final = "visible"
+SEGMENT_VISIBILITY_HIDDEN: Final = "hidden"
+
+DRAINAGE_STATUS_DRAINING: Final = "draining"
+DRAINAGE_STATUS_DRAINING_SUCCESS: Final = "draining_successful"
+DRAINAGE_STATUS_DRAINING_FAILED: Final = "draining_failed"
+
+LOW_WATER_WARNING_NO_WARNING: Final = "no_warning"
+LOW_WATER_WARNING_NO_WATER_LEFT_DISMISS: Final = "no_water_left_dismiss"
+LOW_WATER_WARNING_NO_WATER_LEFT: Final = "no_water_left"
+LOW_WATER_WARNING_NO_WATER_LEFT_AFTER_CLEAN: Final = "no_water_left_after_clean"
+LOW_WATER_WARNING_NO_WATER_FOR_CLEAN: Final = "no_water_for_clean"
+LOW_WATER_WARNING_LOW_WATER: Final = "low_water"
+LOW_WATER_WARNING_TANK_NOT_INSTALLED: Final = "tank_not_installed"
+
+TASK_TYPE_STANDARD: Final = "standard"
+TASK_TYPE_STANDARD_PAUSED: Final = "standard_paused"
+TASK_TYPE_CUSTOM: Final = "custom"
+TASK_TYPE_CUSTOM_PAUSED: Final = "custom_paused"
+TASK_TYPE_SHORTCUT: Final = "shortcut"
+TASK_TYPE_SHORTCUT_PAUSED: Final = "shortcut_paused"
+TASK_TYPE_SCHEDULED: Final = "scheduled"
+TASK_TYPE_SCHEDULED_PAUSED: Final = "scheduled_paused"
+TASK_TYPE_SMART: Final = "smart"
+TASK_TYPE_SMART_PAUSED: Final = "smart_paused"
+TASK_TYPE_PARTIAL: Final = "partial"
+TASK_TYPE_PARTIAL_PAUSED: Final = "partial_paused"
+TASK_TYPE_SUMMON: Final = "summon"
+TASK_TYPE_SUMMON_PAUSED: Final = "summon_paused"
+TASK_TYPE_WATER_STAIN: Final = "water_stain"
+TASK_TYPE_WATER_STAIN_PAUSED: Final = "water_stain_paused"
+TASK_TYPE_BOOSTED_EDGE_CLEANING: Final = "boosted_edge_cleaning"
+TASK_TYPE_HAIR_COMPRESSING: Final = "hair_compressing"
+TASK_TYPE_LARGE_PARTICLE_CLEANING: Final = "large_particle_cleaning"
+TASK_TYPE_INTENSIVE_STAIN_CLEANING: Final = "intensive_stain_cleaning"
+TASK_TYPE_STAIN_CLEANING: Final = "stain_cleaning"
+TASK_TYPE_INITIAL_DEEP_CLEANING: Final = "initial_deep_cleaning"
+TASK_TYPE_INITIAL_DEEP_CLEANING_PAUSED: Final = "initial_deep_cleaning_paused"
+TASK_TYPE_MOP_PAD_HEATING: Final = "mop_pad_heating"
+TASK_TYPE_CLEANING_AFTER_MAPPING: Final = "cleaning_after_mapping"
+TASK_TYPE_SMALL_PARTICLE_CLEANING: Final = "small_particle_cleaning"
+TASK_TYPE_CHANGING_MOP: Final = "changing_mop"
+TASK_TYPE_CHANGING_MOP_PAUSED: Final = "changing_mop_paused"
+TASK_TYPE_FLOOR_MAINTAINING: Final = "floor_maintaining"
+TASK_TYPE_FLOOR_MAINTAINING_PAUSED: Final = "floor_maintaining_paused"
+TASK_TYPE_WOOD_FLOOR_MAINTAINING: Final = "wood_floor_maintaining"
+
+CLEAN_WATER_TANK_STATUS_INSTALLED: Final = "installed"
+CLEAN_WATER_TANK_STATUS_NOT_INSTALLED: Final = "not_installed"
+CLEAN_WATER_TANK_STATUS_LOW_WATER: Final = "low_water"
+
+DIRTY_WATER_TANK_STATUS_INSTALLED: Final = "installed"
+DIRTY_WATER_TANK_STATUS_NOT_INSTALLED_OR_FULL: Final = "not_installed_or_full"
+
+DUST_BAG_STATUS_INSTALLED: Final = "installed"
+DUST_BAG_STATUS_NOT_INSTALLED: Final = "not_installed"
+DUST_BAG_STATUS_CHECK: Final = "check"
+
+AUTO_LDS_COVERAGE_SECURITY: Final = "security"
+AUTO_LDS_COVERAGE_EXTREME: Final = "extreme"
+
+DETERGENT_STATUS_INSTALLED: Final = "installed"
+DETERGENT_STATUS_DISABLED: Final = "disabled"
+DETERGENT_STATUS_LOW_DETERGENT: Final = "low_detergent"
+
+HOT_WATER_STATUS_DISABLED: Final = "disabled"
+HOT_WATER_STATUS_ENABLED: Final = "enabled"
+
+STATION_DRAINAGE_STATUS_DRAINING: Final = "draining"
+
ERROR_NO_ERROR: Final = "no_error"
ERROR_DROP: Final = "drop"
ERROR_CLIFF: Final = "cliff"
@@ -209,6 +457,26 @@
ERROR_REMOVE_MOP: Final = "remove_mop"
ERROR_MOP_REMOVED: Final = "mop_removed"
ERROR_MOP_PAD_STOP_ROTATE: Final = "mop_pad_stop_rotate"
+ERROR_MOP_INSTALL_FAILED: Final = "mop_install_failed"
+ERROR_LOW_BATTERY_TURN_OFF: Final = "low_battery_turn_off"
+ERROR_DIRTY_TANK_NOT_INSTALLED: Final = "dirty_tank_not_installed"
+ERROR_ROBOT_IN_HIDDEN_ROOM: Final = "robot_in_hidden_room"
+ERROR_LDS_FAILED_TO_LIFT: Final = "lds_failed_to_lift"
+ERROR_ROBOT_STUCK: Final = "robot_stuck"
+ERROR_SLIPPERY_FLOOR: Final = "slippery_floor"
+ERROR_CHECK_MOP_INSTALL: Final = "check_mop_install"
+ERROR_DIRTY_WATER_TANK_FULL: Final = "dirty_water_tank_full"
+ERROR_RETRACTABLE_LEG_STUCK: Final = "retractable_leg_stuck"
+ERROR_INTERNAL_ERROR: Final = "internal_error"
+ERROR_ROBOT_STUCK_ON_TABLES: Final = "robot_stuck_on_tables"
+ERROR_ROBOT_STUCK_ON_PASSAGE: Final = "robot_stuck_on_passage"
+ERROR_ROBOT_STUCK_ON_THRESHOLD: Final = "robot_stuck_on_threshold"
+ERROR_ROBOT_STUCK_ON_LOW_LYING_AREA: Final = "robot_stuck_on_low_lying_area"
+ERROR_ROBOT_STUCK_ON_RAMP: Final = "robot_stuck_on_ramp"
+ERROR_ROBOT_STUCK_ON_OBSTACLE: Final = "robot_stuck_on_obstacle"
+ERROR_ROBOT_STUCK_ON_PET: Final = "robot_stuck_on_pet"
+ERROR_ROBOT_STUCK_ON_SLIPPERY_SURFACE: Final = "robot_stuck_on_slippery_surface"
+ERROR_ROBOT_STUCK_ON_CARPET: Final = "robot_stuck_on_carpet"
ERROR_BIN_FULL: Final = "bin_full"
ERROR_BIN_OPEN: Final = "bin_open"
ERROR_WATER_TANK: Final = "water_tank"
@@ -220,39 +488,132 @@
ERROR_WET_MOP_PAD: Final = "wet_mop_pad"
ERROR_CLEAN_MOP_PAD: Final = "clean_mop_pad"
ERROR_CLEAN_TANK_LEVEL: Final = "clean_tank_level"
+ERROR_STATION_DISCONNECTED: Final = "station_disconnected"
ERROR_DIRTY_TANK_LEVEL: Final = "dirty_tank_level"
ERROR_WASHBOARD_LEVEL: Final = "washboard_level"
+ERROR_NO_MOP_IN_STATION: Final = "no_mop_in_station"
+ERROR_DUST_BAG_FULL: Final = "dust_bag_full"
+ERROR_SELF_TEST_FAILED: Final = "self_test_failed"
+ERROR_WASHBOARD_NOT_WORKING: Final = "washboard_not_working"
+ERROR_DRAINAGE_FAILED: Final = "drainage_failed"
+ERROR_MOP_NOT_DETECTED: Final = "mop_not_detected"
+ERROR_MOP_HOLDER_ERROR: Final = "mop_holder_error"
+ERROR_DOCK_ERROR: Final = "dock_error"
+ERROR_WASH_FAILED: Final = "wash_failed"
+ERROR_ROBOT_STUCK_ON_CURTAIN: Final = "robot_stuck_on_curtain"
+ERROR_EDGE_MOP_STOP_ROTATE: Final = "edge_mop_stop_rotate"
+ERROR_EDGE_MOP_DETACHED: Final = "edge_mop_detached"
+ERROR_CHASSIS_LIFT_MALFUNCTION: Final = "chassis_lift_malfunction"
+ERROR_MOP_COVER_ERROR: Final = "mop_cover_error"
+ERROR_ROLLER_MOP_ERROR: Final = "roller_mop_error"
+ERROR_ONBOARD_WATER_TANK_EMPTY: Final = "onboard_water_tank_empty"
+ERROR_ONBOARD_DIRTY_WATER_TANK_FULL: Final = "onboard_dirty_water_tank_full"
+ERROR_MOP_NOT_INSTALLED: Final = "mop_not_installed"
+ERROR_FLUFFING_ROLLER_ERROR: Final = "fluffing_roller_error"
+ERROR_BLOCKED_BY_OBSTACLE: Final = "blocked_by_obstacle"
+ERROR_RETURN_TO_CHARGE_FAILED: Final = "return_to_charge_failed"
+ATTR_VALUE: Final = "value"
ATTR_CHARGING: Final = "charging"
+ATTR_DOCKED: Final = "docked"
+ATTR_LOCATED: Final = "located"
ATTR_STARTED: Final = "started"
ATTR_PAUSED: Final = "paused"
ATTR_RUNNING: Final = "running"
ATTR_RETURNING_PAUSED: Final = "returning_paused"
ATTR_RETURNING: Final = "returning"
ATTR_MAPPING: Final = "mapping"
+ATTR_MAPPING_AVAILABLE: Final = "mapping_available"
+ATTR_WASHING_AVAILABLE: Final = "washing_available"
+ATTR_DRYING_AVAILABLE: Final = "drying_available"
+ATTR_DUST_BAG_DRYING_AVAILABLE: Final = "dust_bag_drying_available"
+ATTR_DRAINING_AVAILABLE: Final = "draining_available"
+ATTR_DRYING_LEFT: Final = "drying_left"
+ATTR_DUST_COLLECTION_AVAILABLE: Final = "dust_collection_available"
ATTR_ROOMS: Final = "rooms"
+ATTR_MAPS: Final = "maps"
ATTR_CURRENT_SEGMENT: Final = "current_segment"
ATTR_SELECTED_MAP: Final = "selected_map"
+ATTR_SELECTED_MAP_ID: Final = "selected_map_id"
+ATTR_SELECTED_MAP_INDEX: Final = "selected_map_index"
ATTR_ID: Final = "id"
+ATTR_DATE: Final = "date"
+ATTR_INDEX: Final = "index"
ATTR_NAME: Final = "name"
+ATTR_CUSTOM_NAME: Final = "custom_name"
+ATTR_RECOVERY_MAP: Final = "recovery_map"
ATTR_ICON: Final = "icon"
+ATTR_TYPE: Final = "type"
+ATTR_ORDER: Final = "order"
+ATTR_DID: Final = "did"
ATTR_STATUS: Final = "status"
ATTR_CLEANING_MODE: Final = "cleaning_mode"
ATTR_SUCTION_LEVEL: Final = "suction_level"
+ATTR_WASHING_MODE: Final = "washing_mode"
ATTR_WATER_TANK: Final = "water_tank"
ATTR_COMPLETED: Final = "completed"
+ATTR_TIMESTAMP: Final = "timestamp"
ATTR_CLEANING_TIME: Final = "cleaning_time"
ATTR_CLEANED_AREA: Final = "cleaned_area"
ATTR_MOP_PAD_HUMIDITY: Final = "mop_pad_humidity"
+ATTR_SELF_CLEAN_AREA: Final = "self_clean_area"
+ATTR_SELF_CLEAN_AREA_MIN: Final = "self_clean_area_min"
+ATTR_SELF_CLEAN_AREA_MAX: Final = "self_clean_area_max"
+ATTR_PREVIOUS_SELF_CLEAN_AREA: Final = "previous_self_clean_area"
+ATTR_SELF_CLEAN_TIME: Final = "self_clean_time"
+ATTR_PREVIOUS_SELF_CLEAN_TIME: Final = "previous_self_clean_time"
+ATTR_SELF_CLEAN_TIME_MIN: Final = "self_clean_time_min"
+ATTR_SELF_CLEAN_TIME_MAX: Final = "self_clean_time_max"
+ATTR_MOP_CLEAN_FREQUENCY: Final = "mop_clean_frequency"
ATTR_MOP_PAD: Final = "mop_pad"
+ATTR_BATTERY: Final = "battery"
ATTR_CLEANING_SEQUENCE: Final = "cleaning_sequence"
-
-AI_SETTING_SWITCH: Final = "obstacle_detect_switch"
-AI_SETTING_UPLOAD: Final = "obstacle_app_display_switch"
-AI_SETTING_PET: Final = "whether_have_pet"
-AI_SETTING_HUMAN: Final = "human_detect_switch"
-AI_SETTING_FURNITURE: Final = "furniture_detect_switch"
-AI_SETTING_FLUID: Final = "fluid_detect_switch"
+ATTR_WASHING: Final = "washing"
+ATTR_WASHING_PAUSED: Final = "washing_paused"
+ATTR_DRYING: Final = "drying"
+ATTR_DRAINING: Final = "draining"
+ATTR_CLEANGENIUS: Final = "cleangenius_cleaning"
+ATTR_WETNESS_LEVEL: Final = "wetness_level"
+ATTR_OFF_PEAK_CHARGING: Final = "off_peak_charging"
+ATTR_OFF_PEAK_CHARGING_START: Final = "off_peak_charging_start"
+ATTR_OFF_PEAK_CHARGING_END: Final = "off_peak_charging_end"
+ATTR_LOW_WATER: Final = "low_water"
+ATTR_VACUUM_STATE: Final = "vacuum_state"
+ATTR_DND: Final = "dnd"
+ATTR_SHORTCUTS: Final = "shortcuts"
+ATTR_CRUISING_TIME: Final = "cruising_time"
+ATTR_CRUISING_TYPE: Final = "cruising_type"
+ATTR_MAP_INDEX: Final = "map_index"
+ATTR_MAP_NAME: Final = "map_name"
+ATTR_CALIBRATION: Final = "calibration_points"
+ATTR_SELECTED: Final = "selected"
+ATTR_CLEANING_HISTORY_PICTURE: Final = "cleaning_history_picture"
+ATTR_CRUISING_HISTORY_PICTURE: Final = "cruising_history_picture"
+ATTR_OBSTACLE_PICTURE: Final = "obstacle_picture"
+ATTR_RECOVERY_MAP_PICTURE: Final = "recovery_map_picture"
+ATTR_RECOVERY_MAP_FILE: Final = "recovery_map_file"
+ATTR_WIFI_MAP_PICTURE: Final = "wifi_map_picture"
+ATTR_BLOCKED_SEGMENTS: Final = "blocked_rooms"
+ATTR_INTERRUPT_REASON: Final = "interrupt_reason"
+ATTR_MULTIPLE_CLEANING_TIME: Final = "multiple_cleaning_time"
+ATTR_PET: Final = "pet"
+ATTR_CLEANUP_METHOD: Final = "cleanup_method"
+ATTR_SEGMENT_CLEANING: Final = "segment_cleaning"
+ATTR_ZONE_CLEANING: Final = "zone_cleaning"
+ATTR_SPOT_CLEANING: Final = "spot_cleaning"
+ATTR_CRUSING: Final = "cruising"
+ATTR_HAS_SAVED_MAP: Final = "has_saved_map"
+ATTR_HAS_TEMPORARY_MAP: Final = "has_temporary_map"
+ATTR_AUTO_EMPTY_MODE: Final = "auto_empty_mode"
+ATTR_CARPET_AVOIDANCE: Final = "carpet_avoidance"
+ATTR_FLOOR_DIRECTION_CLEANING_AVAILABLE: Final = "floor_direction_cleaning_available"
+ATTR_SHORTCUT_TASK: Final = "shortcut_task"
+ATTR_FIRMWARE_VERSION: Final = "firmware_version"
+ATTR_AP: Final = "ap"
+ATTR_MAP_ID: Final = "map_id"
+ATTR_SAVED_MAP_ID: Final = "saved_map_id"
+ATTR_COLOR_SCHEME: Final = "color_scheme"
+ATTR_CAPABILITIES: Final = "capabilities"
MAP_PARAMETER_NAME: Final = "name"
MAP_PARAMETER_VALUE: Final = "value"
@@ -264,16 +625,8 @@
MAP_PARAMETER_MAPSTR: Final = "mapstr"
MAP_PARAMETER_CURR_ID: Final = "curr_id"
MAP_PARAMETER_VACUUM: Final = "vacuum"
-MAP_PARAMETER_ID: Final = "id"
-MAP_PARAMETER_INFO: Final = "info"
-MAP_PARAMETER_FIRST: Final = "first"
-MAP_PARAMETER_OBJNAME: Final = "objname"
-MAP_PARAMETER_RESULT: Final = "result"
MAP_PARAMETER_URL: Final = "url"
MAP_PARAMETER_EXPIRES_TIME: Final = "expires_time"
-MAP_PARAMETER_THB: Final = "thb"
-MAP_PARAMETER_OBJECT_NAME: Final = "object_name"
-MAP_PARAMETER_MD5: Final = "md5"
MAP_REQUEST_PARAMETER_MAP_ID: Final = "map_id"
MAP_REQUEST_PARAMETER_FRAME_ID: Final = "frame_id"
@@ -284,170 +637,384 @@
MAP_REQUEST_PARAMETER_INDEX: Final = "index"
MAP_REQUEST_PARAMETER_ROOM_ID: Final = "roomID"
-MAP_DATA_PARAMETER_CLASS: Final = "__class"
-MAP_DATA_PARAMETER_SIZE: Final = "size"
-MAP_DATA_PARAMETER_X: Final = "x"
-MAP_DATA_PARAMETER_Y: Final = "y"
-MAP_DATA_PARAMETER_PIXEL_SIZE: Final = "pixelSize"
-MAP_DATA_PARAMETER_LAYERS: Final = "layers"
-MAP_DATA_PARAMETER_ENTITIES: Final = "entities"
-MAP_DATA_PARAMETER_META_DATA: Final = "metaData"
-MAP_DATA_PARAMETER_VERSION: Final = "version"
-MAP_DATA_PARAMETER_ROTATION: Final = "rotation"
-MAP_DATA_PARAMETER_TYPE: Final = "type"
-MAP_DATA_PARAMETER_POINTS: Final = "points"
-MAP_DATA_PARAMETER_PIXELS: Final = "pixels"
-MAP_DATA_PARAMETER_SEGMENT_ID: Final = "segmentId"
-MAP_DATA_PARAMETER_ACTIVE: Final = "active"
-MAP_DATA_PARAMETER_NAME: Final = "name"
-MAP_DATA_PARAMETER_DIMENSIONS: Final = "dimensions"
-MAP_DATA_PARAMETER_MIN: Final = "min"
-MAP_DATA_PARAMETER_MAX: Final = "max"
-MAP_DATA_PARAMETER_MID: Final = "mid"
-MAP_DATA_PARAMETER_AVG: Final = "avg"
-MAP_DATA_PARAMETER_PIXEL_COUNT: Final = "pixelCount"
-MAP_DATA_PARAMETER_COMPRESSED_PIXELS: Final = "compressedPixels"
-MAP_DATA_PARAMETER_ROBOT_POSITION: Final = "robot_position"
-MAP_DATA_PARAMETER_CHARGER_POSITION: Final = "charger_location"
-MAP_DATA_PARAMETER_NO_MOP_AREA: Final = "no_mop_area"
-MAP_DATA_PARAMETER_NO_GO_AREA: Final = "no_go_area"
-MAP_DATA_PARAMETER_ACTIVE_ZONE: Final = "active_zone"
-MAP_DATA_PARAMETER_VIRTUAL_WALL: Final = "virtual_wall"
-MAP_DATA_PARAMETER_PATH: Final = "path"
-MAP_DATA_PARAMETER_FLOOR: Final = "floor"
-MAP_DATA_PARAMETER_WALL: Final = "wall"
-MAP_DATA_PARAMETER_SEGMENT: Final = "segment"
-
-DEVICE_MAP_KEY: Final = (
- "H4sICGt+oGMEAGRldmljZWtleS50eHQAbc67DoIwAIXhd+nsQG8obhaDKFChEg0jBEGJgSIGgsZ3lwbcmL+c/OcDJIKQVGANdN+6u37k2W7/kEshwEIZMZQJfiQS0wQFTly1tjmZpmxVlycjrfMQm1LurvBvctbGXjzfeyKkGQPVlnNrq00trNDPHK6PRMlAneg1mkVucPCErXvFSFBXT0hjtjhA7JVczmzP0GiYDsRFV7KCWg33c8aTcJpBNUvLVAT4vdqYxTbdehX4/gAN9AoFFgEAAA=="
+MAP_DATA_JSON_CLASS: Final = "ValetudoMap"
+MAP_DATA_JSON_PARAMETER_CLASS: Final = "__class"
+MAP_DATA_JSON_PARAMETER_SIZE: Final = "size"
+MAP_DATA_JSON_PARAMETER_X: Final = "x"
+MAP_DATA_JSON_PARAMETER_Y: Final = "y"
+MAP_DATA_JSON_PARAMETER_PIXEL_SIZE: Final = "pixelSize"
+MAP_DATA_JSON_PARAMETER_LAYERS: Final = "layers"
+MAP_DATA_JSON_PARAMETER_ENTITIES: Final = "entities"
+MAP_DATA_JSON_PARAMETER_META_DATA: Final = "metaData"
+MAP_DATA_JSON_PARAMETER_VERSION: Final = "version"
+MAP_DATA_JSON_PARAMETER_ROTATION: Final = "rotation"
+MAP_DATA_JSON_PARAMETER_TYPE: Final = "type"
+MAP_DATA_JSON_PARAMETER_POINTS: Final = "points"
+MAP_DATA_JSON_PARAMETER_PIXELS: Final = "pixels"
+MAP_DATA_JSON_PARAMETER_SEGMENT_ID: Final = "segmentId"
+MAP_DATA_JSON_PARAMETER_ACTIVE: Final = "active"
+MAP_DATA_JSON_PARAMETER_NAME: Final = "name"
+MAP_DATA_JSON_PARAMETER_DIMENSIONS: Final = "dimensions"
+MAP_DATA_JSON_PARAMETER_MIN: Final = "min"
+MAP_DATA_JSON_PARAMETER_MAX: Final = "max"
+MAP_DATA_JSON_PARAMETER_MID: Final = "mid"
+MAP_DATA_JSON_PARAMETER_AVG: Final = "avg"
+MAP_DATA_JSON_PARAMETER_PIXEL_COUNT: Final = "pixelCount"
+MAP_DATA_JSON_PARAMETER_COMPRESSED_PIXELS: Final = "compressedPixels"
+MAP_DATA_JSON_PARAMETER_ROBOT_POSITION: Final = "robot_position"
+MAP_DATA_JSON_PARAMETER_CHARGER_POSITION: Final = "charger_location"
+MAP_DATA_JSON_PARAMETER_NO_MOP_AREA: Final = "no_mop_area"
+MAP_DATA_JSON_PARAMETER_NO_GO_AREA: Final = "no_go_area"
+MAP_DATA_JSON_PARAMETER_ACTIVE_ZONE: Final = "active_zone"
+MAP_DATA_JSON_PARAMETER_VIRTUAL_WALL: Final = "virtual_wall"
+MAP_DATA_JSON_PARAMETER_PATH: Final = "path"
+MAP_DATA_JSON_PARAMETER_FLOOR: Final = "floor"
+MAP_DATA_JSON_PARAMETER_WALL: Final = "wall"
+MAP_DATA_JSON_PARAMETER_SEGMENT: Final = "segment"
+
+DEVICE_INFO: Final = (
+ "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"
)
PROPERTY_TO_NAME: Final = {
- DreameVacuumProperty.STATE: ["state", "State"],
- DreameVacuumProperty.ERROR: ["error", "Error"],
- DreameVacuumProperty.BATTERY_LEVEL: ["battery_level", "Battery Level"],
- DreameVacuumProperty.CHARGING_STATUS: ["charging_status", "Charging Status"],
- DreameVacuumProperty.STATUS: ["status", "Status"],
- DreameVacuumProperty.CLEANING_TIME: ["cleaning_time", "Cleaning Time"],
- DreameVacuumProperty.CLEANED_AREA: ["cleaned_area", "Cleaned Area"],
- DreameVacuumProperty.SUCTION_LEVEL: ["suction_level", "Suction Level"],
- DreameVacuumProperty.WATER_VOLUME: ["water_volume", "Water Volume"],
- DreameVacuumProperty.WATER_TANK: ["water_tank", "Water Tank"],
- DreameVacuumProperty.TASK_STATUS: ["task_status", "Task Status"],
- DreameVacuumProperty.RESUME_CLEANING: ["resume_cleaning", "Resume Cleaning"],
- DreameVacuumProperty.CARPET_BOOST: ["carpet_boost", "Carpet Boost"],
- DreameVacuumProperty.REMOTE_CONTROL: ["remote_control", "Remote Control"],
- DreameVacuumProperty.MOP_CLEANING_REMAINDER: [
+ DreameVacuumProperty.STATE.name: ["state", "State"],
+ DreameVacuumProperty.ERROR.name: ["error", "Error"],
+ DreameVacuumProperty.BATTERY_LEVEL.name: ["battery_level", "Battery Level"],
+ DreameVacuumProperty.CHARGING_STATUS.name: ["charging_status", "Charging Status"],
+ DreameVacuumProperty.OFF_PEAK_CHARGING.name: [
+ "off_peak_charging",
+ "Off-Peak Charging",
+ ],
+ DreameVacuumProperty.STATUS.name: ["status", "Status"],
+ DreameVacuumProperty.CLEANING_TIME.name: ["cleaning_time", "Cleaning Time"],
+ DreameVacuumProperty.CLEANED_AREA.name: ["cleaned_area", "Cleaned Area"],
+ DreameVacuumProperty.SUCTION_LEVEL.name: ["suction_level", "Suction Level"],
+ DreameVacuumProperty.WATER_VOLUME.name: ["water_volume", "Water Volume"],
+ DreameVacuumProperty.WATER_TANK.name: ["water_tank", "Water Tank"],
+ DreameVacuumProperty.TASK_STATUS.name: ["task_status", "Task Status"],
+ DreameVacuumProperty.RESUME_CLEANING.name: ["resume_cleaning", "Resume Cleaning"],
+ DreameVacuumProperty.CARPET_BOOST.name: ["carpet_boost", "Carpet Boost"],
+ DreameVacuumProperty.REMOTE_CONTROL.name: ["remote_control", "Remote Control"],
+ DreameVacuumProperty.MOP_CLEANING_REMAINDER.name: [
"mop_cleaning_remainder",
"Mop Cleaning Remainder",
],
- DreameVacuumProperty.CLEANING_PAUSED: ["cleaning_paused", "Cleaning Paused"],
- DreameVacuumProperty.FAULTS: ["faults", "Faults"],
- DreameVacuumProperty.RELOCATION_STATUS: ["relocation_status", "Relocation Status"],
- DreameVacuumProperty.OBSTACLE_AVOIDANCE: [
+ DreameVacuumProperty.CLEANING_PAUSED.name: ["cleaning_paused", "Cleaning Paused"],
+ DreameVacuumProperty.FAULTS.name: ["faults", "Faults"],
+ DreameVacuumProperty.RELOCATION_STATUS.name: [
+ "relocation_status",
+ "Relocation Status",
+ ],
+ DreameVacuumProperty.OBSTACLE_AVOIDANCE.name: [
"obstacle_avoidance",
"Obstacle Avoidance",
],
- DreameVacuumProperty.AI_DETECTION: [
+ DreameVacuumProperty.AI_DETECTION.name: [
"ai_obstacle_detection",
"AI Obstacle Detection",
],
- DreameVacuumProperty.CLEANING_MODE: ["cleaning_mode", "Cleaning Mode"],
- DreameVacuumProperty.SELF_WASH_BASE_STATUS: [
+ DreameVacuumProperty.CLEANING_MODE.name: ["cleaning_mode", "Cleaning Mode"],
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS.name: [
"self_wash_base_status",
"Self-Wash Base Status",
],
- DreameVacuumProperty.CUSTOMIZED_CLEANING: [
+ DreameVacuumProperty.CUSTOMIZED_CLEANING.name: [
"customized_cleaning",
"Customized Cleaning",
],
- DreameVacuumProperty.CHILD_LOCK: ["child_lock", "Child Lock"],
- DreameVacuumProperty.CARPET_SENSITIVITY: [
+ DreameVacuumProperty.CHILD_LOCK.name: ["child_lock", "Child Lock"],
+ DreameVacuumProperty.CARPET_SENSITIVITY.name: [
"carpet_sensitivity",
"Carpet Sensitivity",
],
- DreameVacuumProperty.TIGHT_MOPPING: ["tight_mopping", "Tight Mopping"],
- DreameVacuumProperty.CLEANING_CANCEL: ["cleaning_cancel", "Cleaning Cancel"],
- DreameVacuumProperty.CARPET_RECOGNITION: [
+ DreameVacuumProperty.TIGHT_MOPPING.name: ["tight_mopping", "Tight Mopping"],
+ DreameVacuumProperty.CLEANING_CANCEL.name: ["cleaning_cancel", "Cleaning Cancel"],
+ DreameVacuumProperty.CARPET_RECOGNITION.name: [
"carpet_recognition",
"Carpet Recognition",
],
- DreameVacuumProperty.SELF_CLEAN: ["self_clean", "Self-Clean"],
- DreameVacuumProperty.WARN_STATUS: ["warn_status", "Warn Status"],
- DreameVacuumProperty.CARPET_AVOIDANCE: ["carpet_avoidance", "Carpet Avoidance"],
- DreameVacuumProperty.AUTO_ADD_DETERGENT: [
+ DreameVacuumProperty.SELF_CLEAN.name: ["self_clean", "Self-Clean"],
+ DreameVacuumProperty.WARN_STATUS.name: ["warn_status", "Warn Status"],
+ DreameVacuumProperty.CARPET_CLEANING.name: ["carpet_cleaning", "Carpet Cleaning"],
+ DreameVacuumProperty.AUTO_ADD_DETERGENT.name: [
"auto_add_detergent",
"Auto-Add Detergent",
],
- DreameVacuumProperty.DRYING_TIME: ["drying_time", "Drying Time"],
- DreameVacuumProperty.DND: ["dnd", "DnD"],
- DreameVacuumProperty.DND_START: ["dnd_start", "DnD Start"],
- DreameVacuumProperty.DND_END: ["dnd_end", "DnD End"],
- DreameVacuumProperty.MULTI_FLOOR_MAP: ["multi_floor_map", "Multi Floor Map"],
- DreameVacuumProperty.MAP_LIST: ["map_list", "Map List"],
- DreameVacuumProperty.RECOVERY_MAP_LIST: ["recovery_map_list", "Recovery Map List"],
- DreameVacuumProperty.MAP_RECOVERY: ["map_recovery", "Map Recovery"],
- DreameVacuumProperty.MAP_RECOVERY_STATUS: [
+ DreameVacuumProperty.DRYING_TIME.name: ["drying_time", "Drying Time"],
+ DreameVacuumProperty.MULTI_FLOOR_MAP.name: ["multi_floor_map", "Multi Floor Map"],
+ DreameVacuumProperty.MAP_LIST.name: ["map_list", "Map List"],
+ DreameVacuumProperty.RECOVERY_MAP_LIST.name: [
+ "recovery_map_list",
+ "Recovery Map List",
+ ],
+ DreameVacuumProperty.MAP_RECOVERY.name: ["map_recovery", "Map Recovery"],
+ DreameVacuumProperty.MAP_RECOVERY_STATUS.name: [
"map_recovery_status",
"Map Recovery Status",
],
- DreameVacuumProperty.VOLUME: ["volume", "Volume"],
- DreameVacuumProperty.SCHEDULE: ["schedule", "Schedule"],
- DreameVacuumProperty.AUTO_DUST_COLLECTING: [
+ DreameVacuumProperty.VOLUME.name: ["volume", "Volume"],
+ DreameVacuumProperty.VOICE_ASSISTANT.name: ["voice_assistant", "Voice Assistant"],
+ DreameVacuumProperty.SCHEDULE.name: ["schedule", "Schedule"],
+ DreameVacuumProperty.AUTO_DUST_COLLECTING.name: [
"auto_dust_collecting",
"Auto Dust Collecting",
],
- DreameVacuumProperty.AUTO_EMPTY_FREQUENCY: [
+ DreameVacuumProperty.AUTO_EMPTY_FREQUENCY.name: [
"auto_empty_frequency",
"Auto Empty Frequency",
],
- DreameVacuumProperty.MAP_SAVING: [
+ DreameVacuumProperty.MAP_SAVING.name: [
"map_saving",
"Map Saving",
],
- DreameVacuumProperty.DUST_COLLECTION: ["dust_collection", "Dust Collection"],
- DreameVacuumProperty.AUTO_EMPTY_STATUS: ["auto_empty_status", "Auto Empty Status"],
- DreameVacuumProperty.SERIAL_NUMBER: ["serial_number", "Serial Number"],
- DreameVacuumProperty.VOICE_PACKET_ID: ["voice_packet_id", "Voice Packet Id"],
- DreameVacuumProperty.TIMEZONE: ["timezone", "Timezone"],
- DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT: [
+ DreameVacuumProperty.DUST_COLLECTION.name: ["dust_collection", "Dust Collection"],
+ DreameVacuumProperty.AUTO_EMPTY_STATUS.name: [
+ "auto_empty_status",
+ "Auto Empty Status",
+ ],
+ DreameVacuumProperty.SERIAL_NUMBER.name: ["serial_number", "Serial Number"],
+ DreameVacuumProperty.VOICE_PACKET_ID.name: ["voice_packet_id", "Voice Packet Id"],
+ DreameVacuumProperty.TIMEZONE.name: ["timezone", "Timezone"],
+ DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT.name: [
"main_brush_time_left",
"Main Brush Time Left",
],
- DreameVacuumProperty.MAIN_BRUSH_LEFT: ["main_brush_left", "Main Brush Left"],
- DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT: [
+ DreameVacuumProperty.MAIN_BRUSH_LEFT.name: ["main_brush_left", "Main Brush Left"],
+ DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT.name: [
"side_brush_time_left",
"Side Brush Time Left",
],
- DreameVacuumProperty.SIDE_BRUSH_LEFT: ["side_brush_left", "Side Brush Left"],
- DreameVacuumProperty.FILTER_LEFT: ["filter_left", "Filter Left"],
- DreameVacuumProperty.FILTER_TIME_LEFT: ["filter_time_left", "Filter Time Left"],
- DreameVacuumProperty.FIRST_CLEANING_DATE: [
+ DreameVacuumProperty.SIDE_BRUSH_LEFT.name: ["side_brush_left", "Side Brush Left"],
+ DreameVacuumProperty.FILTER_LEFT.name: ["filter_left", "Filter Left"],
+ DreameVacuumProperty.FILTER_TIME_LEFT.name: [
+ "filter_time_left",
+ "Filter Time Left",
+ ],
+ DreameVacuumProperty.FIRST_CLEANING_DATE.name: [
"first_cleaning_date",
"First Cleaning Date",
],
- DreameVacuumProperty.TOTAL_CLEANING_TIME: [
+ DreameVacuumProperty.TOTAL_CLEANING_TIME.name: [
"total_cleaning_time",
"Total Cleaning Time",
],
- DreameVacuumProperty.CLEANING_COUNT: ["cleaning_count", "Cleaning Count"],
- DreameVacuumProperty.TOTAL_CLEANED_AREA: [
+ DreameVacuumProperty.CLEANING_COUNT.name: ["cleaning_count", "Cleaning Count"],
+ DreameVacuumProperty.TOTAL_CLEANED_AREA.name: [
"total_cleaned_area",
"Total Cleaned Area",
],
- DreameVacuumProperty.SENSOR_DIRTY_LEFT: ["sensor_dirty_left", "Sensor Dirty Left"],
- DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT: [
+ DreameVacuumProperty.TOTAL_RUNTIME.name: [
+ "total_runtime",
+ "Total Runtime",
+ ],
+ DreameVacuumProperty.TOTAL_CRUISE_TIME.name: [
+ "total_cruise_time",
+ "Total Cruise Time",
+ ],
+ DreameVacuumProperty.SENSOR_DIRTY_LEFT.name: [
+ "sensor_dirty_left",
+ "Sensor Dirty Left",
+ ],
+ DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT.name: [
"sensor_dirty_time_left",
"Sensor Dirty Time Left",
],
- DreameVacuumProperty.SECONDARY_FILTER_LEFT: ["secondary_filter_left", "Secondary Filter Left"],
- DreameVacuumProperty.SECONDARY_FILTER_TIME_LEFT: ["secondary_filter_time_left", "Secondary Filter Time Left"],
- DreameVacuumProperty.MOP_PAD_LEFT: ["mop_pad_left", "Mop Pad Left"],
- DreameVacuumProperty.MOP_PAD_TIME_LEFT: ["mop_pad_time_left", "Mop Pad Time Left"],
- DreameVacuumProperty.SILVER_ION_LEFT: ["silver_ion_left", "Silver-ion Left"],
- DreameVacuumProperty.SILVER_ION_TIME_LEFT: ["silver_ion_time_left", "Silver-ion Time Left"],
- DreameVacuumProperty.DETERGENT_LEFT: ["detergent_left", "Detergent Left"],
- DreameVacuumProperty.DETERGENT_TIME_LEFT: ["detergent_time_left", "Detergent Time Left"],
+ DreameVacuumProperty.TANK_FILTER_LEFT.name: [
+ "tank_filter_left",
+ "Tank Filter Left",
+ ],
+ DreameVacuumProperty.TANK_FILTER_TIME_LEFT.name: [
+ "tank_filter_time_left",
+ "Tank Filter Time Left",
+ ],
+ DreameVacuumProperty.MOP_PAD_LEFT.name: ["mop_pad_left", "Mop Pad Left"],
+ DreameVacuumProperty.MOP_PAD_TIME_LEFT.name: [
+ "mop_pad_time_left",
+ "Mop Pad Time Left",
+ ],
+ DreameVacuumProperty.SILVER_ION_LEFT.name: ["silver_ion_left", "Silver-ion Left"],
+ DreameVacuumProperty.SILVER_ION_TIME_LEFT.name: [
+ "silver_ion_time_left",
+ "Silver-ion Time Left",
+ ],
+ DreameVacuumProperty.DETERGENT_LEFT.name: ["detergent_left", "Detergent Left"],
+ DreameVacuumProperty.DETERGENT_TIME_LEFT.name: [
+ "detergent_time_left",
+ "Detergent Time Left",
+ ],
+ DreameVacuumProperty.SQUEEGEE_LEFT.name: ["squeegee_left", "Squeegee Left"],
+ DreameVacuumProperty.SQUEEGEE_TIME_LEFT.name: [
+ "squeegee_time_left",
+ "Squeegee Time Left",
+ ],
+ DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_LEFT.name: [
+ "onboard_dirty_water_tank_left",
+ "Onboard Dirty Water Tank Left",
+ ],
+ DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_TIME_LEFT.name: [
+ "onboard_dirty_water_tank_time_left",
+ "Onboard Dirty Water Tank Time Left",
+ ],
+ DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_LEFT.name: [
+ "DIRTY_WATER_CHANNEL_DIRTY_left",
+ "Dirty Water Channel Left",
+ ],
+ DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_TIME_LEFT.name: [
+ "DIRTY_WATER_CHANNEL_DIRTY_time_left",
+ "Dirty Water Channel Time Left",
+ ],
+ DreameVacuumProperty.DEODORIZER_LEFT.name: [
+ "deodorizer_left",
+ "Deodorizer Left",
+ ],
+ DreameVacuumProperty.DEODORIZER_TIME_LEFT.name: [
+ "deodorizer_time_left",
+ "Deodorizer Time Left",
+ ],
+ DreameVacuumProperty.WHEEL_DIRTY_LEFT.name: [
+ "wheel_dirty_left",
+ "Wheel Dirty Left",
+ ],
+ DreameVacuumProperty.WHEEL_DIRTY_TIME_LEFT.name: [
+ "wheel_dirty_time_left",
+ "Wheel Dirty Time Left",
+ ],
+ DreameVacuumProperty.SCALE_INHIBITOR_LEFT.name: [
+ "scale_inhibitor_left",
+ "Scale Inhibitor Left",
+ ],
+ DreameVacuumProperty.SCALE_INHIBITOR_TIME_LEFT.name: [
+ "scale_inhibitor_time_left",
+ "Scale Inhibitor Time Left",
+ ],
+ DreameVacuumProperty.CLEANGENIUS_MODE.name: [
+ "cleangenius_mode",
+ "CleanGenius Mode",
+ ],
+ DreameVacuumProperty.DND_DISABLE_RESUME_CLEANING.name: [
+ "dnd_disable_resume_cleaning",
+ "DnD Disable Resume Cleaning",
+ ],
+ DreameVacuumProperty.DND_DISABLE_AUTO_EMPTY.name: [
+ "dnd_disable_auto_empty",
+ "DnD Disable Auto Empty",
+ ],
+ DreameVacuumProperty.DND_REDUCE_VOLUME.name: [
+ "dnd_reduce_volume",
+ "DnD Reduce Volume",
+ ],
+ DreameVacuumAIProperty.AI_FURNITURE_DETECTION.name: [
+ "ai_furniture_detection",
+ "AI Furniture Detection",
+ ],
+ DreameVacuumAIProperty.AI_OBSTACLE_DETECTION.name: [
+ "ai_obstacle_detection",
+ "AI Obstacle Detection",
+ ],
+ DreameVacuumAIProperty.AI_OBSTACLE_PICTURE.name: [
+ "ai_obstacle_picture",
+ "AI Obstacle Picture",
+ ],
+ DreameVacuumAIProperty.AI_FLUID_DETECTION.name: [
+ "ai_fluid_detection",
+ "AI Fluid Detection",
+ ],
+ DreameVacuumAIProperty.AI_PET_DETECTION.name: [
+ "ai_pet_detection",
+ "AI Pet Detection",
+ ],
+ DreameVacuumAIProperty.AI_OBSTACLE_IMAGE_UPLOAD.name: [
+ "ai_obstacle_image_upload",
+ "AI Obstacle Image Upload",
+ ],
+ DreameVacuumAIProperty.AI_IMAGE.name: ["ai_image", "AI Image"],
+ DreameVacuumAIProperty.AI_PET_AVOIDANCE.name: [
+ "ai_pet_avoidance",
+ "AI Pet Avoidance",
+ ],
+ DreameVacuumAIProperty.FUZZY_OBSTACLE_DETECTION.name: [
+ "fuzzy_obstacle_detection",
+ "Fuzzy Obstacle Detection",
+ ],
+ DreameVacuumAIProperty.PET_PICTURE.name: ["pet_picture", "Pet Picture"],
+ DreameVacuumAIProperty.PET_FOCUSED_DETECTION.name: [
+ "pet_focused_detection",
+ "Pet Focused Detection",
+ ],
+ DreameVacuumAIProperty.LARGE_PARTICLES_BOOST.name: [
+ "large_particles_boost",
+ "Large Particles Boost",
+ ],
+ DreameVacuumStrAIProperty.AI_HUMAN_DETECTION.name: [
+ "ai_human_detection",
+ "AI Human Detection",
+ ],
+ DreameVacuumAutoSwitchProperty.COLLISION_AVOIDANCE.name: [
+ "collision_avoidance",
+ "Collision Avoidance",
+ ],
+ DreameVacuumAutoSwitchProperty.FILL_LIGHT.name: ["fill_light", "Fill Light"],
+ DreameVacuumAutoSwitchProperty.AUTO_DRYING.name: ["auto_drying", "Auto Drying"],
+ DreameVacuumAutoSwitchProperty.STAIN_AVOIDANCE.name: [
+ "stain_avoidance",
+ "Stain Avoidance",
+ ],
+ DreameVacuumAutoSwitchProperty.MOPPING_TYPE.name: ["mopping_type", "Mopping Type"],
+ DreameVacuumAutoSwitchProperty.CLEANGENIUS.name: [
+ "cleangenius",
+ "CleanGenius",
+ ],
+ DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE.name: [
+ "wider_corner_coverage",
+ "Wider Corner Coverage",
+ ],
+ DreameVacuumAutoSwitchProperty.FLOOR_DIRECTION_CLEANING.name: [
+ "floor_direction_cleaning",
+ "Floor Direction Cleaning",
+ ],
+ DreameVacuumAutoSwitchProperty.PET_FOCUSED_CLEANING.name: [
+ "pet_focused_cleaning",
+ "Pet Focused Cleaning",
+ ],
+ DreameVacuumAutoSwitchProperty.AUTO_RECLEANING.name: [
+ "auto_recleaning",
+ "Auto Re-Cleaning",
+ ],
+ DreameVacuumAutoSwitchProperty.AUTO_REWASHING.name: [
+ "auto_rewashing",
+ "Auto Re-Washing",
+ ],
+ DreameVacuumAutoSwitchProperty.MOP_PAD_SWING.name: [
+ "mop_pad_swing",
+ "Mop Pad Swing",
+ ],
+ DreameVacuumAutoSwitchProperty.MOP_EXTEND.name: [
+ "mop_extend",
+ "Mop Extend",
+ ],
+ DreameVacuumAutoSwitchProperty.MOP_EXTEND_FREQUENCY.name: [
+ "mop_extend_frequency",
+ "Mop Extend Frequency",
+ ],
+ DreameVacuumAutoSwitchProperty.HUMAN_FOLLOW.name: ["human_follow", "Human Follow"],
+ DreameVacuumAutoSwitchProperty.MAX_SUCTION_POWER.name: [
+ "max_suction_power",
+ "Max Suction Power",
+ ],
+ DreameVacuumAutoSwitchProperty.SMART_DRYING.name: ["smart_drying", "Smart Drying"],
+ DreameVacuumAutoSwitchProperty.DRAINAGE_CONFIRM_RESULT.name: [
+ "drainage_confirm_result",
+ "Drainage Confirm Result",
+ ],
+ DreameVacuumAutoSwitchProperty.DRAINAGE_TEST_RESULT.name: [
+ "drainage_test_result",
+ "Drainage Test Result",
+ ],
+ DreameVacuumAutoSwitchProperty.HOT_WASHING.name: ["hot_washing", "Hot Washing"],
+ DreameVacuumAutoSwitchProperty.UV_STERILIZATION.name: [
+ "uv_sterilization",
+ "UV Sterilization",
+ ],
}
ACTION_TO_NAME: Final = {
@@ -482,11 +1049,48 @@
DreameVacuumState.MOPPING: STATE_MOPPING,
DreameVacuumState.DRYING: STATE_DRYING,
DreameVacuumState.WASHING: STATE_WASHING,
- DreameVacuumState.RETURNING_WASHING: STATE_RETURNING_WASHING,
+ DreameVacuumState.RETURNING_TO_WASH: STATE_RETURNING_WASH,
DreameVacuumState.BUILDING: STATE_BUILDING,
DreameVacuumState.SWEEPING_AND_MOPPING: STATE_SWEEPING_AND_MOPPING,
DreameVacuumState.CHARGING_COMPLETED: STATE_CHARGING_COMPLETED,
DreameVacuumState.UPGRADING: STATE_UPGRADING,
+ DreameVacuumState.CLEAN_SUMMON: STATE_CLEAN_SUMMON,
+ DreameVacuumState.STATION_RESET: STATE_STATION_RESET,
+ DreameVacuumState.RETURNING_INSTALL_MOP: STATE_RETURNING_INSTALL_MOP,
+ DreameVacuumState.RETURNING_REMOVE_MOP: STATE_RETURNING_REMOVE_MOP,
+ DreameVacuumState.WATER_CHECK: STATE_WATER_CHECK,
+ DreameVacuumState.CLEAN_ADD_WATER: STATE_CLEAN_ADD_WATER,
+ DreameVacuumState.WASHING_PAUSED: STATE_WASHING_PAUSED,
+ DreameVacuumState.AUTO_EMPTYING: STATE_AUTO_EMPTYING,
+ DreameVacuumState.REMOTE_CONTROL: STATE_REMOTE_CONTROL,
+ DreameVacuumState.SMART_CHARGING: STATE_SMART_CHARGING,
+ DreameVacuumState.SECOND_CLEANING: STATE_SECOND_CLEANING,
+ DreameVacuumState.HUMAN_FOLLOWING: STATE_HUMAN_FOLLOWING,
+ DreameVacuumState.SPOT_CLEANING: STATE_SPOT_CLEANING,
+ DreameVacuumState.RETURNING_AUTO_EMPTY: STATE_RETURNING_AUTO_EMPTY,
+ DreameVacuumState.WAITING_FOR_TASK: STATE_WAITING_FOR_TASK,
+ DreameVacuumState.STATION_CLEANING: STATE_STATION_CLEANING,
+ DreameVacuumState.RETURNING_TO_DRAIN: STATE_RETURNING_TO_DRAIN,
+ DreameVacuumState.DRAINING: STATE_DRAINING,
+ DreameVacuumState.AUTO_WATER_DRAINING: STATE_AUTO_WATER_DRAINING,
+ DreameVacuumState.EMPTYING: STATE_EMPTYING,
+ DreameVacuumState.DUST_BAG_DRYING: STATE_DUST_BAG_DRYING,
+ DreameVacuumState.DUST_BAG_DRYING_PAUSED: STATE_DUST_BAG_DRYING_PAUSED,
+ DreameVacuumState.HEADING_TO_EXTRA_CLEANING: STATE_HEADING_TO_EXTRA_CLEANING,
+ DreameVacuumState.EXTRA_CLEANING: STATE_EXTRA_CLEANING,
+ DreameVacuumState.FINDING_PET_PAUSED: STATE_FINDING_PET_PAUSED,
+ DreameVacuumState.FINDING_PET: STATE_FINDING_PET,
+ DreameVacuumState.SHORTCUT: STATE_SHORTCUT,
+ DreameVacuumState.MONITORING: STATE_MONITORING,
+ DreameVacuumState.MONITORING_PAUSED: STATE_MONITORING_PAUSED,
+ DreameVacuumState.INITIAL_DEEP_CLEANING: STATE_INITIAL_DEEP_CLEANING,
+ DreameVacuumState.INITIAL_DEEP_CLEANING_PAUSED: STATE_INITIAL_DEEP_CLEANING_PAUSED,
+ DreameVacuumState.SANITIZING: STATE_SANITIZING,
+ DreameVacuumState.SANITIZING_WITH_DRY: STATE_SANITIZING_WITH_DRY,
+ DreameVacuumState.CHANGING_MOP: STATE_CHANGING_MOP,
+ DreameVacuumState.CHANGING_MOP_PAUSED: STATE_CHANGING_MOP_PAUSED,
+ DreameVacuumState.FLOOR_MAINTAINING: STATE_FLOOR_MAINTAINING,
+ DreameVacuumState.FLOOR_MAINTAINING_PAUSED: STATE_FLOOR_MAINTAINING_PAUSED,
}
# Dreame Vacuum suction level names
@@ -516,12 +1120,15 @@
DreameVacuumCleaningMode.SWEEPING: CLEANING_MODE_SWEEPING,
DreameVacuumCleaningMode.MOPPING: CLEANING_MODE_MOPPING,
DreameVacuumCleaningMode.SWEEPING_AND_MOPPING: CLEANING_MODE_SWEEPING_AND_MOPPING,
+ DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING: CLEANING_MODE_MOPPING_AFTER_SWEEPING,
}
WATER_TANK_CODE_TO_NAME: Final = {
+ DreameVacuumWaterTank.UNKNOWN: STATE_UNKNOWN,
DreameVacuumWaterTank.INSTALLED: WATER_TANK_INSTALLED,
DreameVacuumWaterTank.NOT_INSTALLED: WATER_TANK_NOT_INSTALLED,
DreameVacuumWaterTank.MOP_INSTALLED: WATER_TANK_MOP_INSTALLED,
+ DreameVacuumWaterTank.MOP_IN_STATION: WATER_TANK_MOP_IN_STATION,
}
CARPET_SENSITIVITY_CODE_TO_NAME: Final = {
@@ -530,7 +1137,37 @@
DreameVacuumCarpetSensitivity.HIGH: CARPET_SENSITIVITY_HIGH,
}
+CARPET_CLEANING_CODE_TO_NAME: Final = {
+ DreameVacuumCarpetCleaning.AVOIDANCE: CARPET_CLEANING_AVOIDANCE,
+ DreameVacuumCarpetCleaning.ADAPTATION: CARPET_CLEANING_ADAPTATION,
+ DreameVacuumCarpetCleaning.REMOVE_MOP: CARPET_CLEANING_REMOVE_MOP,
+ DreameVacuumCarpetCleaning.ADAPTATION_WITHOUT_ROUTE: CARPET_CLEANING_ADAPTATION_WITHOUT_ROUTE,
+ DreameVacuumCarpetCleaning.VACUUM_AND_MOP: CARPET_CLEANING_VACUUM_AND_MOP,
+ DreameVacuumCarpetCleaning.IGNORE: CARPET_CLEANING_IGNORE,
+ DreameVacuumCarpetCleaning.CROSS: CARPET_CLEANING_CROSS,
+}
+
+FLOOR_MATERIAL_CODE_TO_NAME: Final = {
+ DreameVacuumFloorMaterial.NONE: FLOOR_MATERIAL_NONE,
+ DreameVacuumFloorMaterial.TILE: FLOOR_MATERIAL_TILE,
+ DreameVacuumFloorMaterial.WOOD: FLOOR_MATERIAL_WOOD,
+ DreameVacuumFloorMaterial.MEDIUM_PILE_CARPET: FLOOR_MATERIAL_MEDIUM_PILE_CARPET,
+ DreameVacuumFloorMaterial.LOW_PILE_CARPET: FLOOR_MATERIAL_LOW_PILE_CARPET,
+ DreameVacuumFloorMaterial.CARPET: FLOOR_MATERIAL_CARPET,
+}
+
+FLOOR_MATERIAL_DIRECTION_CODE_TO_NAME: Final = {
+ DreameVacuumFloorMaterialDirection.VERTICAL: FLOOR_MATERIAL_DIRECTION_VERTICAL,
+ DreameVacuumFloorMaterialDirection.HORIZONTAL: FLOOR_MATERIAL_DIRECTION_HORIZONTAL,
+}
+
+SEGMENT_VISIBILITY_CODE_TO_NAME: Final = {
+ DreameVacuumSegmentVisibility.VISIBLE: SEGMENT_VISIBILITY_VISIBLE,
+ DreameVacuumSegmentVisibility.HIDDEN: SEGMENT_VISIBILITY_HIDDEN,
+}
+
TASK_STATUS_CODE_TO_NAME: Final = {
+ DreameVacuumTaskStatus.UNKNOWN: STATE_UNKNOWN,
DreameVacuumTaskStatus.COMPLETED: TASK_STATUS_COMPLETED,
DreameVacuumTaskStatus.AUTO_CLEANING: TASK_STATUS_AUTO_CLEANING,
DreameVacuumTaskStatus.ZONE_CLEANING: TASK_STATUS_ZONE_CLEANING,
@@ -550,16 +1187,22 @@
DreameVacuumTaskStatus.AUTO_DOCKING_PAUSED: TASK_STATUS_DOCKING_PAUSE,
DreameVacuumTaskStatus.ZONE_DOCKING_PAUSED: TASK_STATUS_DOCKING_PAUSE,
DreameVacuumTaskStatus.SEGMENT_DOCKING_PAUSED: TASK_STATUS_DOCKING_PAUSE,
- DreameVacuumTaskStatus.MONITOR_CRUISE: TASK_STATUS_MONITOR_CRUISE,
- DreameVacuumTaskStatus.MONITOR_CRUISE_PAUSE: TASK_STATUS_MONITOR_CRUISE_PAUSE,
- DreameVacuumTaskStatus.MONITOR_SPOT: TASK_STATUS_MONITOR_SPOT,
- DreameVacuumTaskStatus.MONITOR_SPOT_PAUSE: TASK_STATUS_MONITOR_SPOT_PAUSE,
- DreameVacuumTaskStatus.SUMMON_CLEAN_PAUSE: TASK_STATUS_SUMMON_CLEAN_PAUSE,
+ DreameVacuumTaskStatus.CRUISING_PATH: TASK_STATUS_CRUISING_PATH,
+ DreameVacuumTaskStatus.CRUISING_PATH_PAUSED: TASK_STATUS_CRUISING_PATH_PAUSED,
+ DreameVacuumTaskStatus.CRUISING_POINT: TASK_STATUS_CRUISING_POINT,
+ DreameVacuumTaskStatus.CRUISING_POINT_PAUSED: TASK_STATUS_CRUISING_POINT_PAUSED,
+ DreameVacuumTaskStatus.SUMMON_CLEAN_PAUSED: TASK_STATUS_SUMMON_CLEAN_PAUSED,
DreameVacuumTaskStatus.RETURNING_INSTALL_MOP: TASK_STATUS_RETURNING_INSTALL_MOP,
DreameVacuumTaskStatus.RETURNING_REMOVE_MOP: TASK_STATUS_RETURNING_REMOVE_MOP,
+ DreameVacuumTaskStatus.STATION_CLEANING: TASK_STATUS_STATION_CLEANING,
+ DreameVacuumTaskStatus.PET_FINDING: TASK_STATUS_PET_FINDING,
+ DreameVacuumTaskStatus.AUTO_CLEANING_WASHING_PAUSED: TASK_STATUS_AUTO_CLEANING_WASHING_PAUSED,
+ DreameVacuumTaskStatus.AREA_CLEANING_WASHING_PAUSED: TASK_STATUS_AREA_CLEANING_WASHING_PAUSED,
+ DreameVacuumTaskStatus.CUSTOM_CLEANING_WASHING_PAUSED: TASK_STATUS_CUSTOM_CLEANING_WASHING_PAUSED,
}
STATUS_CODE_TO_NAME: Final = {
+ DreameVacuumStatus.UNKNOWN: STATE_UNKNOWN,
DreameVacuumStatus.IDLE: STATE_IDLE,
DreameVacuumStatus.PAUSED: STATE_PAUSED,
DreameVacuumStatus.CLEANING: STATUS_CLEANING,
@@ -575,19 +1218,23 @@
DreameVacuumStatus.ERROR: STATUS_ERROR,
DreameVacuumStatus.REMOTE_CONTROL: STATUS_REMOTE_CONTROL,
DreameVacuumStatus.SLEEPING: STATUS_SLEEP,
- DreameVacuumStatus.SELF_TEST: STATUS_SELF_TEST,
+ DreameVacuumStatus.SELF_REPAIR: STATUS_SELF_REPAIR,
DreameVacuumStatus.FACTORY_FUNCION_TEST: STATUS_FACTORY_FUNC_TEST,
DreameVacuumStatus.STANDBY: STATUS_STANDBY,
DreameVacuumStatus.SEGMENT_CLEANING: STATUS_SEGMENT_CLEANING,
DreameVacuumStatus.ZONE_CLEANING: STATUS_ZONE_CLEANING,
DreameVacuumStatus.SPOT_CLEANING: STATUS_SPOT_CLEANING,
DreameVacuumStatus.FAST_MAPPING: STATUS_FAST_MAPPING,
- DreameVacuumStatus.MONITOR_CRUISE: STATUS_MONITOR_CRUISE,
- DreameVacuumStatus.MONITOR_SPOT: STATUS_MONITOR_SPOT,
+ DreameVacuumStatus.CRUISING_PATH: STATUS_CRUISING_PATH,
+ DreameVacuumStatus.CRUISING_POINT: STATUS_CRUISING_POINT,
DreameVacuumStatus.SUMMON_CLEAN: STATUS_SUMMON_CLEAN,
+ DreameVacuumStatus.SHORTCUT: STATUS_SHORTCUT,
+ DreameVacuumStatus.PERSON_FOLLOW: STATUS_PERSON_FOLLOW,
+ DreameVacuumStatus.WATER_CHECK: STATUS_WATER_CHECK,
}
RELOCATION_STATUS_CODE_TO_NAME: Final = {
+ DreameVacuumRelocationStatus.UNKNOWN: STATE_UNKNOWN,
DreameVacuumRelocationStatus.LOCATED: RELOCATION_STATUS_LOCATED,
DreameVacuumRelocationStatus.LOCATING: RELOCATION_STATUS_LOCATING,
DreameVacuumRelocationStatus.FAILED: RELOCATION_STATUS_FAILED,
@@ -595,6 +1242,7 @@
}
CHARGING_STATUS_CODE_TO_NAME: Final = {
+ DreameVacuumChargingStatus.UNKNOWN: STATE_UNKNOWN,
DreameVacuumChargingStatus.CHARGING: CHARGING_STATUS_CHARGING,
DreameVacuumChargingStatus.NOT_CHARGING: CHARGING_STATUS_NOT_CHARGING,
DreameVacuumChargingStatus.CHARGING_COMPLETED: CHARGING_STATUS_CHARGING_COMPLETED,
@@ -602,6 +1250,7 @@
}
ERROR_CODE_TO_ERROR_NAME: Final = {
+ DreameVacuumErrorCode.UNKNOWN: STATE_UNKNOWN,
DreameVacuumErrorCode.NO_ERROR: ERROR_NO_ERROR,
DreameVacuumErrorCode.DROP: ERROR_DROP,
DreameVacuumErrorCode.CLIFF: ERROR_CLIFF,
@@ -672,6 +1321,29 @@
DreameVacuumErrorCode.MOP_REMOVED_2: ERROR_MOP_REMOVED,
DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE: ERROR_MOP_PAD_STOP_ROTATE,
DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE_2: ERROR_MOP_PAD_STOP_ROTATE,
+ DreameVacuumErrorCode.MOP_INSTALL_FAILED: ERROR_MOP_INSTALL_FAILED,
+ DreameVacuumErrorCode.LOW_BATTERY_TURN_OFF: ERROR_LOW_BATTERY_TURN_OFF,
+ DreameVacuumErrorCode.DIRTY_TANK_NOT_INSTALLED: ERROR_DIRTY_TANK_NOT_INSTALLED,
+ DreameVacuumErrorCode.ROBOT_IN_HIDDEN_ROOM: ERROR_ROBOT_IN_HIDDEN_ROOM,
+ DreameVacuumErrorCode.LDS_FAILED_TO_LIFT: ERROR_LDS_FAILED_TO_LIFT,
+ DreameVacuumErrorCode.ROBOT_STUCK: ERROR_ROBOT_STUCK,
+ DreameVacuumErrorCode.ROBOT_STUCK_REPEAT: ERROR_ROBOT_STUCK,
+ DreameVacuumErrorCode.SLIPPERY_FLOOR: ERROR_SLIPPERY_FLOOR,
+ DreameVacuumErrorCode.UNKNOWN_ERROR: STATE_UNKNOWN,
+ DreameVacuumErrorCode.CHECK_MOP_INSTALL: ERROR_CHECK_MOP_INSTALL,
+ DreameVacuumErrorCode.DIRTY_WATER_TANK_FULL: ERROR_DIRTY_WATER_TANK_FULL,
+ DreameVacuumErrorCode.RETRACTABLE_LEG_STUCK: ERROR_RETRACTABLE_LEG_STUCK,
+ DreameVacuumErrorCode.INTERNAL_ERROR: ERROR_INTERNAL_ERROR,
+ DreameVacuumErrorCode.ROBOT_STUCK_2: ERROR_ROBOT_STUCK,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_TABLES: ERROR_ROBOT_STUCK_ON_TABLES,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_PASSAGE: ERROR_ROBOT_STUCK_ON_PASSAGE,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_THRESHOLD: ERROR_ROBOT_STUCK_ON_THRESHOLD,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_LOW_LYING_AREA: ERROR_ROBOT_STUCK_ON_LOW_LYING_AREA,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_RAMP: ERROR_ROBOT_STUCK_ON_RAMP,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_OBSTACLE: ERROR_ROBOT_STUCK_ON_OBSTACLE,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_PET: ERROR_ROBOT_STUCK_ON_PET,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_SLIPPERY_SURFACE: ERROR_ROBOT_STUCK_ON_SLIPPERY_SURFACE,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_CARPET: ERROR_ROBOT_STUCK_ON_CARPET,
DreameVacuumErrorCode.BIN_FULL: ERROR_BIN_FULL,
DreameVacuumErrorCode.BIN_OPEN: ERROR_BIN_OPEN,
DreameVacuumErrorCode.BIN_OPEN_2: ERROR_BIN_OPEN,
@@ -685,22 +1357,68 @@
DreameVacuumErrorCode.WET_MOP_PAD: ERROR_WET_MOP_PAD,
DreameVacuumErrorCode.CLEAN_MOP_PAD: ERROR_CLEAN_MOP_PAD,
DreameVacuumErrorCode.CLEAN_TANK_LEVEL: ERROR_CLEAN_TANK_LEVEL,
+ DreameVacuumErrorCode.STATION_DISCONNECTED: ERROR_STATION_DISCONNECTED,
DreameVacuumErrorCode.DIRTY_TANK_LEVEL: ERROR_DIRTY_TANK_LEVEL,
DreameVacuumErrorCode.WASHBOARD_LEVEL: ERROR_WASHBOARD_LEVEL,
+ DreameVacuumErrorCode.NO_MOP_IN_STATION: ERROR_NO_MOP_IN_STATION,
+ DreameVacuumErrorCode.DUST_BAG_FULL: ERROR_DUST_BAG_FULL,
+ DreameVacuumErrorCode.SELF_TEST_FAILED: ERROR_SELF_TEST_FAILED,
+ DreameVacuumErrorCode.UNKNOWN_WARNING: STATE_UNKNOWN,
+ DreameVacuumErrorCode.WASHBOARD_NOT_WORKING: ERROR_WASHBOARD_NOT_WORKING,
+ DreameVacuumErrorCode.DRAINAGE_FAILED: ERROR_DRAINAGE_FAILED,
+ DreameVacuumErrorCode.MOP_NOT_DETECTED: ERROR_MOP_NOT_DETECTED,
+ DreameVacuumErrorCode.MOP_HOLDER_ERROR: ERROR_MOP_HOLDER_ERROR,
+ DreameVacuumErrorCode.DOCK_ERROR: ERROR_DOCK_ERROR,
+ DreameVacuumErrorCode.WASH_FAILED: ERROR_WASH_FAILED,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_CURTAIN: ERROR_ROBOT_STUCK_ON_CURTAIN,
+ DreameVacuumErrorCode.EDGE_MOP_STOP_ROTATE: ERROR_EDGE_MOP_STOP_ROTATE,
+ DreameVacuumErrorCode.EDGE_MOP_DETACHED: ERROR_EDGE_MOP_DETACHED,
+ DreameVacuumErrorCode.CHASSIS_LIFT_MALFUNCTION: ERROR_CHASSIS_LIFT_MALFUNCTION,
+ DreameVacuumErrorCode.INTERNAL_ERROR_2: ERROR_INTERNAL_ERROR,
+ DreameVacuumErrorCode.MOP_COVER_ERROR: ERROR_MOP_COVER_ERROR,
+ DreameVacuumErrorCode.ROLLER_MOP_ERROR: ERROR_ROLLER_MOP_ERROR,
+ DreameVacuumErrorCode.ONBOARD_WATER_TANK_EMPTY: ERROR_ONBOARD_WATER_TANK_EMPTY,
+ DreameVacuumErrorCode.ONBOARD_DIRTY_WATER_TANK_FULL: ERROR_ONBOARD_DIRTY_WATER_TANK_FULL,
+ DreameVacuumErrorCode.MOP_NOT_INSTALLED: ERROR_MOP_NOT_INSTALLED,
+ DreameVacuumErrorCode.ROLLER_MOP_ERROR_2: ERROR_ROLLER_MOP_ERROR,
+ DreameVacuumErrorCode.FLUFFING_ROLLER_ERROR: ERROR_FLUFFING_ROLLER_ERROR,
+ DreameVacuumErrorCode.MOP_COVER_ERROR_2: ERROR_MOP_COVER_ERROR,
+ DreameVacuumErrorCode.BLOCKED_BY_OBSTACLE: ERROR_BLOCKED_BY_OBSTACLE,
+ DreameVacuumErrorCode.RETURN_TO_CHARGE_FAILED: ERROR_RETURN_TO_CHARGE_FAILED,
}
DUST_COLLECTION_TO_NAME: Final = {
+ DreameVacuumDustCollection.UNKNOWN: STATE_UNKNOWN,
DreameVacuumDustCollection.NOT_AVAILABLE: DUST_COLLECTION_NOT_AVAILABLE,
DreameVacuumDustCollection.AVAILABLE: DUST_COLLECTION_AVAILABLE,
}
AUTO_EMPTY_STATUS_TO_NAME: Final = {
+ DreameVacuumAutoEmptyStatus.UNKNOWN: STATE_UNKNOWN,
DreameVacuumAutoEmptyStatus.IDLE: STATE_IDLE,
DreameVacuumAutoEmptyStatus.ACTIVE: AUTO_EMPTY_STATUS_ACTIVE,
DreameVacuumAutoEmptyStatus.NOT_PERFORMED: AUTO_EMPTY_STATUS_NOT_PERFORMED,
}
+MAP_RECOVERY_STATUS_TO_NAME: Final = {
+ DreameVacuumMapRecoveryStatus.UNKNOWN: STATE_UNKNOWN,
+ DreameVacuumMapRecoveryStatus.IDLE: STATE_IDLE,
+ DreameVacuumMapRecoveryStatus.RUNNING: MAP_RECOVERY_STATUS_RUNNING,
+ DreameVacuumMapRecoveryStatus.SUCCESS: MAP_RECOVERY_STATUS_SUCCESS,
+ DreameVacuumMapRecoveryStatus.FAIL: MAP_RECOVERY_STATUS_FAIL,
+ DreameVacuumMapRecoveryStatus.FAIL_2: MAP_RECOVERY_STATUS_FAIL,
+}
+
+MAP_BACKUP_STATUS_TO_NAME: Final = {
+ DreameVacuumMapBackupStatus.UNKNOWN: STATE_UNKNOWN,
+ DreameVacuumMapBackupStatus.IDLE: STATE_IDLE,
+ DreameVacuumMapBackupStatus.RUNNING: MAP_BACKUP_STATUS_RUNNING,
+ DreameVacuumMapBackupStatus.SUCCESS: MAP_BACKUP_STATUS_SUCCESS,
+ DreameVacuumMapBackupStatus.FAIL: MAP_BACKUP_STATUS_FAIL,
+}
+
SELF_WASH_BASE_STATUS_TO_NAME: Final = {
+ DreameVacuumSelfWashBaseStatus.UNKNOWN: STATE_UNKNOWN,
DreameVacuumSelfWashBaseStatus.IDLE: STATE_IDLE,
DreameVacuumSelfWashBaseStatus.WASHING: SELF_WASH_BASE_STATUS_WASHING,
DreameVacuumSelfWashBaseStatus.DRYING: SELF_WASH_BASE_STATUS_DRYING,
@@ -710,25 +1428,257 @@
DreameVacuumSelfWashBaseStatus.ADDING_WATER: SELF_WASH_BASE_STATUS_ADDING_WATER,
}
-SELF_AREA_CLEAN_TO_NAME: Final = {
- DreameVacuumSelfCleanArea.FIVE_SQUARE_METERS: SELF_AREA_CLEAN_FIVE_SQUARE_METERS,
- DreameVacuumSelfCleanArea.TEN_SQUARE_METERS: SELF_AREA_CLEAN_TEN_SQUARE_METERS,
- DreameVacuumSelfCleanArea.FIFTEEN_SQUARE_METERS: SELF_AREA_CLEAN_FIFTEEN_SQUARE_METERS,
- DreameVacuumSelfCleanArea.SINGLE_ZONE: SELF_AREA_CLEAN_SINGLE_ZONE,
-}
-
MOP_WASH_LEVEL_TO_NAME: Final = {
DreameVacuumMopWashLevel.DEEP: MOP_WASH_LEVEL_DEEP,
DreameVacuumMopWashLevel.DAILY: MOP_WASH_LEVEL_DAILY,
DreameVacuumMopWashLevel.WATER_SAVING: MOP_WASH_LEVEL_WATER_SAVING,
}
+MOP_CLEAN_FREQUENCY_TO_NAME: Final = {
+ DreameVacuumMopCleanFrequency.BY_ROOM: MOP_CLEAN_FREQUENCY_BY_ROOM,
+ DreameVacuumMopCleanFrequency.FIVE_SQUARE_METERS: MOP_CLEAN_FREQUENCY_FIVE_SQUARE_METERS,
+ DreameVacuumMopCleanFrequency.EIGHT_SQUARE_METERS: MOP_CLEAN_FREQUENCY_EIGHT_SQUARE_METERS,
+ DreameVacuumMopCleanFrequency.TEN_SQUARE_METERS: MOP_CLEAN_FREQUENCY_TEN_SQUARE_METERS,
+ DreameVacuumMopCleanFrequency.FIFTEEN_SQUARE_METERS: MOP_CLEAN_FREQUENCY_FIFTEEN_SQUARE_METERS,
+ DreameVacuumMopCleanFrequency.TWENTY_SQUARE_METERS: MOP_CLEAN_FREQUENCY_TWENTY_SQUARE_METERS,
+ DreameVacuumMopCleanFrequency.TWENTYFIVE_SQUARE_METERS: MOP_CLEAN_FREQUENCY_TWENTYFIVE_SQUARE_METERS,
+}
+
MOPPING_TYPE_TO_NAME: Final = {
DreameVacuumMoppingType.DEEP: MOPPING_TYPE_DEEP,
DreameVacuumMoppingType.DAILY: MOPPING_TYPE_DAILY,
DreameVacuumMoppingType.ACCURATE: MOPPING_TYPE_ACCURATE,
}
+STREAM_STATUS_TO_NAME: Final = {
+ DreameVacuumStreamStatus.UNKNOWN: STATE_UNKNOWN,
+ DreameVacuumStreamStatus.IDLE: STATE_IDLE,
+ DreameVacuumStreamStatus.VIDEO: STREAM_STATUS_VIDEO,
+ DreameVacuumStreamStatus.AUDIO: STREAM_STATUS_AUDIO,
+ DreameVacuumStreamStatus.RECORDING: STREAM_STATUS_RECORDING,
+}
+
+VOICE_ASSISTANT_LANGUAGE_TO_NAME: Final = {
+ DreameVacuumVoiceAssistantLanguage.DEFAULT: VOICE_ASSISTANT_LANGUAGE_DEFAULT,
+ DreameVacuumVoiceAssistantLanguage.ENGLISH: VOICE_ASSISTANT_LANGUAGE_ENGLISH,
+ DreameVacuumVoiceAssistantLanguage.GERMAN: VOICE_ASSISTANT_LANGUAGE_GERMAN,
+ DreameVacuumVoiceAssistantLanguage.RUSSIAN: VOICE_ASSISTANT_LANGUAGE_RUSSIAN,
+ DreameVacuumVoiceAssistantLanguage.ITALIAN: VOICE_ASSISTANT_LANGUAGE_ITALIAN,
+ DreameVacuumVoiceAssistantLanguage.FRENCH: VOICE_ASSISTANT_LANGUAGE_FRENCH,
+ DreameVacuumVoiceAssistantLanguage.KOREAN: VOICE_ASSISTANT_LANGUAGE_KOREAN,
+ DreameVacuumVoiceAssistantLanguage.CHINESE: VOICE_ASSISTANT_LANGUAGE_CHINESE,
+}
+
+MOP_PRESSURE_TO_NAME: Final = {
+ DreameVacuumMopPressure.LIGHT: WASHING_MODE_LIGHT,
+ DreameVacuumMopPressure.NORMAL: WATER_TEMPERATURE_NORMAL,
+}
+
+MOP_TEMPERATURE_TO_NAME: Final = {
+ DreameVacuumMopTemperature.NORMAL: WATER_TEMPERATURE_NORMAL,
+ DreameVacuumMopTemperature.WARM: WATER_TEMPERATURE_WARM,
+}
+
+LOW_LYING_AREA_FREQUENCY_TO_NAME: Final = {
+ DreameVacuumLowLyingAreaFrequency.WEEKLY: MOP_PAD_SWING_WEEKLY,
+ DreameVacuumLowLyingAreaFrequency.DAILY: MOP_PAD_SWING_DAILY,
+}
+
+SCRAPER_FREQUENCY_TO_NAME: Final = {
+ DreameVacuumScraperFrequency.OFF: STATE_OFF,
+ DreameVacuumScraperFrequency.WEEKLY: MOP_PAD_SWING_WEEKLY,
+ DreameVacuumScraperFrequency.DAILY: MOP_PAD_SWING_DAILY,
+}
+
+WIDER_CORNER_COVERAGE_TO_NAME: Final = {
+ DreameVacuumWiderCornerCoverage.OFF: STATE_OFF,
+ DreameVacuumWiderCornerCoverage.LOW_FREQUENCY: WIDER_CORNER_COVERAGE_LOW_FREQUENCY,
+ DreameVacuumWiderCornerCoverage.HIGH_FREQUENCY: WIDER_CORNER_COVERAGE_HIGH_FREQUENCY,
+}
+
+MOP_PAD_SWING_TO_NAME: Final = {
+ DreameVacuumMopPadSwing.OFF: STATE_OFF,
+ DreameVacuumMopPadSwing.AUTO: MOP_PAD_SWING_AUTO,
+ DreameVacuumMopPadSwing.DAILY: MOP_PAD_SWING_DAILY,
+ DreameVacuumMopPadSwing.WEEKLY: MOP_PAD_SWING_WEEKLY,
+}
+
+MOP_EXTEND_FREQUENCY_TO_NAME: Final = {
+ DreameVacuumMopExtendFrequency.STANDARD: MOP_EXTEND_FREQUENCY_STANDARD,
+ DreameVacuumMopExtendFrequency.INTELLIGENT: MOP_EXTEND_FREQUENCY_INTELLIGENT,
+ DreameVacuumMopExtendFrequency.HIGH: MOP_EXTEND_FREQUENCY_HIGH,
+}
+
+SECOND_CLEANING_TO_NAME: Final = {
+ DreameVacuumSecondCleaning.OFF: STATE_OFF,
+ DreameVacuumSecondCleaning.IN_DEEP_MODE: SECOND_CLEANING_IN_DEEP_MODE,
+ DreameVacuumSecondCleaning.IN_ALL_MODES: SECOND_CLEANING_IN_ALL_MODES,
+}
+
+CLEANING_ROUTE_TO_NAME: Final = {
+ DreameVacuumCleaningRoute.QUICK: ROUTE_QUICK,
+ DreameVacuumCleaningRoute.STANDARD: ROUTE_STANDARD,
+ DreameVacuumCleaningRoute.INTENSIVE: ROUTE_INTENSIVE,
+ DreameVacuumCleaningRoute.DEEP: ROUTE_DEEP,
+}
+
+CUSTOM_MOPPING_ROUTE_TO_NAME: Final = {
+ DreameVacuumCustomMoppingRoute.OFF: ROUTE_OFF,
+ DreameVacuumCustomMoppingRoute.STANDARD: ROUTE_STANDARD,
+ DreameVacuumCustomMoppingRoute.INTENSIVE: ROUTE_INTENSIVE,
+ DreameVacuumCustomMoppingRoute.DEEP: ROUTE_DEEP,
+}
+
+CLEANGENIUS_TO_NAME = {
+ DreameVacuumCleanGenius.OFF: STATE_OFF,
+ DreameVacuumCleanGenius.ROUTINE_CLEANING: CLEANGENIUS_ROUTINE_CLEANING,
+ DreameVacuumCleanGenius.DEEP_CLEANING: CLEANGENIUS_DEEP_CLEANING,
+}
+
+CLEANGENIUS_MODE_TO_NAME = {
+ DreameVacuumCleanGeniusMode.VACUUM_AND_MOP: CLEANGENIUS_MODE_VACUUM_AND_MOP,
+ DreameVacuumCleanGeniusMode.MOP_AFTER_VACUUM: CLEANGENIUS_MODE_MOP_AFTER_VACUUM,
+}
+
+WASHING_MODE_TO_NAME = {
+ DreameVacuumWashingMode.LIGHT: WASHING_MODE_LIGHT,
+ DreameVacuumWashingMode.STANDARD: WASHING_MODE_STANDARD,
+ DreameVacuumWashingMode.DEEP: WASHING_MODE_DEEP,
+ DreameVacuumWashingMode.ULTRA_WASHING: WASHING_MODE_ULTRA_WASHING,
+}
+
+WATER_TEMPERATURE_TO_NAME = {
+ DreameVacuumWaterTemperature.NORMAL: WATER_TEMPERATURE_NORMAL,
+ DreameVacuumWaterTemperature.MILD: WATER_TEMPERATURE_MILD,
+ DreameVacuumWaterTemperature.WARM: WATER_TEMPERATURE_WARM,
+ DreameVacuumWaterTemperature.HOT: WATER_TEMPERATURE_HOT,
+ DreameVacuumWaterTemperature.MAX: WATER_TEMPERATURE_MAX,
+}
+
+SELF_CLEAN_FREQUENCY_TO_NAME: Final = {
+ DreameVacuumSelfCleanFrequency.BY_AREA: SELF_CLEAN_FREQUENCY_BY_AREA,
+ DreameVacuumSelfCleanFrequency.BY_TIME: SELF_CLEAN_FREQUENCY_BY_TIME,
+ DreameVacuumSelfCleanFrequency.BY_ROOM: SELF_CLEAN_FREQUENCY_BY_ROOM,
+ DreameVacuumSelfCleanFrequency.INTELLIGENT: SELF_CLEAN_FREQUENCY_INTELLIGENT,
+}
+
+AUTO_EMPTY_MODE_TO_NAME = {
+ DreameVacuumAutoEmptyMode.OFF: STATE_OFF,
+ DreameVacuumAutoEmptyMode.STANDARD: AUTO_EMPTY_MODE_STANDARD,
+ DreameVacuumAutoEmptyMode.HIGH_FREQUENCY: AUTO_EMPTY_MODE_HIGH_FREQUENCY,
+ DreameVacuumAutoEmptyMode.LOW_FREQUENCY: AUTO_EMPTY_MODE_LOW_FREQUENCY,
+}
+
+AUTO_EMPTY_MODE_V2_TO_NAME = {
+ DreameVacuumAutoEmptyModeV2.OFF: STATE_OFF,
+ DreameVacuumAutoEmptyModeV2.STANDARD: AUTO_EMPTY_MODE_STANDARD,
+ DreameVacuumAutoEmptyModeV2.CUSTOM_FREQUENCY: AUTO_EMPTY_MODE_CUSTOM_FREQUENCY,
+ DreameVacuumAutoEmptyModeV2.HIGH_FREQUENCY: AUTO_EMPTY_MODE_HIGH_FREQUENCY,
+ DreameVacuumAutoEmptyModeV2.LOW_FREQUENCY: AUTO_EMPTY_MODE_LOW_FREQUENCY,
+ DreameVacuumAutoEmptyModeV2.INTELLIGENT: AUTO_EMPTY_MODE_INTELLIGENT,
+}
+
+DRAINAGE_STATUS_TO_NAME: Final = {
+ DreameVacuumDrainageStatus.UNKNOWN: STATE_UNKNOWN,
+ DreameVacuumDrainageStatus.IDLE: STATE_IDLE,
+ DreameVacuumDrainageStatus.DRAINING: DRAINAGE_STATUS_DRAINING,
+ DreameVacuumDrainageStatus.DRAINING_SUCCESS: DRAINAGE_STATUS_DRAINING_SUCCESS,
+ DreameVacuumDrainageStatus.DRAINING_FAILED: DRAINAGE_STATUS_DRAINING_FAILED,
+}
+
+LOW_WATER_WARNING_TO_NAME: Final = {
+ DreameVacuumLowWaterWarning.UNKNOWN: STATE_UNKNOWN,
+ DreameVacuumLowWaterWarning.NO_WARNING: LOW_WATER_WARNING_NO_WARNING,
+ DreameVacuumLowWaterWarning.NO_WATER_LEFT_DISMISS: LOW_WATER_WARNING_NO_WATER_LEFT_DISMISS,
+ DreameVacuumLowWaterWarning.NO_WATER_LEFT: LOW_WATER_WARNING_NO_WATER_LEFT,
+ DreameVacuumLowWaterWarning.NO_WATER_LEFT_AFTER_CLEAN: LOW_WATER_WARNING_NO_WATER_LEFT_AFTER_CLEAN,
+ DreameVacuumLowWaterWarning.NO_WATER_FOR_CLEAN: LOW_WATER_WARNING_NO_WATER_FOR_CLEAN,
+ DreameVacuumLowWaterWarning.LOW_WATER: LOW_WATER_WARNING_LOW_WATER,
+ DreameVacuumLowWaterWarning.TANK_NOT_INSTALLED: LOW_WATER_WARNING_TANK_NOT_INSTALLED,
+}
+
+TASK_TYPE_TO_NAME: Final = {
+ DreameVacuumTaskType.UNKNOWN: STATE_UNKNOWN,
+ DreameVacuumTaskType.IDLE: STATE_IDLE,
+ DreameVacuumTaskType.STANDARD: TASK_TYPE_STANDARD,
+ DreameVacuumTaskType.STANDARD_PAUSED: TASK_TYPE_STANDARD_PAUSED,
+ DreameVacuumTaskType.CUSTOM: TASK_TYPE_CUSTOM,
+ DreameVacuumTaskType.CUSTOM_PAUSED: TASK_TYPE_CUSTOM_PAUSED,
+ DreameVacuumTaskType.SHORTCUT: TASK_TYPE_SHORTCUT,
+ DreameVacuumTaskType.SHORTCUT_PAUSED: TASK_TYPE_SHORTCUT_PAUSED,
+ DreameVacuumTaskType.SCHEDULED: TASK_TYPE_SCHEDULED,
+ DreameVacuumTaskType.SCHEDULED_PAUSED: TASK_TYPE_SCHEDULED_PAUSED,
+ DreameVacuumTaskType.SMART: TASK_TYPE_SMART,
+ DreameVacuumTaskType.SMART_PAUSED: TASK_TYPE_SMART_PAUSED,
+ DreameVacuumTaskType.PARTIAL: TASK_TYPE_PARTIAL,
+ DreameVacuumTaskType.PARTIAL_PAUSED: TASK_TYPE_PARTIAL_PAUSED,
+ DreameVacuumTaskType.SUMMON: TASK_TYPE_SUMMON,
+ DreameVacuumTaskType.SUMMON_PAUSED: TASK_TYPE_SUMMON_PAUSED,
+ DreameVacuumTaskType.WATER_STAIN: TASK_TYPE_WATER_STAIN,
+ DreameVacuumTaskType.WATER_STAIN_PAUSED: TASK_TYPE_WATER_STAIN_PAUSED,
+ DreameVacuumTaskType.BOOSTED_EDGE_CLEANING: TASK_TYPE_BOOSTED_EDGE_CLEANING,
+ DreameVacuumTaskType.HAIR_COMPRESSING: TASK_TYPE_HAIR_COMPRESSING,
+ DreameVacuumTaskType.LARGE_PARTICLE_CLEANING: TASK_TYPE_LARGE_PARTICLE_CLEANING,
+ DreameVacuumTaskType.INTENSIVE_STAIN_CLEANING: TASK_TYPE_INTENSIVE_STAIN_CLEANING,
+ DreameVacuumTaskType.STAIN_CLEANING: TASK_TYPE_STAIN_CLEANING,
+ DreameVacuumTaskType.INITIAL_DEEP_CLEANING: TASK_TYPE_INITIAL_DEEP_CLEANING,
+ DreameVacuumTaskType.INITIAL_DEEP_CLEANING_PAUSED: TASK_TYPE_INITIAL_DEEP_CLEANING_PAUSED,
+ DreameVacuumTaskType.MOP_PAD_HEATING: TASK_TYPE_MOP_PAD_HEATING,
+ DreameVacuumTaskType.CLEANING_AFTER_MAPPING: TASK_TYPE_CLEANING_AFTER_MAPPING,
+ DreameVacuumTaskType.SMALL_PARTICLE_CLEANING: TASK_TYPE_SMALL_PARTICLE_CLEANING,
+ DreameVacuumTaskType.CHANGING_MOP: TASK_TYPE_CHANGING_MOP,
+ DreameVacuumTaskType.CHANGING_MOP_PAUSED: TASK_TYPE_CHANGING_MOP_PAUSED,
+ DreameVacuumTaskType.FLOOR_MAINTAINING: TASK_TYPE_FLOOR_MAINTAINING,
+ DreameVacuumTaskType.FLOOR_MAINTAINING_PAUSED: TASK_TYPE_FLOOR_MAINTAINING_PAUSED,
+ DreameVacuumTaskType.WOOD_FLOOR_MAINTAINING: TASK_TYPE_WOOD_FLOOR_MAINTAINING,
+}
+
+CLEAN_WATER_TANK_STATUS_TO_NAME: Final = {
+ DreameVacuumCleanWaterTankStatus.INSTALLED: CLEAN_WATER_TANK_STATUS_INSTALLED,
+ DreameVacuumCleanWaterTankStatus.NOT_INSTALLED: CLEAN_WATER_TANK_STATUS_NOT_INSTALLED,
+ DreameVacuumCleanWaterTankStatus.LOW_WATER: CLEAN_WATER_TANK_STATUS_LOW_WATER,
+ DreameVacuumCleanWaterTankStatus.CHECKING: CLEAN_WATER_TANK_STATUS_INSTALLED,
+}
+
+DIRTY_WATER_TANK_STATUS_TO_NAME: Final = {
+ DreameVacuumDirtyWaterTankStatus.INSTALLED: DIRTY_WATER_TANK_STATUS_INSTALLED,
+ DreameVacuumDirtyWaterTankStatus.NOT_INSTALLED_OR_FULL: DIRTY_WATER_TANK_STATUS_NOT_INSTALLED_OR_FULL,
+}
+
+DUST_BAG_STATUS_TO_NAME: Final = {
+ DreameVacuumDustBagStatus.INSTALLED: DUST_BAG_STATUS_INSTALLED,
+ DreameVacuumDustBagStatus.NOT_INSTALLED: DUST_BAG_STATUS_NOT_INSTALLED,
+ DreameVacuumDustBagStatus.CHECK: DUST_BAG_STATUS_CHECK,
+}
+
+AUTO_LDS_COVERAGE_TO_NAME = {
+ DreameVacuumAutoLDSCoverage.OFF: STATE_OFF,
+ DreameVacuumAutoLDSCoverage.SECURITY: AUTO_LDS_COVERAGE_SECURITY,
+ DreameVacuumAutoLDSCoverage.EXTREME: AUTO_LDS_COVERAGE_EXTREME,
+}
+
+DETERGENT_STATUS_TO_NAME: Final = {
+ DreameVacuumDetergentStatus.INSTALLED: DETERGENT_STATUS_INSTALLED,
+ DreameVacuumDetergentStatus.DISABLED: DETERGENT_STATUS_DISABLED,
+ DreameVacuumDetergentStatus.LOW_DETERGENT: DETERGENT_STATUS_LOW_DETERGENT,
+}
+
+HOT_WATER_STATUS_TO_NAME: Final = {
+ DreameVacuumHotWaterStatus.DISABLED: HOT_WATER_STATUS_DISABLED,
+ DreameVacuumHotWaterStatus.ENABLED: HOT_WATER_STATUS_ENABLED,
+}
+
+STATION_DRAINAGE_STATUS_TO_NAME: Final = {
+ DreameVacuumStationDrainageStatus.IDLE: STATE_IDLE,
+ DreameVacuumStationDrainageStatus.DRAINING: STATION_DRAINAGE_STATUS_DRAINING,
+}
+
+DUST_BAG_DRYING_STATUS_TO_NAME: Final = {
+ DreameVacuumDustBagDryingStatus.IDLE: STATE_IDLE,
+ DreameVacuumDustBagDryingStatus.DRYING: SELF_WASH_BASE_STATUS_DRYING,
+ DreameVacuumDustBagDryingStatus.PAUSED: SELF_WASH_BASE_STATUS_PAUSED,
+}
+
ERROR_CODE_TO_IMAGE_INDEX: Final = {
DreameVacuumErrorCode.BUMPER: 1,
DreameVacuumErrorCode.BUMPER_REPEAT: 1,
@@ -750,6 +1700,7 @@
DreameVacuumErrorCode.FILTER_BLOCKED: 9,
DreameVacuumErrorCode.CHARGE_FAULT: 12,
DreameVacuumErrorCode.CHARGE_NO_ELECTRIC: 16,
+ DreameVacuumErrorCode.BATTERY_LOW: 20,
DreameVacuumErrorCode.BATTERY_FAULT: 29,
DreameVacuumErrorCode.INFRARED_FAULT: 39,
DreameVacuumErrorCode.LDS_ERROR: 48,
@@ -764,29 +1715,147 @@
DreameVacuumErrorCode.BLOCKED_2: 63,
DreameVacuumErrorCode.BLOCKED_3: 64,
DreameVacuumErrorCode.RESTRICTED: 65,
+ DreameVacuumErrorCode.ROBOT_IN_HIDDEN_ROOM: 65,
+ DreameVacuumErrorCode.RESTRICTED_2: 65,
+ DreameVacuumErrorCode.RESTRICTED_3: 65,
+ DreameVacuumErrorCode.MOP_REMOVED: 69,
+ DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE: 69,
+ DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE_2: 69,
+ DreameVacuumErrorCode.BIN_FULL: 101,
+ DreameVacuumErrorCode.BIN_FULL_2: 101,
+ DreameVacuumErrorCode.BIN_OPEN: 102,
+ DreameVacuumErrorCode.BIN_OPEN_2: 102,
+ DreameVacuumErrorCode.WATER_TANK: 105,
+ DreameVacuumErrorCode.CLEAN_TANK_LEVEL: 105,
+ DreameVacuumErrorCode.DIRTY_WATER_TANK: 106,
+ DreameVacuumErrorCode.DIRTY_WATER_TANK_2: 106,
+ DreameVacuumErrorCode.DIRTY_WATER_TANK_BLOCKED: 106,
+ DreameVacuumErrorCode.DIRTY_WATER_TANK_PUMP: 106,
+ DreameVacuumErrorCode.DIRTY_TANK_LEVEL: 118,
+ DreameVacuumErrorCode.WATER_TANK_DRY: 107,
+ DreameVacuumErrorCode.MOP_PAD: 111,
+ DreameVacuumErrorCode.WET_MOP_PAD: 111,
+ DreameVacuumErrorCode.WASHBOARD_LEVEL: 114,
+ DreameVacuumErrorCode.CLEAN_MOP_PAD: 114,
+ DreameVacuumErrorCode.NO_MOP_IN_STATION: 69,
+ DreameVacuumErrorCode.DUST_BAG_FULL: 102,
+ DreameVacuumErrorCode.DIRTY_TANK_NOT_INSTALLED: 76,
+ DreameVacuumErrorCode.CLEAN_TANK_LEVEL: 105,
+ DreameVacuumErrorCode.STATION_DISCONNECTED: 117,
+ DreameVacuumErrorCode.SELF_TEST_FAILED: 999,
+ DreameVacuumErrorCode.WASHBOARD_NOT_WORKING: 111,
+ DreameVacuumErrorCode.RETURN_TO_CHARGE_FAILED: 1000,
+}
+
+ERROR_CODE_GEN5_TO_IMAGE_INDEX: Final = {
+ DreameVacuumErrorCode.BUMPER: 1,
+ DreameVacuumErrorCode.BUMPER_REPEAT: 1,
+ DreameVacuumErrorCode.DROP: 2,
+ DreameVacuumErrorCode.DROP_REPEAT: 2,
+ DreameVacuumErrorCode.CLIFF: 3,
+ DreameVacuumErrorCode.BRUSH: 4,
+ DreameVacuumErrorCode.SIDE_BRUSH: 5,
+ DreameVacuumErrorCode.LEFT_WHEEL_MOTOR: 6,
+ DreameVacuumErrorCode.RIGHT_WHEEL_MOTOR: 6,
+ DreameVacuumErrorCode.LEFTWHELL_SPEED: 6,
+ DreameVacuumErrorCode.RIGHTWHELL_SPEED: 6,
+ DreameVacuumErrorCode.TURN_SUFFOCATE: 7,
+ DreameVacuumErrorCode.FORWARD_SUFFOCATE: 7,
+ DreameVacuumErrorCode.ROBOT_STUCK_2: 7,
+ DreameVacuumErrorCode.BOX: 8,
+ DreameVacuumErrorCode.BOX_FULL: 9,
+ DreameVacuumErrorCode.FAN: 9,
+ DreameVacuumErrorCode.FILTER_BLOCKED: 9,
+ DreameVacuumErrorCode.CHARGE_FAULT: 12,
+ DreameVacuumErrorCode.GESTURE: 15,
+ DreameVacuumErrorCode.CHARGE_NO_ELECTRIC: 16,
+ DreameVacuumErrorCode.OPTICAL_FLOW: 19,
+ DreameVacuumErrorCode.INTERNAL_ERROR: 19,
+ DreameVacuumErrorCode.INTERNAL_ERROR_2: 19,
+ DreameVacuumErrorCode.UNKNOWN: 19,
+ DreameVacuumErrorCode.BATTERY_LOW: 20,
+ DreameVacuumErrorCode.LOW_BATTERY_TURN_OFF: 20,
+ DreameVacuumErrorCode.BATTERY_FAULT: 29,
+ DreameVacuumErrorCode.INFRARED_FAULT: 19,
+ DreameVacuumErrorCode.BLOCKED: 47,
+ DreameVacuumErrorCode.LDS_ERROR: 48,
+ DreameVacuumErrorCode.LDS_BUMPER: 49,
+ DreameVacuumErrorCode.EDGE: 54,
+ DreameVacuumErrorCode.EDGE_2: 54,
+ DreameVacuumErrorCode.CARPET: 55,
+ DreameVacuumErrorCode.ULTRASONIC: 58,
+ DreameVacuumErrorCode.ROUTE: 61,
+ DreameVacuumErrorCode.ROUTE_2: 62,
+ DreameVacuumErrorCode.BLOCKED_2: 63,
+ DreameVacuumErrorCode.BLOCKED_3: 64,
+ DreameVacuumErrorCode.RESTRICTED: 65,
+ DreameVacuumErrorCode.ROBOT_IN_HIDDEN_ROOM: 65,
DreameVacuumErrorCode.RESTRICTED_2: 65,
DreameVacuumErrorCode.RESTRICTED_3: 65,
+ DreameVacuumErrorCode.NO_GO_ZONE: 65,
DreameVacuumErrorCode.MOP_REMOVED: 69,
+ DreameVacuumErrorCode.MOP_REMOVED_2: 69,
+ DreameVacuumErrorCode.NO_MOP_IN_STATION: 69,
DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE: 69,
DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE_2: 69,
+ DreameVacuumErrorCode.MOP_INSTALL_FAILED: 74,
+ DreameVacuumErrorCode.DIRTY_TANK_NOT_INSTALLED: 76,
+ DreameVacuumErrorCode.DIRTY_WATER_TANK_FULL: 76,
+ DreameVacuumErrorCode.LDS_FAILED_TO_LIFT: 79,
+ DreameVacuumErrorCode.ROBOT_STUCK: 80,
+ DreameVacuumErrorCode.ROBOT_STUCK_REPEAT: 80,
+ DreameVacuumErrorCode.SLIPPERY_FLOOR: 82,
+ DreameVacuumErrorCode.RETRACTABLE_LEG_STUCK: 88,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_TABLES: 91,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_PASSAGE: 92,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_THRESHOLD: 93,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_LOW_LYING_AREA: 94,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_RAMP: 95,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_OBSTACLE: 96,
+ DreameVacuumErrorCode.BLOCKED_BY_OBSTACLE: 96,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_PET: 97,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_SLIPPERY_SURFACE: 98,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_CARPET: 99,
DreameVacuumErrorCode.BIN_FULL: 101,
DreameVacuumErrorCode.BIN_FULL_2: 101,
DreameVacuumErrorCode.BIN_OPEN: 102,
DreameVacuumErrorCode.BIN_OPEN_2: 102,
+ DreameVacuumErrorCode.DUST_BAG_FULL: 102,
+ DreameVacuumErrorCode.WATERBOX_EMPTY: 105,
DreameVacuumErrorCode.WATER_TANK: 105,
DreameVacuumErrorCode.CLEAN_TANK_LEVEL: 105,
DreameVacuumErrorCode.DIRTY_WATER_TANK: 106,
DreameVacuumErrorCode.DIRTY_WATER_TANK_2: 106,
DreameVacuumErrorCode.DIRTY_WATER_TANK_BLOCKED: 106,
DreameVacuumErrorCode.DIRTY_WATER_TANK_PUMP: 106,
- DreameVacuumErrorCode.DIRTY_TANK_LEVEL: 106,
DreameVacuumErrorCode.WATER_TANK_DRY: 107,
DreameVacuumErrorCode.MOP_PAD: 111,
DreameVacuumErrorCode.WET_MOP_PAD: 111,
- DreameVacuumErrorCode.WASHBOARD_LEVEL: 111,
+ DreameVacuumErrorCode.WASHBOARD_NOT_WORKING: 111,
DreameVacuumErrorCode.CLEAN_MOP_PAD: 114,
+ DreameVacuumErrorCode.WASHBOARD_LEVEL: 114,
+ DreameVacuumErrorCode.STATION_DISCONNECTED: 117,
+ DreameVacuumErrorCode.DIRTY_TANK_LEVEL: 118,
+ DreameVacuumErrorCode.MOP_NOT_DETECTED: 126,
+ DreameVacuumErrorCode.MOP_HOLDER_ERROR: 126,
+ DreameVacuumErrorCode.DOCK_ERROR: 128,
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_CURTAIN: 130,
+ DreameVacuumErrorCode.EDGE_MOP_STOP_ROTATE: 201,
+ DreameVacuumErrorCode.EDGE_MOP_DETACHED: 201,
+ DreameVacuumErrorCode.MOP_COVER_ERROR: 209,
+ DreameVacuumErrorCode.MOP_COVER_ERROR_2: 209,
+ DreameVacuumErrorCode.ROLLER_MOP_ERROR: 210,
+ DreameVacuumErrorCode.ROLLER_MOP_ERROR_2: 210,
+ DreameVacuumErrorCode.ONBOARD_WATER_TANK_EMPTY: 213,
+ DreameVacuumErrorCode.ONBOARD_DIRTY_WATER_TANK_FULL: 214,
+ DreameVacuumErrorCode.MOP_NOT_INSTALLED: 215,
+ DreameVacuumErrorCode.FLUFFING_ROLLER_ERROR: 222,
+ DreameVacuumErrorCode.SELF_TEST_FAILED: 999,
+ DreameVacuumErrorCode.DRAINAGE_FAILED: 999,
+ DreameVacuumErrorCode.RETURN_TO_CHARGE_FAILED: 1000,
}
+
# Dreame Vacuum error descriptions
ERROR_CODE_TO_ERROR_DESCRIPTION: Final = {
DreameVacuumErrorCode.NO_ERROR: ["No error", ""],
@@ -874,7 +1943,7 @@
"Charging error",
"Please use a dry cloth to wipe charging contacts of the robot and auto-empty base.",
],
- DreameVacuumErrorCode.BATTERY_PERCENTAGE: ["", ""],
+ DreameVacuumErrorCode.BATTERY_PERCENTAGE: ["Battery level error", ""],
DreameVacuumErrorCode.HEART: [
"Internal error",
"Please try to restart the vacuum-mop.",
@@ -969,7 +2038,7 @@
"Please try to restart the vacuum-mop.",
],
DreameVacuumErrorCode.BLOCKED: [
- "Route notification",
+ "The robot may be blocked or stuck.",
"Cleanup route is blocked, returning to the dock.",
],
DreameVacuumErrorCode.LDS_ERROR: [
@@ -1053,13 +2122,101 @@
"The mop pads come off, install them before resuming working.",
],
DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE: [
- "Mop Pad Stops Rotating",
+ "Mop Pad Stops Rotating.",
"The mop pad has stopped rotating, please check.",
],
DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE_2: [
- "Mop Pad Stops Rotating",
+ "Mop Pad Stops Rotating.",
"The mop pad has stopped rotating, please check.",
],
+ DreameVacuumErrorCode.MOP_INSTALL_FAILED: [
+ "Mop pad installation failed.",
+ "Failed to install mop pads. Please install manually.",
+ ],
+ DreameVacuumErrorCode.LOW_BATTERY_TURN_OFF: [
+ "Low battery. Robot will shut down soon.",
+ "",
+ ],
+ DreameVacuumErrorCode.DIRTY_TANK_NOT_INSTALLED: [
+ "The used water tank of robot is not installed.",
+ "Please make sure that the used water tank of robot is installed properly, and then start the task.",
+ ],
+ DreameVacuumErrorCode.ROBOT_IN_HIDDEN_ROOM: [
+ "Hidden area. Please move the robot to the appropriate area and retry.",
+ "The area has been hidden. To reuse it, please go to the specific map and click the gray area to manually recover the hidden area.",
+ ],
+ DreameVacuumErrorCode.LDS_FAILED_TO_LIFT: [
+ "Failed to lift LDS module.",
+ "Please clear any debris around the LDS and move robot to an open area to resume the task.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK: [
+ "Move robot to an open area and resume the task.",
+ "LDS cannot be raised here for positioning.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_REPEAT: [
+ "Move robot to an open area and resume the task.",
+ "1. Robot failed to position because the area under the furniture is uneven or has changed.\n2. Start the task or control the LDS to rise in an open area",
+ ],
+ DreameVacuumErrorCode.SLIPPERY_FLOOR: [
+ "Slippery floor. Please try again later.",
+ "Slippery floor. Robot failed to get through obstacles. You can wait for robot to retry, or clear the water around it and resume the task.",
+ ],
+ DreameVacuumErrorCode.CHECK_MOP_INSTALL: [
+ "Check mop Installation Instructions",
+ "Please check if the mop is installed properly.",
+ ],
+ DreameVacuumErrorCode.DIRTY_WATER_TANK_FULL: [
+ "Abnormal water level in the robot's used water tank",
+ "The robot's used water tank is too dirty. Please remove and clean it in time.",
+ ],
+ DreameVacuumErrorCode.RETRACTABLE_LEG_STUCK: [
+ "Retractable legs may be tangled.",
+ "Please check if the retractable legs are tangled.",
+ ],
+ DreameVacuumErrorCode.INTERNAL_ERROR: [
+ "Internal Error",
+ "Malfunction due to an internal error. Try to restart the robot.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_2: [
+ "The robot is stuck",
+ "The robot may be blocked or stuck. Please clear surrounding.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_TABLES: [
+ "The robot is stuck",
+ "Robot stuck among the tables and chairs\n1. Please move robot to an open area and restart the task.\n2. It is recommended to arrange the tables and chairs neatly to prevent robot from getting stuck.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_PASSAGE: [
+ "The robot is stuck",
+ "Robot stuck in the narrow passage\n1. Please move robot to an open area and restart the task.\n2. It is recommended to set the narrow passage as a no-go zone to prevent the robot from getting stuck.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_THRESHOLD: [
+ "The robot is stuck",
+ "Robot stuck at the step/threshold\n1. Please move robot to an open area and restart the task.\n2. It is recommended to set the step/threshold as an impassable threshold to prevent robot from getting stuck.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_LOW_LYING_AREA: [
+ "The robot is stuck",
+ "Robot stuck in a low-clearance area\n1. Please move robot to an open area and restart the task.\n2. It is recommended to set the low area as a no-go zone to prevent robot from getting stuck.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_RAMP: [
+ "Robot has detected Easy-to-Fall ramps on the path",
+ "It is recommended to set passable thresholds if there are no Easy-to-Fall ramps on the path.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_OBSTACLE: [
+ "Robot has detected obstacles on the path",
+ "Please remove obstacles from the path and restart the task.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_PET: [
+ "Robot has detected people or pets on the path",
+ "Please ensure that no people or pets are on the path when restarting the task.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_SLIPPERY_SURFACE: [
+ "Robot is stuck due to slipping",
+ "Robot is stuck due to slipping. Please clean the main wheels.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_CARPET: [
+ "The robot is stuck",
+ "Robot slips on the carpet\n1. Please move robot away from the carpet and restart the task\n2. It is recommended to set the carpet as a no-go zone to prevent robot from getting stuck.",
+ ],
DreameVacuumErrorCode.BIN_FULL: [
"The dust collection bag is full, or the air duct is blocked.",
"The system detects that the dust collection bag is full, or the air duct is blocked.",
@@ -1112,6 +2269,10 @@
"Please fill the clean water tank.",
"The water in the clean water tank is about to be used up. Check and fill the clean water tank promptly.",
],
+ DreameVacuumErrorCode.STATION_DISCONNECTED: [
+ "Base station not powered on.",
+ "Please check whether the power is off or the power switch is on in your home, and re-plug both ends of the base station power supply.",
+ ],
DreameVacuumErrorCode.DIRTY_TANK_LEVEL: [
"The water level in the used water tank is too high.",
"Please check if the used water tank is full.",
@@ -1120,4 +2281,241 @@
"Water level in the washboard is too high.",
"Please clean the used water tank and washboard in time.",
],
+ DreameVacuumErrorCode.NO_MOP_IN_STATION: [
+ "Check if the mop pad is in the base station, or install the mop pad onto the robot manually.",
+ "The mop pad is out of place. Retry after putting it into the base station or install it onto the robot manually.",
+ ],
+ DreameVacuumErrorCode.DUST_BAG_FULL: [
+ "Check whether the dust collection bag is full.",
+ "If so, replace the bag. Please clean the auto-empty vents of the dust bin and the base station regularly.",
+ ],
+ DreameVacuumErrorCode.SELF_TEST_FAILED: [
+ "Self test failed.",
+ "There is no water in the clean water tank of the upper and lower water modules.",
+ ],
+ DreameVacuumErrorCode.WASHBOARD_NOT_WORKING: [
+ "Washboard stops working. Please check.",
+ "Washboard stops working. Please follow troubleshooting steps as below:\n1. Check if the washboard is tangled. Clean up before use\n2. Check if the washboard is installed properly\n3.如仍未解决请联系客服",
+ ],
+ DreameVacuumErrorCode.DRAINAGE_FAILED: [
+ "Abnormal water drainage from used water tank",
+ "Sewage pump error. Please contact customer service.",
+ ],
+ DreameVacuumErrorCode.MOP_NOT_DETECTED: [
+ "Mop not detected.",
+ "Mop not detected. Please install and continue the task.",
+ ],
+ DreameVacuumErrorCode.MOP_HOLDER_ERROR: [
+ "Mop holder error in the dock.",
+ "Mop holder quantity/placement error in the dock. Please install the mop holder or adjust its placement to ensure proper cleaning.",
+ ],
+ DreameVacuumErrorCode.DOCK_ERROR: [
+ "Dock Error",
+ "Please check the dock and try the following steps:\n1. Make sure the hatch is fully closed.\n2. Make sure the three groups of mops are placed on the hatch in red-yellow-blue order. If the mops are currently on the transport carrier or washboard, put them back on the hatch in this order and try again.\n3. Check for any debris inside the dock. Do not place your hand, robot, or other items in the washboard when switching mops.",
+ ],
+ DreameVacuumErrorCode.WASH_FAILED: [
+ "Failed to wash dirty mop.",
+ "Please check the dock and try the following steps:\n1. Please manually attach the mop that needs washing to robot.\n2. Please install other dirty mops onto the hatch.\n3. Go to the app → Dock Functions → Wash to restart the mop-washing task.",
+ ],
+ DreameVacuumErrorCode.ROBOT_STUCK_ON_CURTAIN: [
+ "The robot is stuck",
+ "Robot slips in the curtain area\n1. Please move robot away from the curtain area and restart the task.\n2. Robot cannot clean this curtain area. It is recommended to remove it.",
+ ],
+ DreameVacuumErrorCode.EDGE_MOP_STOP_ROTATE: [
+ "Edge mop stopped rotating.",
+ "Edge mop stopped rotating. Please follow these steps:\n1. Check if robot is on a carpet. Friction between the edge mop and carpet may stop it from rotating. Move robot to a non-carpet area and resume cleaning.\n2. Check if the edge mop is tangled. If so, remove them and resume cleaning.",
+ ],
+ DreameVacuumErrorCode.EDGE_MOP_DETACHED: [
+ "Edge mop detached.",
+ "Edge mop not detected. Please install it before resuming cleaning.",
+ ],
+ DreameVacuumErrorCode.CHASSIS_LIFT_MALFUNCTION: [
+ "Chassis lift malfunction.",
+ "Chassis lift malfunction. Please restart the task. If the issue persists, contact customer service.",
+ ],
+ DreameVacuumErrorCode.INTERNAL_ERROR_2: [
+ "Internal Error",
+ "Malfunction due to an internal error. Try to restart the robot.",
+ ],
+ DreameVacuumErrorCode.MOP_COVER_ERROR: [
+ "Mop cover error.",
+ "Check for any debris near the roller mop and mop cover. Clean the roller mop to prevent the cover from getting stuck. After that, place the robot flat and resume the task. If the issue persists, please contact customer service.",
+ ],
+ DreameVacuumErrorCode.ROLLER_MOP_ERROR: [
+ "Roller mop error.",
+ "Check for any debris near the roller mop and mop cover. Clean the roller mop to prevent it from getting stuck. After that, place the robot flat and resume the task. If the issue persists, please contact customer service.",
+ ],
+ DreameVacuumErrorCode.ONBOARD_WATER_TANK_EMPTY: [
+ "Low water level in robot’s clean water box.",
+ "Low water level in robot’s clean water box. Please refill promptly.",
+ ],
+ DreameVacuumErrorCode.ONBOARD_DIRTY_WATER_TANK_FULL: [
+ "Robot's used water box is full. Please empty it promptly.",
+ "Please take out the box and empty it. Alternatively, you can move robot to the dock for mop-washing (this will also drain the used water).",
+ ],
+ DreameVacuumErrorCode.MOP_NOT_INSTALLED: [
+ "Mop Not Installed",
+ "Please confirm the roller mop is properly installed before starting or resuming the task.",
+ ],
+ DreameVacuumErrorCode.ROLLER_MOP_ERROR_2: [
+ "Roller mop error.",
+ "Check for any debris near the roller mop and mop cover. Clean the roller mop to prevent it from getting stuck. After that, place the robot flat and resume the task. If the issue persists, please contact customer service.",
+ ],
+ DreameVacuumErrorCode.FLUFFING_ROLLER_ERROR: [
+ "Fluffing Roller Error.",
+ "1. Turn robot over with the bottom facing up. Press the release button on one side of the roller mop to take it out, then clean any debris around it.\n2. Press the orange clip and take out the fluffing roller. Clean any hair or debris on it.\n3. After cleaning, install the fluffing roller and press the clip firmly. Then install the roller mop, place the robot flat, and resume the task.\nIf the issue persists, please check more details or contact customer service.",
+ ],
+ DreameVacuumErrorCode.MOP_COVER_ERROR_2: [
+ "Mop cover error.",
+ "Check for any debris near the roller mop and mop cover. Clean the roller mop to prevent the cover from getting stuck. After that, place the robot flat and resume the task. If the issue persists, please contact customer service.",
+ ],
+ DreameVacuumErrorCode.BLOCKED_BY_OBSTACLE: [
+ "Robot blocked by obstacle",
+ "Please check for any obstacles in front of the robot and remove them.",
+ ],
+ DreameVacuumErrorCode.RETURN_TO_CHARGE_FAILED: [
+ "Failed to return to charge.",
+ "Please check the base station.\n1. Check if the ramp extension plate is installed down to the base station;\n2. Check if the base station is powered on;\n3. Make sure there is no obstacle in front of the base station.",
+ ],
+}
+
+# Dreame Vacuum low water warning descriptions
+LOW_WATER_WARNING_CODE_TO_DESCRIPTION: Final = {
+ DreameVacuumLowWaterWarning.NO_WARNING: ["No warning", ""],
+ DreameVacuumLowWaterWarning.NO_WATER_LEFT_DISMISS: [
+ "Please check the clean water tank.",
+ "",
+ ],
+ DreameVacuumLowWaterWarning.NO_WATER_LEFT: [
+ "Please fill the clean water tank.",
+ "The water in the clean water tank is about to be used up. Check and fill the clean water tank promptly.",
+ ],
+ DreameVacuumLowWaterWarning.NO_WATER_LEFT_AFTER_CLEAN: [
+ "Please fill the clean water tank.",
+ "Mop pad has been cleaned. Detected that the water in the clean water tank is insufficient, please fill the clean water tank and empty the used water tank.",
+ ],
+ DreameVacuumLowWaterWarning.NO_WATER_FOR_CLEAN: [
+ "Low water level in the clean water tank.",
+ "Robot has switched to Vacuuming Mode.",
+ ],
+ DreameVacuumLowWaterWarning.LOW_WATER: [
+ "About to run out of water",
+ "Please fill the clean water tank.",
+ ],
+ DreameVacuumLowWaterWarning.TANK_NOT_INSTALLED: [
+ "The clean water tank is not installed.",
+ "Please check the clean water tank",
+ ],
+}
+
+CONSUMABLE_TO_LIFE_WARNING_DESCRIPTION: Final = {
+ DreameVacuumProperty.MAIN_BRUSH_LEFT: [
+ [
+ "Main brush must be replaced",
+ "The main brush is worn out. Please replace it in time and reset the counter.",
+ ],
+ [
+ "Main brush needs to be replaced soon",
+ "The main brush is nearly worn out. Please replace it in time.",
+ ],
+ ],
+ DreameVacuumProperty.SIDE_BRUSH_LEFT: [
+ [
+ "Side brush must be replaced",
+ "The side brush is worn out. Please replace it and reset the counter.",
+ ],
+ [
+ "Side brush needs to be replaced soon",
+ "The side brush is nearly worn out. Please replace it as soon as possible.",
+ ],
+ ],
+ DreameVacuumProperty.FILTER_LEFT: [
+ [
+ "Filter must be replaced",
+ "The filter is worn out. Please replace it in time and reset the counter.",
+ ],
+ [
+ "Filter needs to be replaced soon",
+ "The filter is nearly worn out. Please replace it in time.",
+ ],
+ ],
+ DreameVacuumProperty.SENSOR_DIRTY_LEFT: [
+ ["Sensors must be cleaned", "Please clean the sensors and reset the counter"]
+ ],
+ DreameVacuumProperty.TANK_FILTER_LEFT: [
+ [
+ "Tank filter must be replaced",
+ "The tank filter is worn out. Please replace it in time and reset the counter.",
+ ],
+ [
+ "Tank filter needs to be replaced soon",
+ "The tank filter is nearly worn out. Please replace it in time.",
+ ],
+ ],
+ DreameVacuumProperty.MOP_PAD_LEFT: [
+ ["Mop Pad Worn Out", "Please replace the mop pad and reset the counter."],
+ ["Mop Pad Nearly Worn Out", "Please replace the mop pad timely."],
+ ],
+ DreameVacuumProperty.SILVER_ION_LEFT: [
+ [
+ "Silver Ion Sterilizer Deteriorated",
+ "Please replace the silver ion sterilizer and reset the counter.",
+ ],
+ [
+ "Silver Ion Sterilizer Near to Deterioration",
+ "Please replace the silver ion sterilizer timely.",
+ ],
+ ],
+ DreameVacuumProperty.DETERGENT_LEFT: [
+ [
+ "The detergent is used up",
+ "Please replace the detergent cartridge it and reset the counter.",
+ ],
+ [
+ "The detergent is about to be used up",
+ "The detergent is about to be used up, please replace it in time.",
+ ],
+ ],
+ DreameVacuumProperty.SQUEEGEE_LEFT: [
+ ["Squeegee Worn Out", "Please replace the squeegee and reset the counter."],
+ ["Squeegee Nearly Worn Out", "Please replace the squeegee timely."],
+ ],
+ DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_LEFT: [
+ [
+ "Onboard dirty water tank needs to be cleaned",
+ "Please clean the onboard dirty water tank and reset the counter.",
+ ]
+ ],
+ DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_LEFT: [
+ [
+ "Dirty water channel needs to be cleaned",
+ "Please clean the dirty water channel and reset the counter.",
+ ]
+ ],
+ DreameVacuumProperty.DEODORIZER_LEFT: [
+ [
+ "Used water tank deodorizer has been exhausted.",
+ "Used water tank deodorizer has been exhausted. Please replace it.",
+ ],
+ [
+ "Used water tank deodorizer is running out.",
+ "Used water tank deodorizer is running out. Please replace it.",
+ ],
+ ],
+ DreameVacuumProperty.WHEEL_DIRTY_LEFT: [
+ ["Omnidirectional wheel needs to be cleaned", "Please clean omnidirectional wheel and reset the counter."]
+ ],
+ DreameVacuumProperty.SCALE_INHIBITOR_LEFT: [
+ ["Scale inhibitor has been exhausted", "Please replace the scale inhibitor and reset the counter."],
+ ["Scale inhibitor is running out", "Please replace the scale inhibitor timely."],
+ ],
+ DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_LEFT: [
+ ["Fluffing roller needs to be cleaned", "Please clean fluffing roller and reset the counter."]
+ ],
+ DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_LEFT: [
+ ["Roller mop filter needs to be cleaned", "Please clean roller mop filter and reset the counter."]
+ ],
+ DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_LEFT: [
+ ["Water outlet filter needs to be cleaned", "Please clean water outlet filter and reset the counter."]
+ ],
}
diff --git a/custom_components/dreame_vacuum/dreame/device.py b/custom_components/dreame_vacuum/dreame/device.py
index 38b3addf..ad9ccc24 100644
--- a/custom_components/dreame_vacuum/dreame/device.py
+++ b/custom_components/dreame_vacuum/dreame/device.py
@@ -6,6 +6,7 @@
import copy
import zlib
import base64
+from functools import cmp_to_key
from datetime import datetime
from random import randrange
from threading import Timer
@@ -14,15 +15,28 @@
from .types import (
PIID,
DIID,
+ DID,
+ ACTION_AVAILABILITY,
+ PROPERTY_AVAILABILITY,
+ CONSUMABLE_PROPERTIES,
+ DISCARDED_PROPERTIES,
+ READ_ONLY_PROPERTIES,
+ READ_WRITE_PROPERTIES,
+ WARNING_ERROR_CODE,
DreameVacuumProperty,
+ DreameVacuumAutoSwitchProperty,
+ DreameVacuumStrAIProperty,
+ DreameVacuumAIProperty,
DreameVacuumPropertyMapping,
DreameVacuumAction,
DreameVacuumActionMapping,
DreameVacuumChargingStatus,
DreameVacuumTaskStatus,
DreameVacuumState,
+ DreameVacuumStateOld,
DreameVacuumWaterTank,
DreameVacuumCarpetSensitivity,
+ DreameVacuumCarpetCleaning,
DreameVacuumStatus,
DreameVacuumErrorCode,
DreameVacuumRelocationStatus,
@@ -33,28 +47,81 @@
DreameVacuumWaterVolume,
DreameVacuumMopPadHumidity,
DreameVacuumCleaningMode,
- DreameVacuumSelfCleanArea,
DreameVacuumMopWashLevel,
+ DreameVacuumMopCleanFrequency,
DreameVacuumMoppingType,
+ DreameVacuumStreamStatus,
+ DreameVacuumVoiceAssistantLanguage,
+ DreameVacuumMopPressure,
+ DreameVacuumMopTemperature,
+ DreameVacuumLowLyingAreaFrequency,
+ DreameVacuumScraperFrequency,
+ DreameVacuumWiderCornerCoverage,
+ DreameVacuumMopPadSwing,
+ DreameVacuumMopExtendFrequency,
+ DreameVacuumSecondCleaning,
+ DreameVacuumCleaningRoute,
+ DreameVacuumCustomMoppingRoute,
+ DreameVacuumSelfCleanFrequency,
+ DreameVacuumAutoEmptyMode,
+ DreameVacuumAutoEmptyModeV2,
+ DreameVacuumCleanGenius,
+ DreameVacuumCleanGeniusMode,
+ DreameVacuumWashingMode,
+ DreameVacuumFloorMaterial,
+ DreameVacuumWaterTemperature,
+ DreameVacuumAutoLDSCoverage,
+ DreameVacuumDrainageStatus,
+ DreameVacuumLowWaterWarning,
+ DreameVacuumTaskType,
+ DreameVacuumMapRecoveryStatus,
+ DreameVacuumMapBackupStatus,
+ DreameVacuumCleanWaterTankStatus,
+ DreameVacuumDirtyWaterTankStatus,
+ DreameVacuumDustBagStatus,
+ DreameVacuumDetergentStatus,
+ DreameVacuumHotWaterStatus,
+ DreameVacuumStationDrainageStatus,
+ DreameVacuumDustBagDryingStatus,
+ DreameVacuumShortcutTaskType,
+ DreameVacuumDeviceCapability,
CleaningHistory,
+ DirtyData,
+ RobotType,
MapData,
Segment,
+ Shortcut,
+ ShortcutTask,
+ Obstacle,
+ ObstacleType,
+ CleanupMethod,
+ GoToZoneSettings,
+ Path,
+ PathType,
+ Coordinate,
+ ScheduledTask,
+ DNDTask,
ATTR_ACTIVE_AREAS,
ATTR_ACTIVE_POINTS,
ATTR_ACTIVE_SEGMENTS,
+ ATTR_PREDEFINED_POINTS,
+ ATTR_ACTIVE_CRUISE_POINTS,
)
from .const import (
+ DEVICE_INFO,
STATE_UNKNOWN,
- STATE_UNAVAILABLE,
SUCTION_LEVEL_CODE_TO_NAME,
WATER_VOLUME_CODE_TO_NAME,
MOP_PAD_HUMIDITY_CODE_TO_NAME,
CLEANING_MODE_CODE_TO_NAME,
CARPET_SENSITIVITY_CODE_TO_NAME,
+ CARPET_CLEANING_CODE_TO_NAME,
CHARGING_STATUS_CODE_TO_NAME,
RELOCATION_STATUS_CODE_TO_NAME,
SELF_WASH_BASE_STATUS_TO_NAME,
AUTO_EMPTY_STATUS_TO_NAME,
+ MAP_RECOVERY_STATUS_TO_NAME,
+ MAP_BACKUP_STATUS_TO_NAME,
TASK_STATUS_CODE_TO_NAME,
STATE_CODE_TO_STATE,
ERROR_CODE_TO_ERROR_NAME,
@@ -62,19 +129,75 @@
STATUS_CODE_TO_NAME,
WATER_TANK_CODE_TO_NAME,
DUST_COLLECTION_TO_NAME,
- SELF_AREA_CLEAN_TO_NAME,
MOP_WASH_LEVEL_TO_NAME,
+ MOP_CLEAN_FREQUENCY_TO_NAME,
MOPPING_TYPE_TO_NAME,
+ STREAM_STATUS_TO_NAME,
+ WIDER_CORNER_COVERAGE_TO_NAME,
+ MOP_PAD_SWING_TO_NAME,
+ MOP_EXTEND_FREQUENCY_TO_NAME,
+ SECOND_CLEANING_TO_NAME,
+ CLEANING_ROUTE_TO_NAME,
+ CUSTOM_MOPPING_ROUTE_TO_NAME,
+ CLEANGENIUS_TO_NAME,
+ CLEANGENIUS_MODE_TO_NAME,
+ WASHING_MODE_TO_NAME,
+ WASHING_MODE_ULTRA_WASHING,
+ WATER_TEMPERATURE_TO_NAME,
+ SELF_CLEAN_FREQUENCY_TO_NAME,
+ AUTO_EMPTY_MODE_TO_NAME,
+ AUTO_EMPTY_MODE_V2_TO_NAME,
+ FLOOR_MATERIAL_CODE_TO_NAME,
+ FLOOR_MATERIAL_DIRECTION_CODE_TO_NAME,
+ SEGMENT_VISIBILITY_CODE_TO_NAME,
+ LOW_WATER_WARNING_TO_NAME,
+ LOW_WATER_WARNING_CODE_TO_DESCRIPTION,
+ DRAINAGE_STATUS_TO_NAME,
+ VOICE_ASSISTANT_LANGUAGE_TO_NAME,
+ MOP_PRESSURE_TO_NAME,
+ MOP_TEMPERATURE_TO_NAME,
+ LOW_LYING_AREA_FREQUENCY_TO_NAME,
+ SCRAPER_FREQUENCY_TO_NAME,
+ TASK_TYPE_TO_NAME,
+ CLEAN_WATER_TANK_STATUS_TO_NAME,
+ DIRTY_WATER_TANK_STATUS_TO_NAME,
+ DUST_BAG_STATUS_TO_NAME,
+ DETERGENT_STATUS_TO_NAME,
+ HOT_WATER_STATUS_TO_NAME,
+ STATION_DRAINAGE_STATUS_TO_NAME,
+ DUST_BAG_DRYING_STATUS_TO_NAME,
+ AUTO_LDS_COVERAGE_TO_NAME,
ERROR_CODE_TO_IMAGE_INDEX,
+ ERROR_CODE_GEN5_TO_IMAGE_INDEX,
+ CONSUMABLE_TO_LIFE_WARNING_DESCRIPTION,
PROPERTY_TO_NAME,
- DEVICE_MAP_KEY,
- AI_SETTING_SWITCH,
- AI_SETTING_UPLOAD,
- AI_SETTING_PET,
- AI_SETTING_HUMAN,
- AI_SETTING_FURNITURE,
- AI_SETTING_FLUID,
+ CLEANING_MODE_MOPPING_AFTER_SWEEPING,
+ MOP_WASH_LEVEL_WATER_SAVING,
+ MOP_CLEAN_FREQUENCY_BY_ROOM,
+ MOP_CLEAN_FREQUENCY_FIVE_SQUARE_METERS,
+ MOP_CLEAN_FREQUENCY_EIGHT_SQUARE_METERS,
+ MOP_CLEAN_FREQUENCY_FIFTEEN_SQUARE_METERS,
+ MOP_CLEAN_FREQUENCY_TWENTY_SQUARE_METERS,
+ MOP_CLEAN_FREQUENCY_TWENTYFIVE_SQUARE_METERS,
+ CARPET_CLEANING_ADAPTATION_WITHOUT_ROUTE,
+ CARPET_CLEANING_CROSS,
+ CARPET_CLEANING_VACUUM_AND_MOP,
+ CARPET_CLEANING_REMOVE_MOP,
+ CARPET_CLEANING_IGNORE,
+ FLOOR_MATERIAL_MEDIUM_PILE_CARPET,
+ FLOOR_MATERIAL_LOW_PILE_CARPET,
+ FLOOR_MATERIAL_CARPET,
+ WATER_TEMPERATURE_MAX,
+ SELF_CLEAN_FREQUENCY_INTELLIGENT,
+ AUTO_EMPTY_MODE_HIGH_FREQUENCY,
+ AUTO_EMPTY_MODE_CUSTOM_FREQUENCY,
ATTR_CHARGING,
+ ATTR_DOCKED,
+ ATTR_LOCATED,
+ ATTR_VACUUM_STATE,
+ ATTR_DND,
+ ATTR_SHORTCUTS,
+ ATTR_BATTERY,
ATTR_CLEANING_SEQUENCE,
ATTR_STARTED,
ATTR_PAUSED,
@@ -82,30 +205,90 @@
ATTR_RETURNING_PAUSED,
ATTR_RETURNING,
ATTR_MAPPING,
+ ATTR_MAPPING_AVAILABLE,
+ ATTR_WASHING_AVAILABLE,
+ ATTR_DRYING_AVAILABLE,
+ ATTR_DUST_BAG_DRYING_AVAILABLE,
+ ATTR_DRAINING_AVAILABLE,
+ ATTR_DRYING_LEFT,
+ ATTR_DUST_COLLECTION_AVAILABLE,
ATTR_ROOMS,
+ ATTR_MAPS,
ATTR_CURRENT_SEGMENT,
ATTR_SELECTED_MAP,
+ ATTR_SELECTED_MAP_ID,
+ ATTR_SELECTED_MAP_INDEX,
ATTR_ID,
+ ATTR_DATE,
+ ATTR_INDEX,
ATTR_NAME,
+ ATTR_CUSTOM_NAME,
+ ATTR_RECOVERY_MAP,
ATTR_ICON,
+ ATTR_TYPE,
+ ATTR_ORDER,
ATTR_STATUS,
+ ATTR_DID,
ATTR_CLEANING_MODE,
ATTR_SUCTION_LEVEL,
ATTR_WATER_TANK,
ATTR_COMPLETED,
ATTR_CLEANING_TIME,
+ ATTR_TIMESTAMP,
ATTR_CLEANED_AREA,
ATTR_MOP_PAD_HUMIDITY,
+ ATTR_WASHING_MODE,
+ ATTR_SELF_CLEAN_AREA,
+ ATTR_PREVIOUS_SELF_CLEAN_AREA,
+ ATTR_SELF_CLEAN_AREA_MIN,
+ ATTR_SELF_CLEAN_AREA_MAX,
+ ATTR_SELF_CLEAN_TIME,
+ ATTR_PREVIOUS_SELF_CLEAN_TIME,
+ ATTR_SELF_CLEAN_TIME_MIN,
+ ATTR_SELF_CLEAN_TIME_MAX,
+ ATTR_MOP_CLEAN_FREQUENCY,
ATTR_MOP_PAD,
+ ATTR_WASHING,
+ ATTR_WASHING_PAUSED,
+ ATTR_DRYING,
+ ATTR_DRAINING,
+ ATTR_OFF_PEAK_CHARGING,
+ ATTR_OFF_PEAK_CHARGING_START,
+ ATTR_OFF_PEAK_CHARGING_END,
+ ATTR_CLEANGENIUS,
+ ATTR_WETNESS_LEVEL,
+ ATTR_LOW_WATER,
+ ATTR_CRUISING_TIME,
+ ATTR_CRUISING_TYPE,
+ ATTR_MAP_INDEX,
+ ATTR_MAP_NAME,
+ ATTR_BLOCKED_SEGMENTS,
+ ATTR_INTERRUPT_REASON,
+ ATTR_MULTIPLE_CLEANING_TIME,
+ ATTR_PET,
+ ATTR_CLEANUP_METHOD,
+ ATTR_SEGMENT_CLEANING,
+ ATTR_ZONE_CLEANING,
+ ATTR_SPOT_CLEANING,
+ ATTR_CRUSING,
+ ATTR_HAS_SAVED_MAP,
+ ATTR_HAS_TEMPORARY_MAP,
+ ATTR_AUTO_EMPTY_MODE,
+ ATTR_CARPET_AVOIDANCE,
+ ATTR_FLOOR_DIRECTION_CLEANING_AVAILABLE,
+ ATTR_SHORTCUT_TASK,
+ ATTR_FIRMWARE_VERSION,
+ ATTR_AP,
+ ATTR_CAPABILITIES,
)
-from .resources import ERROR_IMAGE
+from .resources import ERROR_IMAGE, ERROR_IMAGE_GEN5
from .exceptions import (
DeviceUpdateFailedException,
InvalidActionException,
InvalidValueException,
)
from .protocol import DreameVacuumProtocol
-from .map import DreameMapVacuumMapManager
+from .map import DreameMapVacuumMapManager, DreameVacuumMapDecoder
_LOGGER = logging.getLogger(__name__)
@@ -126,23 +309,25 @@ def __init__(
password: str = None,
country: str = None,
prefer_cloud: bool = False,
+ account_type: str = "mi",
device_id: str = None,
auth_key: str = None,
) -> None:
- # Used for tracking the task status is changed from cleaning to completed
- self.cleanup_completed: bool = False
# Used for easy filtering the device from cloud device list and generating unique ids
+ self.info = None
self.mac: str = None
self.token: str = None # Local api token
self.host: str = None # IP address or host name of the device
# Dictionary for storing the current property values
self.data: dict[DreameVacuumProperty, Any] = {}
+ self.auto_switch_data: dict[DreameVacuumAutoSwitchProperty, Any] = None
+ self.ai_data: dict[DreameVacuumStrAIProperty | DreameVacuumAIProperty, Any] = None
self.available: bool = False # Last update is successful or not
self.disconnected: bool = False
- self._update_running: bool = False # Update is running
# Previous cleaning mode for restoring it after water tank is installed or removed
self._previous_cleaning_mode: DreameVacuumCleaningMode = None
+ self._previous_cleangenius: int = None
# Device do not request properties that returned -1 as result. This property used for overriding that behavior at first connection
self._ready: bool = False
# Last settings properties requested time
@@ -150,9 +335,12 @@ def __init__(
self._last_map_list_request: float = 0 # Last map list property requested time
self._last_map_request: float = 0 # Last map request trigger time
self._last_change: float = 0 # Last property change time
- self._last_update_failed: float = 0 # Last update failed time
+ self._last_update_failed: float = None # Last update failed time
self._cleaning_history_update: float = 0 # Cleaning history update time
self._update_fail_count: int = 0 # Update failed counter
+ self._draining_complete_time: int = None
+ self._map_select_time: float = None
+ self._last_map_change_time: float = None
# Map Manager object. Only available when cloud connection is present
self._map_manager: DreameMapVacuumMapManager = None
self._update_callback = None # External update callback for device
@@ -160,139 +348,282 @@ def __init__(
# External update callbacks for specific device property
self._property_update_callback = {}
self._update_timer: Timer = None # Update schedule timer
+ self._keep_alive_timer: Timer = None # Keep alive request timer
+ self._callback_timer: Timer = None # Update listener debouncing timer
# Used for requesting consumable properties after reset action otherwise they will only requested when cleaning completed
- self._consumable_reset: bool = False
+ self._consumable_change: bool = False
self._remote_control: bool = False
- self._dirty_data: dict[DreameVacuumProperty, Any] = {}
+ self._dirty_data: dict[DreameVacuumProperty, DirtyData] = {}
+ self._dirty_auto_switch_data: dict[DreameVacuumAutoSwitchProperty, DirtyData] = {}
+ self._dirty_ai_data: dict[DreameVacuumStrAIProperty | DreameVacuumAIProperty, Any] = None
+ self._discard_timeout = 5
+ self._restore_timeout = 15
self._name = name
self.mac = mac
self.token = token
self.host = host
self.auth_failed = False
+ self.account_type = account_type
self.status = DreameVacuumDeviceStatus(self)
+ self.capability = DreameVacuumDeviceCapability(self)
+
+ # Remove write only and response only properties from default list
+ self._default_properties = list(
+ set([prop for prop in DreameVacuumProperty])
+ - set(
+ [
+ DreameVacuumProperty.SCHEDULE_ID,
+ DreameVacuumProperty.REMOTE_CONTROL,
+ DreameVacuumProperty.VOICE_CHANGE,
+ DreameVacuumProperty.VOICE_CHANGE_STATUS,
+ DreameVacuumProperty.MAP_RECOVERY,
+ DreameVacuumProperty.CLEANING_START_TIME,
+ DreameVacuumProperty.CLEAN_LOG_FILE_NAME,
+ DreameVacuumProperty.CLEANING_PROPERTIES,
+ DreameVacuumProperty.CLEAN_LOG_STATUS,
+ DreameVacuumProperty.MAP_INDEX,
+ DreameVacuumProperty.MAP_NAME,
+ DreameVacuumProperty.CRUISE_TYPE,
+ DreameVacuumProperty.MAP_DATA,
+ DreameVacuumProperty.FRAME_INFO,
+ DreameVacuumProperty.OBJECT_NAME,
+ DreameVacuumProperty.MAP_EXTEND_DATA,
+ DreameVacuumProperty.ROBOT_TIME,
+ DreameVacuumProperty.RESULT_CODE,
+ DreameVacuumProperty.OLD_MAP_DATA,
+ DreameVacuumProperty.FACTORY_TEST_STATUS,
+ DreameVacuumProperty.FACTORY_TEST_RESULT,
+ DreameVacuumProperty.SELF_TEST_STATUS,
+ DreameVacuumProperty.LSD_TEST_STATUS,
+ DreameVacuumProperty.DEBUG_SWITCH,
+ DreameVacuumProperty.SERIAL,
+ DreameVacuumProperty.CALIBRATION_STATUS,
+ DreameVacuumProperty.VERSION,
+ DreameVacuumProperty.PERFORMANCE_SWITCH,
+ DreameVacuumProperty.AI_TEST_STATUS,
+ DreameVacuumProperty.PUBLIC_KEY,
+ DreameVacuumProperty.AUTO_PAIR,
+ DreameVacuumProperty.MCU_VERSION,
+ DreameVacuumProperty.MOP_TEST_STATUS,
+ DreameVacuumProperty.PLATFORM_NETWORK,
+ DreameVacuumProperty.TAKE_PHOTO,
+ DreameVacuumProperty.STEAM_HUMAN_FOLLOW,
+ DreameVacuumProperty.STREAM_KEEP_ALIVE,
+ DreameVacuumProperty.STREAM_UPLOAD,
+ DreameVacuumProperty.STREAM_AUDIO,
+ DreameVacuumProperty.STREAM_RECORD,
+ DreameVacuumProperty.STREAM_CODE,
+ DreameVacuumProperty.STREAM_SET_CODE,
+ DreameVacuumProperty.STREAM_VERIFY_CODE,
+ DreameVacuumProperty.STREAM_RESET_CODE,
+ DreameVacuumProperty.STREAM_CRUISE_POINT,
+ DreameVacuumProperty.STREAM_FAULT,
+ DreameVacuumProperty.STREAM_TASK,
+ ]
+ )
+ )
self.listen(self._task_status_changed, DreameVacuumProperty.TASK_STATUS)
self.listen(self._status_changed, DreameVacuumProperty.STATUS)
+ self.listen(self._faults_changed, DreameVacuumProperty.FAULTS)
self.listen(self._charging_status_changed, DreameVacuumProperty.CHARGING_STATUS)
+ self.listen(self._cleaning_mode_changed, DreameVacuumProperty.CLEANING_MODE)
self.listen(self._water_tank_changed, DreameVacuumProperty.WATER_TANK)
- self.listen(self._water_tank_changed, DreameVacuumProperty.AUTO_MOUNT_MOP)
+ self.listen(self._water_tank_changed, DreameVacuumProperty.MOP_PAD_INSTALLED)
+ self.listen(self._water_tank_changed, DreameVacuumProperty.MOP_IN_STATION)
+ self.listen(self._auto_mount_mop_changed, DreameVacuumProperty.AUTO_MOUNT_MOP)
self.listen(self._ai_obstacle_detection_changed, DreameVacuumProperty.AI_DETECTION)
- self.listen(self._auto_switch_settings_changed, DreameVacuumProperty.AUTO_SWITCH_SETTINGS)
- self.listen(self._intelligent_recognition_changed, DreameVacuumProperty.INTELLIGENT_RECOGNITION)
+ self.listen(
+ self._auto_switch_settings_changed,
+ DreameVacuumProperty.AUTO_SWITCH_SETTINGS,
+ )
+ self.listen(self._dnd_task_changed, DreameVacuumProperty.DND_TASK)
+ self.listen(self._schedule_changed, DreameVacuumProperty.SCHEDULE)
+ self.listen(self._stream_status_changed, DreameVacuumProperty.STREAM_STATUS)
+ self.listen(self._shortcuts_changed, DreameVacuumProperty.SHORTCUTS)
+ self.listen(
+ self._voice_assistant_language_changed,
+ DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE,
+ )
+ self.listen(self._drainage_status_changed, DreameVacuumProperty.DRAINAGE_STATUS)
+ self.listen(self._auto_water_refilling_changed, DreameVacuumProperty.AUTO_WATER_REFILLING)
+ self.listen(
+ self._self_wash_base_status_changed,
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
+ )
+ self.listen(self._off_peak_charging_changed, DreameVacuumProperty.OFF_PEAK_CHARGING)
+ self.listen(self._suction_level_changed, DreameVacuumProperty.SUCTION_LEVEL)
+ self.listen(self._water_volume_changed, DreameVacuumProperty.WATER_VOLUME)
+ self.listen(self._wetness_level_changed, DreameVacuumProperty.WETNESS_LEVEL)
+ self.listen(self._error_changed, DreameVacuumProperty.ERROR)
+ self.listen(
+ self._map_recovery_status_changed,
+ DreameVacuumProperty.MAP_RECOVERY_STATUS,
+ )
+ self.listen(
+ self._drying_progress_changed,
+ DreameVacuumProperty.DRYING_PROGRESS,
+ )
+ self.listen(
+ self._keep_alive_changed,
+ DreameVacuumProperty.KEEP_ALIVE,
+ )
self._protocol = DreameVacuumProtocol(
- self.host, self.token, username, password, country, prefer_cloud, device_id, auth_key
+ self.host,
+ self.token,
+ username,
+ password,
+ country,
+ prefer_cloud,
+ account_type,
+ device_id,
+ auth_key,
)
if self._protocol.cloud:
self._map_manager = DreameMapVacuumMapManager(self._protocol)
self.listen(self._map_list_changed, DreameVacuumProperty.MAP_LIST)
self.listen(self._recovery_map_list_changed, DreameVacuumProperty.RECOVERY_MAP_LIST)
- self.listen(self._map_property_changed, DreameVacuumProperty.ERROR)
- self.listen(self._map_property_changed, DreameVacuumProperty.SELF_WASH_BASE_STATUS)
+ self.listen(self._battery_level_changed, DreameVacuumProperty.BATTERY_LEVEL)
self.listen(self._map_property_changed, DreameVacuumProperty.CUSTOMIZED_CLEANING)
-
- self._map_manager.listen(self._property_changed)
+ self.listen(self._map_property_changed, DreameVacuumProperty.STATE)
+ self.listen(self._map_property_changed, DreameVacuumProperty.AUTO_EMPTY_STATUS)
+ self.listen(self._map_property_changed, DreameVacuumProperty.AUTO_CHANGE_MOP)
+ self.listen(
+ self._map_backup_status_changed,
+ DreameVacuumProperty.MAP_BACKUP_STATUS,
+ )
+ self._map_manager.listen(self._map_changed, self._map_updated)
self._map_manager.listen_error(self._update_failed)
- def _request_properties(self, properties: list[DreameVacuumProperty] = None) -> bool:
- """Request properties from the device."""
- if not properties:
- properties = [prop for prop in DreameVacuumProperty]
-
- # Remove write only and response only properties from default list
- properties.remove(DreameVacuumProperty.SCHEDULE_ID)
- properties.remove(DreameVacuumProperty.REMOTE_CONTROL)
- properties.remove(DreameVacuumProperty.VOICE_CHANGE)
- properties.remove(DreameVacuumProperty.VOICE_CHANGE_STATUS)
- properties.remove(DreameVacuumProperty.MAP_RECOVERY)
- properties.remove(DreameVacuumProperty.MAP_RECOVERY_STATUS)
- properties.remove(DreameVacuumProperty.CLEANING_START_TIME)
- properties.remove(DreameVacuumProperty.CLEAN_LOG_FILE_NAME)
- properties.remove(DreameVacuumProperty.CLEANING_PROPERTIES)
- properties.remove(DreameVacuumProperty.CLEAN_LOG_STATUS)
- properties.remove(DreameVacuumProperty.MAP_DATA)
- properties.remove(DreameVacuumProperty.FRAME_INFO)
- properties.remove(DreameVacuumProperty.OBJECT_NAME)
- properties.remove(DreameVacuumProperty.MAP_EXTEND_DATA)
- properties.remove(DreameVacuumProperty.ROBOT_TIME)
- properties.remove(DreameVacuumProperty.RESULT_CODE)
- properties.remove(DreameVacuumProperty.OLD_MAP_DATA)
- properties.remove(DreameVacuumProperty.WIFI_MAP)
- properties.remove(DreameVacuumProperty.TAKE_PHOTO)
- properties.remove(DreameVacuumProperty.CAMERA_LIGHT)
- properties.remove(DreameVacuumProperty.CAMERA_BRIGHTNESS)
- properties.remove(DreameVacuumProperty.STREAM_KEEP_ALIVE)
- properties.remove(DreameVacuumProperty.STREAM_UPLOAD)
- properties.remove(DreameVacuumProperty.STREAM_STATUS)
- properties.remove(DreameVacuumProperty.STREAM_AUDIO)
- properties.remove(DreameVacuumProperty.STREAM_RECORD)
- properties.remove(DreameVacuumProperty.STREAM_CODE)
- properties.remove(DreameVacuumProperty.STREAM_SET_CODE)
- properties.remove(DreameVacuumProperty.STREAM_VERIFY_CODE)
- properties.remove(DreameVacuumProperty.STREAM_RESET_CODE)
- properties.remove(DreameVacuumProperty.STREAM_CRUISE_POINT)
- properties.remove(DreameVacuumProperty.STREAM_PROPERTY)
- properties.remove(DreameVacuumProperty.STREAM_FAULT)
- properties.remove(DreameVacuumProperty.STREAM_TASK)
- properties.remove(DreameVacuumProperty.STREAM_SPACE)
+ def _connected_callback(self):
+ if not self._ready:
+ return
+ _LOGGER.info("Requesting properties after connect")
+ self.available = True
+ self.schedule_update(2, True)
+ self._property_changed()
- property_list = []
- for prop in properties:
- if prop in self.property_mapping:
- mapping = self.property_mapping[prop]
- # Do not include properties that are not exists on the device
- if "aiid" not in mapping and (not self._ready or prop.value in self.data):
- property_list.append({"did": str(prop.value), **mapping})
+ def _message_callback(self, message):
+ if not self._ready:
+ return
- props = property_list.copy()
- results = []
- while props:
- result = self._protocol.get_properties(props[:15])
- if result is not None:
- results.extend(result)
- props[:] = props[15:]
+ _LOGGER.debug("Message Callback: %s", message)
+ if "method" in message and "params" in message:
+ self.available = True
+ method = message["method"]
+ params = message["params"]
+ if method == "properties_changed":
+ properties = []
+ map_properties = []
+ for param in params:
+ prop = DID(param["siid"], param["piid"])
+ if prop is not None:
+ if prop in self._default_properties:
+ param["did"] = str(prop.value)
+ param["code"] = 0
+ properties.append(param)
+ continue
+
+ if (
+ prop is DreameVacuumProperty.OBJECT_NAME
+ or prop is DreameVacuumProperty.MAP_DATA
+ or prop is DreameVacuumProperty.ROBOT_TIME
+ or prop is DreameVacuumProperty.OLD_MAP_DATA
+ ):
+ map_properties.append(param)
+
+ if len(map_properties) and self._map_manager:
+ self._map_manager.handle_properties(map_properties)
+
+ self._handle_properties(properties)
+ elif method == "_otc.info":
+ info = DreameVacuumDeviceInfo(params)
+ if info != self.info:
+ self.info = info
+ self._last_change = time.time()
+ if self._ready:
+ self._property_changed()
+
+ def _handle_properties(self, properties) -> bool:
changed = False
callbacks = []
- for prop in results:
+ for prop in properties:
+ if not isinstance(prop, dict):
+ continue
+ did = int(prop["did"])
+ if did not in DreameVacuumProperty._value2member_map_:
+ did = DID(prop["siid"], prop["piid"])
+ if did is None:
+ continue
+ did = int(did.value)
if prop["code"] == 0 and "value" in prop:
- did = int(prop["did"])
value = prop["value"]
-
if did in self._dirty_data:
- if self._dirty_data[did] != value:
+ if (
+ self._dirty_data[did].value != value
+ and time.time() - self._dirty_data[did].update_time < self._discard_timeout
+ ):
_LOGGER.info(
"Property %s Value Discarded: %s <- %s",
DreameVacuumProperty(did).name,
- self._dirty_data[did],
+ self._dirty_data[did].value,
value,
)
+
+ del self._dirty_data[did]
+ continue
del self._dirty_data[did]
- continue
- if self.data.get(did, None) != value:
- # Do not call external listener when map list and recovery map list properties changed
- if (
- did != DreameVacuumProperty.MAP_LIST.value
- and did != DreameVacuumProperty.RECOVERY_MAP_LIST.value
+ current_value = self.data.get(did)
+ if current_value != value:
+ # Do not call external listener when map and json properties changed
+ if not (
+ did == DreameVacuumProperty.MAP_LIST.value
+ or did == DreameVacuumProperty.RECOVERY_MAP_LIST.value
+ or did == DreameVacuumProperty.MAP_DATA.value
+ or did == DreameVacuumProperty.OBJECT_NAME.value
+ or did == DreameVacuumProperty.AUTO_SWITCH_SETTINGS.value
+ or did == DreameVacuumProperty.AI_DETECTION.value
+ # or did == DreameVacuumProperty.SELF_TEST_STATUS.value
):
changed = True
- current_value = self.data.get(did)
- if current_value is not None:
- _LOGGER.info(
- "Property %s Changed: %s -> %s", DreameVacuumProperty(did).name, current_value, value
- )
- else:
- _LOGGER.info("Property %s Added: %s", DreameVacuumProperty(did).name, value)
+ custom_property = (
+ did == DreameVacuumProperty.AUTO_SWITCH_SETTINGS.value
+ or did == DreameVacuumProperty.AI_DETECTION.value
+ or did == DreameVacuumProperty.MAP_LIST.value
+ or did == DreameVacuumProperty.RECOVERY_MAP_LIST.value
+ or did == DreameVacuumProperty.SERIAL_NUMBER.value
+ )
+ if not custom_property:
+ if current_value is not None:
+ _LOGGER.info(
+ "Property %s Changed: %s -> %s",
+ DreameVacuumProperty(did).name,
+ current_value,
+ value,
+ )
+ else:
+ _LOGGER.info(
+ "Property %s Added: %s",
+ DreameVacuumProperty(did).name,
+ value,
+ )
self.data[did] = value
if did in self._property_update_callback:
for callback in self._property_update_callback[did]:
- callbacks.append([callback, current_value])
+ if not self._ready and custom_property:
+ callback(current_value)
+ else:
+ callbacks.append([callback, current_value])
+ else:
+ _LOGGER.debug("Property %s Not Available", DreameVacuumProperty(did).name)
if not self._ready:
- self.status.update_static_properties()
+ self.capability.load(json.loads(zlib.decompress(base64.b64decode(DEVICE_INFO), zlib.MAX_WBITS | 32)))
for callback in callbacks:
callback[0](callback[1])
@@ -301,8 +632,178 @@ def _request_properties(self, properties: list[DreameVacuumProperty] = None) ->
self._last_change = time.time()
if self._ready:
self._property_changed()
+
+ if not self._ready:
+ if self._protocol.dreame_cloud:
+ self._discard_timeout = 5
+
+ self._calculate_self_clean_area_limits()
+
+ if not self.status.previous_self_clean_area:
+ self.status.previous_self_clean_area = (
+ self.status.self_clean_value
+ if self.status.self_clean_value
+ else self.status.self_clean_area_default
+ )
+
+ if not self.status.previous_self_clean_time:
+ self.status.previous_self_clean_time = (
+ self.status.self_clean_value
+ if self.status.self_clean_value and self.status.self_clean_by_time
+ else self.status.self_clean_time_default
+ )
+
+ if self.capability.mop_clean_frequency:
+ if MOP_WASH_LEVEL_WATER_SAVING in self.status.mop_wash_level_list:
+ self.status.mop_wash_level_list.pop(MOP_WASH_LEVEL_WATER_SAVING)
+
+ if self.capability.mop_pad_swing:
+ if MOP_CLEAN_FREQUENCY_EIGHT_SQUARE_METERS in self.status.mop_clean_frequency_list:
+ self.status.mop_clean_frequency_list.pop(MOP_CLEAN_FREQUENCY_EIGHT_SQUARE_METERS)
+ if MOP_CLEAN_FREQUENCY_FIVE_SQUARE_METERS in self.status.mop_clean_frequency_list:
+ self.status.mop_clean_frequency_list.pop(MOP_CLEAN_FREQUENCY_FIVE_SQUARE_METERS)
+ else:
+ if MOP_CLEAN_FREQUENCY_BY_ROOM in self.status.mop_clean_frequency_list:
+ self.status.mop_clean_frequency_list.pop(MOP_CLEAN_FREQUENCY_BY_ROOM)
+ if MOP_CLEAN_FREQUENCY_FIFTEEN_SQUARE_METERS in self.status.mop_clean_frequency_list:
+ self.status.mop_clean_frequency_list.pop(MOP_CLEAN_FREQUENCY_FIFTEEN_SQUARE_METERS)
+ if MOP_CLEAN_FREQUENCY_TWENTY_SQUARE_METERS in self.status.mop_clean_frequency_list:
+ self.status.mop_clean_frequency_list.pop(MOP_CLEAN_FREQUENCY_TWENTY_SQUARE_METERS)
+ if MOP_CLEAN_FREQUENCY_TWENTYFIVE_SQUARE_METERS in self.status.mop_clean_frequency_list:
+ self.status.mop_clean_frequency_list.pop(MOP_CLEAN_FREQUENCY_TWENTYFIVE_SQUARE_METERS)
+
+ if (
+ self.capability.smart_mop_washing
+ and not self.capability.ultra_clean_mode
+ and WASHING_MODE_ULTRA_WASHING in self.status.washing_mode_list
+ ):
+ self.status.washing_mode_list.pop(WASHING_MODE_ULTRA_WASHING)
+
+ if (
+ not self.capability.mopping_after_sweeping
+ and CLEANING_MODE_MOPPING_AFTER_SWEEPING in self.status.cleaning_mode_list
+ ):
+ self.status.cleaning_mode_list.pop(CLEANING_MODE_MOPPING_AFTER_SWEEPING)
+
+ if (
+ not self.capability.mop_pad_lifting_plus
+ or self.capability.auto_carpet_cleaning
+ or self.capability.carpet_crossing
+ ) and CARPET_CLEANING_ADAPTATION_WITHOUT_ROUTE in self.status.carpet_cleaning_list:
+ self.status.carpet_cleaning_list.pop(CARPET_CLEANING_ADAPTATION_WITHOUT_ROUTE)
+
+ if (
+ not self.capability.auto_carpet_cleaning or self.capability.carpet_crossing
+ ) and CARPET_CLEANING_VACUUM_AND_MOP in self.status.carpet_cleaning_list:
+ self.status.carpet_cleaning_list.pop(CARPET_CLEANING_VACUUM_AND_MOP)
+
+ if (
+ not self.capability.mop_pad_unmounting
+ ) and CARPET_CLEANING_REMOVE_MOP in self.status.carpet_cleaning_list:
+ self.status.carpet_cleaning_list.pop(CARPET_CLEANING_REMOVE_MOP)
+
+ if (
+ not self.capability.mop_pad_lifting_plus and not self.capability.auto_carpet_cleaning
+ ) and CARPET_CLEANING_IGNORE in self.status.carpet_cleaning_list:
+ self.status.carpet_cleaning_list.pop(CARPET_CLEANING_IGNORE)
+
+ if not self.capability.carpet_crossing and CARPET_CLEANING_CROSS in self.status.carpet_cleaning_list:
+ self.status.carpet_cleaning_list.pop(CARPET_CLEANING_CROSS)
+
+ if (
+ not (self.capability.carpet_material and self.capability.carpet_type)
+ and FLOOR_MATERIAL_CARPET in self.status.floor_material_list
+ ):
+ self.status.floor_material_list.pop(FLOOR_MATERIAL_MEDIUM_PILE_CARPET)
+ self.status.floor_material_list.pop(FLOOR_MATERIAL_LOW_PILE_CARPET)
+ self.status.floor_material_list.pop(FLOOR_MATERIAL_CARPET)
+
+ if not self.capability.hot_water_washing and WATER_TEMPERATURE_MAX in self.status.water_temperature_list:
+ self.status.water_temperature_list.pop(WATER_TEMPERATURE_MAX)
+
+ if (
+ not self.capability.intelligent_self_clean_frequency
+ and SELF_CLEAN_FREQUENCY_INTELLIGENT in self.status.self_clean_frequency_list
+ ):
+ self.status.self_clean_frequency_list.pop(SELF_CLEAN_FREQUENCY_INTELLIGENT)
+
+ self.status.segment_cleaning_mode_list = self.status.cleaning_mode_list.copy()
+ if CLEANING_MODE_MOPPING_AFTER_SWEEPING in self.status.segment_cleaning_mode_list:
+ self.status.segment_cleaning_mode_list.pop(CLEANING_MODE_MOPPING_AFTER_SWEEPING)
+
+ if self.capability.cleaning_route:
+ if not self.capability.cleaning_route_v2:
+ if (
+ self.status.cleaning_mode == DreameVacuumCleaningMode.SWEEPING
+ or self.status.cleaning_mode == DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
+ ):
+ new_list = CLEANING_ROUTE_TO_NAME.copy()
+ new_list.pop(DreameVacuumCleaningRoute.DEEP)
+ new_list.pop(DreameVacuumCleaningRoute.INTENSIVE)
+ self.status.cleaning_route_list = {v: k for k, v in new_list.items()}
+
+ new_list = CLEANING_ROUTE_TO_NAME.copy()
+ if self.capability.segment_slow_clean_route:
+ new_list.pop(DreameVacuumCleaningRoute.QUICK)
+ self.status.segment_cleaning_route_list = {v: k for k, v in new_list.items()}
+
+ if not self.capability.mop_clean_frequency:
+ if (
+ self.capability.custom_drying_time
+ and self.capability.drying_time_list
+ and "," in self.capability.drying_time_list
+ ):
+ self.status.drying_time_list = {
+ f"{i}h": int(i) for i in self.capability.drying_time_list.split(",")
+ }
+ else:
+ if self.capability.quick_dry:
+ self.status.drying_time_list = {f"{i}h": i for i in range(1, 4)}
+ elif self.capability.drying_time_v2:
+ self.status.drying_time_list = {f"{i}h": i for i in range(3, 6)}
+
+ if self.capability.intelligent_auto_empty:
+ self.status.auto_empty_mode_list = {v: k for k, v in AUTO_EMPTY_MODE_V2_TO_NAME.items()}
+ if self.capability.auto_empty_area:
+ self.status.auto_empty_mode_list.pop(AUTO_EMPTY_MODE_HIGH_FREQUENCY)
+ else:
+ self.status.auto_empty_mode_list.pop(AUTO_EMPTY_MODE_CUSTOM_FREQUENCY)
+ else:
+ self.status.auto_empty_mode_list = {v: k for k, v in AUTO_EMPTY_MODE_TO_NAME.items()}
+
+ for p in dir(self.capability):
+ if not p.startswith("__") and not callable(getattr(self.capability, p)):
+ val = getattr(self.capability, p)
+ if isinstance(val, bool) and val:
+ _LOGGER.info("Capability %s", p.upper())
+
+ self.reload_shortcuts(True)
+
return changed
+ def _request_properties(self, properties: list[DreameVacuumProperty] = None) -> bool:
+ """Request properties from the device."""
+ if not properties:
+ properties = self._default_properties
+
+ property_list = []
+ for prop in properties:
+ if prop in self.property_mapping:
+ mapping = self.property_mapping[prop]
+ # Do not include properties that are not exists on the device
+ if "aiid" not in mapping and (not self._ready or prop.value in self.data):
+ property_list.append({"did": str(prop.value), **mapping})
+
+ props = property_list.copy()
+ results = []
+ while props:
+ result = self._protocol.get_properties(props[:15], timeout=(10 if len(property_list) > 15 else None))
+ if result is not None:
+ results.extend(result)
+ props[:] = props[15:]
+
+ return self._handle_properties(results)
+
def _update_status(self, task_status: DreameVacuumTaskStatus, status: DreameVacuumStatus) -> None:
"""Update status properties on memory for map renderer to update the image before action is sent to the device."""
if task_status is not DreameVacuumTaskStatus.COMPLETED:
@@ -313,33 +814,43 @@ def _update_status(self, task_status: DreameVacuumTaskStatus, status: DreameVacu
new_state = DreameVacuumState.SWEEPING_AND_MOPPING
self._update_property(DreameVacuumProperty.STATE, new_state.value)
- if status is DreameVacuumStatus.STANDBY:
- self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.IDLE.value)
-
self._update_property(DreameVacuumProperty.STATUS, status.value)
self._update_property(DreameVacuumProperty.TASK_STATUS, task_status.value)
- def _update_property(self, prop: DreameVacuumProperty, value: Any) -> Any:
+ def _update_property(self, prop: DreameVacuumProperty, value: Any, delay=True) -> Any:
"""Update device property on memory and notify listeners."""
if prop in self.property_mapping:
+ if (
+ not self.capability.new_state
+ and prop == DreameVacuumProperty.STATE
+ and int(value) > 18
+ and value in DreameVacuumState._value2member_map_
+ ):
+ old_state = DreameVacuumStateOld[DreameVacuumState(value).name]
+ if old_state:
+ value = int(old_state)
+
current_value = self.get_property(prop)
if current_value != value:
- self._dirty_data[prop.value] = value
did = prop.value
self.data[did] = value
-
if did in self._property_update_callback:
for callback in self._property_update_callback[did]:
callback(current_value)
- self._property_changed()
-
+ if (
+ prop != DreameVacuumProperty.CUSTOMIZED_CLEANING
+ and prop != DreameVacuumProperty.STATE
+ and prop != DreameVacuumProperty.AUTO_EMPTY_STATUS
+ and prop != DreameVacuumProperty.KEEP_ALIVE
+ ):
+ self._property_changed(delay)
return current_value if current_value is not None else value
return None
def _map_property_changed(self, previous_property: Any = None) -> None:
"""Update last update time of the map when a property associated with rendering map changed."""
- if self._map_manager:
+ if self._map_manager and previous_property is not None:
self._map_manager.editor.refresh_map()
def _map_list_changed(self, previous_map_list: Any = None) -> None:
@@ -350,8 +861,11 @@ def _map_list_changed(self, previous_map_list: Any = None) -> None:
try:
map_list = json.loads(map_list)
object_name = map_list.get("object_name")
+ if object_name is None:
+ object_name = map_list.get("obj_name")
if object_name and object_name != "":
- self._map_manager.set_map_list_object_name(map_list)
+ _LOGGER.info("Property MAP_LIST Changed: %s", object_name)
+ self._map_manager.set_map_list_object_name(object_name, map_list.get("md5"))
else:
self._last_map_list_request = 0
except:
@@ -365,55 +879,226 @@ def _recovery_map_list_changed(self, previous_recovery_map_list: Any = None) ->
try:
map_list = json.loads(map_list)
object_name = map_list.get("object_name")
- if object_name and object_name != "":
- self._map_manager.set_recovery_map_list_object_name(map_list)
- else:
- self._last_map_list_request = 0
+ if object_name is None:
+ object_name = map_list.get("obj_name")
except:
- pass
+ object_name = map_list
+
+ if object_name and object_name != "":
+ _LOGGER.info("Property RECOVERY_MAP_LIST Changed: %s", object_name)
+ self._map_manager.set_recovery_map_list_object_name(object_name)
+ else:
+ self._last_map_list_request = 0
+
+ def _map_recovery_status_changed(self, previous_map_recovery_status: Any = None) -> None:
+ if previous_map_recovery_status and self.status.map_recovery_status:
+ if self.status.map_recovery_status == DreameVacuumMapRecoveryStatus.SUCCESS.value:
+ if not self._protocol.dreame_cloud:
+ self._last_map_list_request = 0
+ self._last_map_change_time = time.time()
+ self._map_manager.request_next_map()
+ self._map_manager.request_next_recovery_map_list()
+
+ if self.status.map_recovery_status != DreameVacuumMapRecoveryStatus.RUNNING.value:
+ self._request_properties([DreameVacuumProperty.MAP_RECOVERY_STATUS])
+
+ def _map_backup_status_changed(self, previous_map_backup_status: Any = None) -> None:
+ if previous_map_backup_status and self.status.map_backup_status:
+ if self.status.map_backup_status == DreameVacuumMapBackupStatus.SUCCESS.value:
+ if not self._protocol.dreame_cloud:
+ self._last_map_list_request = 0
+ self._last_map_change_time = time.time()
+ self._map_manager.request_next_recovery_map_list()
+ if self.status.map_backup_status != DreameVacuumMapBackupStatus.RUNNING.value:
+ self._request_properties([DreameVacuumProperty.MAP_BACKUP_STATUS])
+
+ def _drying_progress_changed(self, previous_drying_progress: Any = None) -> None:
+ self.status._drying_time = self.get_property(DreameVacuumProperty.DRYING_TIME)
+
+ def _keep_alive_changed(self, previous_keep_alive: Any = None) -> None:
+ ## Latest generation vacuum app plugin uses this property to inform the device about app is visibile or not
+ ## so that the device does not send unnecessary data to cloud but obviously we don't want that in Home Assistant
+
+ if self.get_property(DreameVacuumProperty.KEEP_ALIVE) == 0:
+ try:
+ ## App always sends 1 but the device returns total client count
+ self.set_property(DreameVacuumProperty.KEEP_ALIVE, 1)
+ except:
+ pass
+
+ ## Keep alive property needs to be requested periodically otherwise it will reset
+ if self._keep_alive_timer:
+ self._keep_alive_timer.cancel()
+ self._keep_alive_timer = Timer(25, self._keep_alive_task)
+ self._keep_alive_timer.start()
+
+ def _cleaning_mode_changed(self, previous_cleaning_mode: Any = None) -> None:
+ value = self.get_property(DreameVacuumProperty.CLEANING_MODE)
+ new_cleaning_mode = None
+ if self.capability.self_wash_base or self.capability.wetness or self.capability.custom_mopping_route:
+ values = DreameVacuumDevice.split_group_value(value, self.capability.mop_pad_lifting)
+ if values and len(values) == 3:
+ if (
+ self.status.self_clean_value != values[1]
+ and values[1] > 0
+ and (self.status.wetness_level is None or self.status.wetness_level < 27)
+ ):
+ if self.status.self_clean_by_time:
+ self.status.previous_self_clean_time = values[1]
+ else:
+ self.status.previous_self_clean_area = values[1]
+ self.status.self_clean_value = values[1]
+ if not self.capability.wetness or values[2] != 0:
+ if values[2] <= 0:
+ if self.capability.custom_mopping_route:
+ if not self.status.custom_mopping_mode:
+ values[2] = self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOPPING_MODE)
+ elif self.status.water_volume:
+ values[2] = self.status.water_volume.value
+
+ if (
+ values[2] > 0
+ and values[2] is not None
+ and values[2] in DreameVacuumMopPadHumidity._value2member_map_
+ ):
+ self.status.mop_pad_humidity = values[2]
+ if values[0] == 3:
+ new_cleaning_mode = DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
+ elif not self.capability.mop_pad_lifting:
+ if not self.status.water_tank_or_mop_installed:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING
+ elif values[0] == 1:
+ new_cleaning_mode = DreameVacuumCleaningMode.MOPPING
+ else:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
+ else:
+ if values[0] == 2:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING
+ elif values[0] == 0:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
+ elif values[0] in DreameVacuumCleaningMode._value2member_map_:
+ new_cleaning_mode = DreameVacuumCleaningMode(values[0])
+ elif self.capability.mop_pad_lifting:
+ if value == 3:
+ new_cleaning_mode = DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
+ elif value == 2:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING
+ elif value == 0:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
+
+ if new_cleaning_mode is None:
+ if value in DreameVacuumCleaningMode._value2member_map_:
+ new_cleaning_mode = DreameVacuumCleaningMode(value)
+ else:
+ new_cleaning_mode = DreameVacuumCleaningMode.UNKNOWN
+
+ if previous_cleaning_mode is not None:
+ if self.status.go_to_zone:
+ self.status.go_to_zone.cleaning_mode = None
+ self.status.go_to_zone.water_level = None
+
+ self._calculate_self_clean_area_limits()
+
+ if self.status.cleaning_mode != new_cleaning_mode:
+ current_cleaning_mode = self.status.cleaning_mode
+ self.status.cleaning_mode = new_cleaning_mode
+
+ if self._ready and self.capability.cleaning_route and not self.capability.cleaning_route_v2:
+ new_list = CLEANING_ROUTE_TO_NAME.copy()
+ if (
+ self.status.cleaning_mode == DreameVacuumCleaningMode.SWEEPING
+ or self.status.cleaning_mode == DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
+ ):
+ new_list.pop(DreameVacuumCleaningRoute.DEEP)
+ new_list.pop(DreameVacuumCleaningRoute.INTENSIVE)
+ self.status.cleaning_route_list = {v: k for k, v in new_list.items()}
+
+ if self.status.cleaning_route and self.status.cleaning_route not in self.status.cleaning_route_list:
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.CLEANING_ROUTE,
+ DreameVacuumCleaningRoute.STANDARD.value,
+ )
+
+ if self.capability.auto_change_mop and (
+ new_cleaning_mode is DreameVacuumCleaningMode.SWEEPING
+ or current_cleaning_mode is DreameVacuumCleaningMode.SWEEPING
+ ):
+ self._map_property_changed(0)
def _water_tank_changed(self, previous_water_tank: Any = None) -> None:
"""Update cleaning mode on device when water tank status is changed."""
# App does not allow you to update cleaning mode when water tank or mop pad is not installed.
if self.get_property(DreameVacuumProperty.CLEANING_MODE) is not None:
new_list = CLEANING_MODE_CODE_TO_NAME.copy()
- if not self.status.auto_mount:
- if not self.status.water_tank_or_mop_installed:
- new_list.pop(DreameVacuumCleaningMode.MOPPING)
- new_list.pop(DreameVacuumCleaningMode.SWEEPING_AND_MOPPING)
- if self.status.cleaning_mode != DreameVacuumCleaningMode.SWEEPING:
- # Store current cleaning mode for future use when water tank is reinstalled
- if not self.status.started:
+ if not self.capability.mopping_after_sweeping or (
+ self.status.started
+ and self.status.cleaning_mode is not DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
+ ):
+ new_list.pop(DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING)
+
+ if not self.capability.embedded_tank and (
+ not self.status.auto_mount_mop or not self.status.mop_in_station
+ ):
+ try:
+ if not self.status.water_tank_or_mop_installed:
+ new_list.pop(DreameVacuumCleaningMode.MOPPING)
+ new_list.pop(DreameVacuumCleaningMode.SWEEPING_AND_MOPPING)
+ if DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING in new_list:
+ new_list.pop(DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING)
+ if self.status.cleaning_mode is not DreameVacuumCleaningMode.SWEEPING:
+ # Store current cleaning mode for future use when water tank is reinstalled
self._previous_cleaning_mode = self.status.cleaning_mode
- self.set_cleaning_mode(DreameVacuumCleaningMode.SWEEPING.value)
- else:
- if not self.status.mop_pad_lifting_available:
+ if (
+ self._ready
+ and not self.status.scheduled_clean
+ and not self.status.shortcut_task
+ and not self.status.cleangenius_cleaning
+ ):
+ try:
+ self._update_cleaning_mode(DreameVacuumCleaningMode.SWEEPING.value)
+ except:
+ pass
+ elif not self.capability.mop_pad_lifting:
new_list.pop(DreameVacuumCleaningMode.SWEEPING)
-
- if not self.status.started and self.status.sweeping:
+ if DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING in new_list:
+ new_list.pop(DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING)
+ if self.status.sweeping:
if (
- self._previous_cleaning_mode is not None
- and self._previous_cleaning_mode != DreameVacuumCleaningMode.SWEEPING
+ self._ready
+ and not self.status.scheduled_clean
+ and not self.status.shortcut_task
+ and not self.status.cleangenius_cleaning
):
- self.set_cleaning_mode(self._previous_cleaning_mode.value)
- else:
- self.set_cleaning_mode(DreameVacuumCleaningMode.SWEEPING_AND_MOPPING.value)
+ if (
+ self._previous_cleaning_mode is not None
+ and self._previous_cleaning_mode is not DreameVacuumCleaningMode.SWEEPING
+ ):
+ self._update_cleaning_mode(self._previous_cleaning_mode.value)
+ else:
+ self._update_cleaning_mode(DreameVacuumCleaningMode.SWEEPING_AND_MOPPING.value)
# Store current cleaning mode for future use when water tank is removed
self._previous_cleaning_mode = self.status.cleaning_mode
+ except:
+ pass
self.status.cleaning_mode_list = {v: k for k, v in new_list.items()}
+ def _auto_mount_mop_changed(self, previous_auto_mount_mop: Any = None) -> None:
+ if previous_auto_mount_mop is not None:
+ carpet_cleaning_list = CARPET_CLEANING_CODE_TO_NAME.copy()
+ if not self.status.auto_mount_mop:
+ carpet_cleaning_list.pop(DreameVacuumCarpetCleaning.REMOVE_MOP)
+ self.status.carpet_cleaning_list = {v: k for k, v in carpet_cleaning_list.items()}
+
def _task_status_changed(self, previous_task_status: Any = None) -> None:
"""Task status is a very important property and must be listened to trigger necessary actions when a task started or ended"""
if previous_task_status is not None:
if previous_task_status in DreameVacuumTaskStatus._value2member_map_:
previous_task_status = DreameVacuumTaskStatus(previous_task_status)
- task_status = self.status.task_status
- if previous_task_status is DreameVacuumTaskStatus.COMPLETED:
- # as implemented on the app
- self._update_property(DreameVacuumProperty.CLEANING_TIME, 0)
- self._update_property(DreameVacuumProperty.CLEANED_AREA, 0)
+ task_status = self.get_property(DreameVacuumProperty.TASK_STATUS)
+ if task_status in DreameVacuumTaskStatus._value2member_map_:
+ task_status = DreameVacuumTaskStatus(task_status)
if self._map_manager is not None:
# Update map data for renderer to update the map image according to the new task status
@@ -423,6 +1108,8 @@ def _task_status_changed(self, previous_task_status: Any = None) -> None:
or task_status is DreameVacuumTaskStatus.ZONE_CLEANING
or task_status is DreameVacuumTaskStatus.SEGMENT_CLEANING
or task_status is DreameVacuumTaskStatus.SPOT_CLEANING
+ or task_status is DreameVacuumTaskStatus.CRUISING_PATH
+ or task_status is DreameVacuumTaskStatus.CRUISING_POINT
):
# Clear path on current map on cleaning start as implemented on the app
self._map_manager.editor.clear_path()
@@ -435,18 +1122,75 @@ def _task_status_changed(self, previous_task_status: Any = None) -> None:
self._map_manager.editor.refresh_map()
if task_status is DreameVacuumTaskStatus.COMPLETED:
- if previous_task_status is DreameVacuumTaskStatus.FAST_MAPPING:
+ if (
+ previous_task_status is DreameVacuumTaskStatus.CRUISING_PATH
+ or previous_task_status is DreameVacuumTaskStatus.CRUISING_POINT
+ or self.status.go_to_zone
+ ):
+ if self._map_manager is not None:
+ # Get the new map list from cloud
+ self._map_manager.editor.set_cruise_points([])
+ self._map_manager.request_next_map_list()
+ self._cleaning_history_update = time.time()
+ elif previous_task_status is DreameVacuumTaskStatus.FAST_MAPPING:
# as implemented on the app
self._update_property(DreameVacuumProperty.CLEANING_TIME, 0)
- self.cleanup_completed = False
if self._map_manager is not None:
# Mapping is completed, get the new map list from cloud
self._map_manager.request_next_map_list()
- elif self.cleanup_completed is not None:
- self.cleanup_completed = True
+ elif (
+ self.status.cleanup_started
+ and not self.status.cleanup_completed
+ and (self.status.status is DreameVacuumStatus.BACK_HOME or not self.status.running)
+ ):
+ self.status.cleanup_started = False
+ self.status.cleanup_completed = True
self._cleaning_history_update = time.time()
+
+ if self._previous_cleangenius is not None:
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.CLEANGENIUS, self._previous_cleangenius, False
+ )
+ self._previous_cleangenius = None
else:
- self.cleanup_completed = None if self.status.fast_mapping else False
+ self.status.cleanup_started = not (
+ self.status.fast_mapping
+ or self.status.cruising
+ or (
+ task_status is DreameVacuumTaskStatus.DOCKING_PAUSED
+ and previous_task_status is DreameVacuumTaskStatus.COMPLETED
+ )
+ )
+ self.status.cleanup_completed = False
+ if self.status.cleanup_started:
+ if previous_task_status is DreameVacuumTaskStatus.COMPLETED:
+ # as implemented on the app
+ self._update_property(DreameVacuumProperty.CLEANING_TIME, 0)
+ self._update_property(DreameVacuumProperty.CLEANED_AREA, 0)
+
+ if (
+ task_status is not DreameVacuumTaskStatus.ZONE_CLEANING
+ and self._previous_cleangenius is not None
+ ):
+ self._previous_cleangenius = None
+
+ if self.status.go_to_zone:
+ cruising = bool(
+ task_status is DreameVacuumTaskStatus.ZONE_CLEANING
+ or task_status is DreameVacuumTaskStatus.ZONE_CLEANING_PAUSED
+ or task_status is DreameVacuumTaskStatus.ZONE_MOPPING_PAUSED
+ or task_status is DreameVacuumTaskStatus.ZONE_DOCKING_PAUSED
+ or task_status is DreameVacuumTaskStatus.CRUISING_POINT
+ or task_status is DreameVacuumTaskStatus.CRUISING_POINT_PAUSED
+ )
+
+ if self.status.go_to_zone.start and not cruising:
+ self._restore_go_to_zone()
+ elif not self.status.go_to_zone.start and cruising:
+ self.status.go_to_zone.start = True
+
+ if self._map_manager:
+ self._map_manager.editor.refresh_map()
if (
task_status is DreameVacuumTaskStatus.COMPLETED
@@ -454,33 +1198,42 @@ def _task_status_changed(self, previous_task_status: Any = None) -> None:
):
# Get properties that only changes when task status is changed
properties = [
- DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT,
- DreameVacuumProperty.MAIN_BRUSH_LEFT,
- DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT,
- DreameVacuumProperty.SIDE_BRUSH_LEFT,
- DreameVacuumProperty.FILTER_LEFT,
- DreameVacuumProperty.FILTER_TIME_LEFT,
- DreameVacuumProperty.SENSOR_DIRTY_LEFT,
- DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT,
- DreameVacuumProperty.SECONDARY_FILTER_LEFT,
- DreameVacuumProperty.SECONDARY_FILTER_TIME_LEFT,
- DreameVacuumProperty.MOP_PAD_LEFT,
- DreameVacuumProperty.MOP_PAD_TIME_LEFT,
- DreameVacuumProperty.SILVER_ION_TIME_LEFT,
- DreameVacuumProperty.SILVER_ION_LEFT,
- DreameVacuumProperty.DETERGENT_TIME_LEFT,
- DreameVacuumProperty.DETERGENT_LEFT,
DreameVacuumProperty.TOTAL_CLEANING_TIME,
DreameVacuumProperty.CLEANING_COUNT,
DreameVacuumProperty.TOTAL_CLEANED_AREA,
+ DreameVacuumProperty.TOTAL_RUNTIME,
+ DreameVacuumProperty.TOTAL_CRUISE_TIME,
DreameVacuumProperty.FIRST_CLEANING_DATE,
DreameVacuumProperty.SCHEDULE,
DreameVacuumProperty.SCHEDULE_CANCEL_REASON,
DreameVacuumProperty.CRUISE_SCHEDULE,
]
+ properties.extend(CONSUMABLE_PROPERTIES)
+
+ if not self.capability.disable_sensor_cleaning:
+ properties.extend(
+ [
+ DreameVacuumProperty.SENSOR_DIRTY_LEFT,
+ DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT,
+ ]
+ )
+
+ if not self.capability.disable_mop_consumable:
+ properties.extend(
+ [
+ DreameVacuumProperty.MOP_PAD_LEFT,
+ DreameVacuumProperty.MOP_PAD_TIME_LEFT,
+ ]
+ )
+
if self._map_manager is not None:
- properties.extend([DreameVacuumProperty.MAP_LIST, DreameVacuumProperty.RECOVERY_MAP_LIST])
+ properties.extend(
+ [
+ DreameVacuumProperty.MAP_LIST,
+ DreameVacuumProperty.RECOVERY_MAP_LIST,
+ ]
+ )
self._last_map_list_request = time.time()
try:
@@ -488,113 +1241,469 @@ def _task_status_changed(self, previous_task_status: Any = None) -> None:
except Exception as ex:
pass
+ if self._protocol.prefer_cloud and self._protocol.dreame_cloud:
+ self.schedule_update(1, True)
+
+ if self.capability.mopping_after_sweeping:
+ if self.status.started:
+ if (
+ self.status.cleaning_mode is not DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
+ and CLEANING_MODE_MOPPING_AFTER_SWEEPING in self.status.cleaning_mode_list
+ ):
+ self.status.cleaning_mode_list.pop(CLEANING_MODE_MOPPING_AFTER_SWEEPING)
+ self._property_changed(False)
+ elif CLEANING_MODE_MOPPING_AFTER_SWEEPING not in self.status.cleaning_mode_list and (
+ self.status.water_tank_or_mop_installed
+ ):
+ self.status.cleaning_mode_list[CLEANING_MODE_MOPPING_AFTER_SWEEPING] = (
+ DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
+ )
+ self._property_changed(False)
+
def _status_changed(self, previous_status: Any = None) -> None:
if previous_status is not None:
if previous_status in DreameVacuumStatus._value2member_map_:
previous_status = DreameVacuumStatus(previous_status)
- status = self.status.status
+ status = self.get_property(DreameVacuumProperty.STATUS)
if (
self._remote_control
- and status is not DreameVacuumStatus.REMOTE_CONTROL
- and previous_status is not DreameVacuumStatus.REMOTE_CONTROL
+ and status != DreameVacuumStatus.REMOTE_CONTROL.value
+ and previous_status != DreameVacuumStatus.REMOTE_CONTROL.value
):
self._remote_control = False
- if status is DreameVacuumStatus.CHARGING and previous_status is DreameVacuumStatus.BACK_HOME:
+ if (
+ not self.capability.cruising
+ and status == DreameVacuumStatus.BACK_HOME
+ and previous_status == DreameVacuumStatus.ZONE_CLEANING
+ and self.status.started
+ ):
+ self.status.cleanup_started = False
+ self.status.cleanup_completed = False
+ if self.status.go_to_zone:
+ self.status.go_to_zone.stop = True
+ self._restore_go_to_zone(True)
+ elif (
+ not self.status.started
+ and self.status.cleanup_started
+ and not self.status.cleanup_completed
+ and (self.status.status is DreameVacuumStatus.BACK_HOME or not self.status.running)
+ ):
+ self.status.cleanup_started = False
+ self.status.cleanup_completed = True
self._cleaning_history_update = time.time()
- self._map_property_changed()
+ if self._previous_cleangenius is not None:
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.CLEANGENIUS, self._previous_cleangenius, False
+ )
+ self._previous_cleangenius = None
- def _charging_status_changed(self, previous_charging_status: Any = None) -> None:
- self._remote_control = False
- self._map_property_changed()
+ did = DreameVacuumProperty.TASK_STATUS.value
+ if did in self._property_update_callback:
+ for callback in self._property_update_callback[did]:
+ callback(self.status.task_status.value)
+ self._property_changed(False)
+ elif status == DreameVacuumStatus.CHARGING.value and previous_status == DreameVacuumStatus.BACK_HOME.value:
+ self._cleaning_history_update = time.time()
- def _ai_obstacle_detection_changed(self, previous_ai_obstacle_detection: Any = None) -> None:
- """AI Detection property returns multiple values as json or int this function parses and sets the sub properties to memory"""
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, str):
- settings = json.loads(value)
-
- if AI_SETTING_SWITCH in settings:
- self.status.ai_obstacle_detection = settings[AI_SETTING_SWITCH]
- if AI_SETTING_UPLOAD in settings:
- self.status.obstacle_image_upload = settings[AI_SETTING_UPLOAD]
- if AI_SETTING_PET in settings:
- self.status.pet_detection = settings[AI_SETTING_PET]
- if AI_SETTING_HUMAN in settings:
- self.status.human_detection = settings[AI_SETTING_HUMAN]
- if AI_SETTING_FURNITURE in settings:
- self.status.furniture_detection = settings[AI_SETTING_FURNITURE]
- if AI_SETTING_FLUID in settings:
- self.status.fluid_detection = settings[AI_SETTING_FLUID]
- elif isinstance(value, int):
- self.status.furniture_detection = (value & 1) == 1
- self.status.ai_obstacle_detection = (value & 2) == 2
- self.status.obstacle_picture = (value & 4) == 4
- self.status.fluid_detection = (value & 8) == 8
- self.status.pet_detection = (value & 16) == 16
- self.status.obstacle_image_upload = (value & 32) == 32
- self.status.ai_picture = (value & 64) == 64
+ if previous_status == DreameVacuumStatus.OTA.value:
+ self._ready = False
+ self.connect_device()
- self.status.ai_policy_accepted = bool(
- self.status.ai_policy_accepted or self.status.ai_obstacle_detection or self.status.obstacle_picture
- )
+ if self._map_manager:
+ self._map_manager.editor.refresh_map()
- def _auto_switch_settings_changed(self, previous_auto_switch_settings: Any = None) -> None:
- value = self.get_property(DreameVacuumProperty.AUTO_SWITCH_SETTINGS)
- if isinstance(value, str) and len(value) > 2:
+ def _faults_changed(self, previous_faults: Any = None) -> None:
+ self.status.faults = []
+ faults = self.get_property(DreameVacuumProperty.FAULTS)
+ if faults and faults != "" and faults != " " and faults != 0 and faults != "0":
try:
- settings = json.loads(value)
- self.status.collision_avoidance = 0
- self.status.fill_light = 0
- self.status.auto_drying = 0
- self.status.stain_avoidance = 0
- self.status.mopping_type = 0
-
- if len(settings):
- for setting in settings:
- key = setting["k"]
- value = setting["v"]
-
- if key == "LessColl":
- self.status.collision_avoidance = value
- elif key == "FillinLight":
- self.status.fill_light = value
- elif key == "AutoDry":
- self.status.auto_drying = value
- elif key == "StainIdentify":
- self.status.stain_avoidance = value
- elif key == "CleanType":
- self.status.mopping_type = value
+ faults = str(faults).split(",")
+ self.status.faults = [
+ int(fault) for fault in faults if int(fault) in DreameVacuumErrorCode._value2member_map_
+ ]
except:
pass
- def _intelligent_recognition_changed(self, previous_intelligent_recognition: Any = None) -> None:
- if not self.status.auto_switch_settings_available:
- self.status.auto_drying = self.get_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION)
+ def _charging_status_changed(self, previous_charging_status: Any = None) -> None:
+ self._remote_control = False
+ if previous_charging_status is not None:
+ if self._map_manager:
+ self._map_manager.editor.refresh_map()
- def _request_cleaning_history(self) -> None:
- """Get and parse the cleaning history from cloud event data and set it to memory"""
- if (
- self.cloud_connected
- and self._cleaning_history_update != 0
- and (
- self._cleaning_history_update == -1
- or self.status._cleaning_history is None
- or (
- time.time() - self._cleaning_history_update >= 5
- and self.status.task_status is DreameVacuumTaskStatus.COMPLETED
- )
- )
- ):
- self._cleaning_history_update = 0
+ if self._ready and self.capability.mop_pad_lifting:
+ self._water_tank_changed()
- _LOGGER.debug("Get Cleaning History")
- try:
- # Limit the results
- start = None
- total = self.get_property(DreameVacuumProperty.CLEANING_COUNT)
+ if (
+ self._protocol.dreame_cloud
+ and self.status.charging_status != DreameVacuumChargingStatus.CHARGING_COMPLETED
+ ):
+ self.schedule_update(2, True)
+
+ def _ai_obstacle_detection_changed(self, previous_ai_obstacle_detection: Any = None) -> None:
+ """AI Detection property returns multiple values as json or int this function parses and sets the sub properties to memory"""
+ ai_value = self.get_property(DreameVacuumProperty.AI_DETECTION)
+ changed = False
+ if isinstance(ai_value, str):
+ settings = json.loads(ai_value)
+ if settings and self.ai_data is None:
+ self.ai_data = {}
+
+ for prop in DreameVacuumStrAIProperty:
+ if prop.value in settings:
+ value = settings[prop.value]
+ if prop.value in self._dirty_ai_data:
+ if (
+ self._dirty_ai_data[prop.name].value != value
+ and time.time() - self._dirty_ai_data[prop.name].update_time < self._discard_timeout
+ ):
+ _LOGGER.info(
+ "AI Property %s Value Discarded: %s <- %s",
+ prop.name,
+ self._dirty_ai_data[prop.name].value,
+ value,
+ )
+ del self._dirty_ai_data[prop.name]
+ continue
+ del self._dirty_ai_data[prop.name]
+
+ current_value = self.ai_data.get(prop.name)
+ if current_value != value:
+ if current_value is not None:
+ _LOGGER.info(
+ "AI Property %s Changed: %s -> %s",
+ prop.name,
+ current_value,
+ value,
+ )
+ if (
+ prop == DreameVacuumStrAIProperty.AI_PET_DETECTION
+ or prop == DreameVacuumStrAIProperty.AI_FLUID_DETECTION
+ ):
+ self._map_property_changed(current_value)
+ else:
+ _LOGGER.info("AI Property %s Added: %s", prop.name, value)
+ changed = True
+ self.ai_data[prop.name] = value
+ elif isinstance(ai_value, int):
+ if self.ai_data is None:
+ self.ai_data = {}
+
+ for prop in DreameVacuumAIProperty:
+ bit = int(prop.value)
+ value = (ai_value & bit) == bit
+ if prop.name in self._dirty_ai_data:
+ if (
+ self._dirty_ai_data[prop.name].value != value
+ and time.time() - self._dirty_ai_data[prop.name].update_time < self._discard_timeout
+ ):
+ _LOGGER.info(
+ "AI Property %s Value Discarded: %s <- %s",
+ prop.name,
+ self._dirty_ai_data[prop.name].value,
+ value,
+ )
+ del self._dirty_ai_data[prop.name]
+ continue
+ del self._dirty_ai_data[prop.name]
+
+ current_value = self.ai_data.get(prop.name)
+ if current_value != value:
+ if current_value is not None:
+ _LOGGER.info(
+ "AI Property %s Changed: %s -> %s",
+ prop.name,
+ current_value,
+ value,
+ )
+ if (
+ prop == DreameVacuumAIProperty.AI_PET_DETECTION
+ or prop == DreameVacuumAIProperty.AI_FLUID_DETECTION
+ ):
+ self._map_property_changed(current_value)
+ else:
+ _LOGGER.info("AI Property %s Added: %s", prop.name, value)
+ changed = True
+ self.ai_data[prop.name] = value
+
+ if changed:
+ self._last_change = time.time()
+ if self._ready:
+ self._property_changed()
+
+ self.status.ai_policy_accepted = bool(
+ self.status.ai_policy_accepted or self.status.ai_obstacle_detection or self.status.ai_obstacle_picture
+ )
+
+ def _auto_switch_settings_changed(self, previous_auto_switch_settings: Any = None) -> None:
+ value = self.get_property(DreameVacuumProperty.AUTO_SWITCH_SETTINGS)
+ if isinstance(value, str) and len(value) > 2:
+ mopping_setting_changed = False
+ cleangenius_changed = False
+ try:
+ settings = json.loads(value)
+ settings_dict = {}
+
+ if isinstance(settings, list):
+ for setting in settings:
+ settings_dict[setting["k"]] = setting["v"]
+ elif "k" in settings:
+ settings_dict[settings["k"]] = settings["v"]
+
+ if settings_dict and self.auto_switch_data is None:
+ self.auto_switch_data = {}
+
+ changed = False
+ for prop in DreameVacuumAutoSwitchProperty:
+ if prop.value in settings_dict:
+ value = settings_dict[prop.value]
+
+ if prop.name in self._dirty_auto_switch_data:
+ if (
+ self._dirty_auto_switch_data[prop.name].value != value
+ and time.time() - self._dirty_auto_switch_data[prop.name].update_time
+ < self._discard_timeout
+ ):
+ _LOGGER.info(
+ "Property %s Value Discarded: %s <- %s",
+ prop.name,
+ self._dirty_auto_switch_data[prop.name].value,
+ value,
+ )
+ del self._dirty_auto_switch_data[prop.name]
+ continue
+ del self._dirty_auto_switch_data[prop.name]
+
+ current_value = self.auto_switch_data.get(prop.name)
+ if current_value != value:
+ if (
+ prop == DreameVacuumAutoSwitchProperty.MOPPING_MODE
+ or prop == DreameVacuumAutoSwitchProperty.CUSTOM_MOPPING_MODE
+ ):
+ mopping_setting_changed = True
+ if prop == DreameVacuumAutoSwitchProperty.CLEANGENIUS:
+ cleangenius_changed = True
+ if self._previous_cleangenius is not None:
+ self._previous_cleangenius = value
+
+ if current_value is not None:
+ _LOGGER.info(
+ "Property %s Changed: %s -> %s",
+ prop.name,
+ current_value,
+ value,
+ )
+ else:
+ _LOGGER.info("Property %s Added: %s", prop.name, value)
+ changed = True
+ self.auto_switch_data[prop.name] = value
+
+ if changed:
+ self._last_change = time.time()
+ if self._ready and previous_auto_switch_settings is not None:
+ self._property_changed()
+ except Exception as ex:
+ _LOGGER.error("Failed to parse auto switch settings: %s", ex)
+
+ if previous_auto_switch_settings is not None and mopping_setting_changed:
+ self._calculate_self_clean_area_limits()
+
+ if cleangenius_changed and self._map_manager and self._ready and previous_auto_switch_settings is not None:
+ self._map_manager.editor.refresh_map()
+
+ def _dnd_task_changed(self, previous_dnd_task: Any = None) -> None:
+ dnd_tasks = self.get_property(DreameVacuumProperty.DND_TASK)
+ dnd_list = []
+ if dnd_tasks and dnd_tasks != "":
+ dnd_list = [
+ DNDTask(task.get("id"), task.get("en"), task.get("st"), task.get("et"), task.get("wk"), task.get("ss"))
+ for task in json.loads(dnd_tasks)
+ ]
+ if dnd_list and len(dnd_list) > 1:
+ dnd_list.sort(
+ key=cmp_to_key(
+ lambda a, b: (
+ b.id - a.id
+ if a.start == b.start
+ else int(a.start.replace(":", "")) - int(b.start.replace(":", ""))
+ )
+ )
+ )
+ self.status.dnd_tasks = dnd_list
+
+ def _schedule_changed(self, previous_schedule: Any = None) -> None:
+ schedule = self.get_property(DreameVacuumProperty.SCHEDULE)
+ schedule_list = []
+ if schedule and schedule != "":
+ tasks = schedule.split(";")
+ for task in tasks:
+ props = task.split("-")
+ if len(props) >= 9:
+ schedule_list.append(
+ ScheduledTask(
+ id=int(props[0]),
+ enabled=bool(props[1] == "1" or props[1] == "2"),
+ invalid=bool(props[1] == "3"),
+ time=props[2],
+ repeats=props[3],
+ once=bool(props[4] == "0"),
+ map_id=props[5],
+ suction_level=int(props[6]),
+ water_volume=int(props[7]),
+ options=props[8].split(",") if props[8] != "0" else None,
+ )
+ )
+ if schedule_list and len(schedule_list) > 1:
+ schedule_list.sort(
+ key=cmp_to_key(
+ lambda a, b: (
+ b.id - a.id
+ if a.time == b.time
+ else int(a.time.replace(":", "")) - int(b.time.replace(":", ""))
+ )
+ )
+ )
+ self.status.schedule = schedule_list
+
+ def _stream_status_changed(self, previous_stream_status: Any = None) -> None:
+ stream_status = self.get_property(DreameVacuumProperty.STREAM_STATUS)
+ if stream_status and stream_status != "" and stream_status != "null":
+ stream_status = json.loads(stream_status)
+ if stream_status and stream_status.get("result") == 0:
+ self.status.stream_session = stream_status.get("session")
+ operation_type = stream_status.get("operType")
+ operation = stream_status.get("operation")
+ if operation_type:
+ if operation_type == "end" or operation == "end":
+ self.status.stream_status = DreameVacuumStreamStatus.IDLE
+ elif operation_type == "start" or operation == "start":
+ if operation:
+ if operation == "monitor" or operation_type == "monitor":
+ self.status.stream_status = DreameVacuumStreamStatus.VIDEO
+ elif operation == "intercom" or operation_type == "intercom":
+ self.status.stream_status = DreameVacuumStreamStatus.AUDIO
+ elif operation == "recordVideo" or operation_type == "recordVideo":
+ self.status.stream_status = DreameVacuumStreamStatus.RECORDING
+
+ def _shortcuts_changed(self, previous_shortcuts: Any = None) -> None:
+ if previous_shortcuts is not None:
+ self.reload_shortcuts()
+
+ def _voice_assistant_language_changed(self, previous_voice_assistant_language: Any = None) -> None:
+ value = self.get_property(DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE)
+ language_list = self.status.voice_assistant_language_list
+ if value and len(value):
+ language_list = VOICE_ASSISTANT_LANGUAGE_TO_NAME.copy()
+ language_list.pop(DreameVacuumVoiceAssistantLanguage.DEFAULT)
+ language_list = {v: k for k, v in language_list.items()}
+ elif DreameVacuumVoiceAssistantLanguage.DEFAULT.value not in language_list:
+ language_list = {v: k for k, v in VOICE_ASSISTANT_LANGUAGE_TO_NAME.items()}
+ self.status.voice_assistant_language_list = language_list
+
+ def _drainage_status_changed(self, previous_drainage_status: Any = None) -> None:
+ if self.status.draining_complete:
+ self._draining_complete_time = time.time()
+ else:
+ self._draining_complete_time = None
+
+ def _auto_water_refilling_changed(self, previous_auto_water_refilling: Any = None) -> None:
+ if self.capability.smart_mop_washing and self.capability.ultra_clean_mode:
+ if self.status.auto_water_refilling_enabled:
+ if WASHING_MODE_ULTRA_WASHING not in self.status.washing_mode_list:
+ self.status.washing_mode_list.append(WASHING_MODE_ULTRA_WASHING)
+ else:
+ if WASHING_MODE_ULTRA_WASHING in self.status.washing_mode_list:
+ self.status.washing_mode_list.pop(WASHING_MODE_ULTRA_WASHING)
+
+ def _self_wash_base_status_changed(self, previous_self_wash_base_status: Any = None) -> None:
+ if previous_self_wash_base_status is not None:
+ if (
+ bool(
+ self.status.started
+ and previous_self_wash_base_status == DreameVacuumSelfWashBaseStatus.WASHING.value
+ or previous_self_wash_base_status == DreameVacuumSelfWashBaseStatus.CLEAN_ADD_WATER.value
+ )
+ != self.status.washing
+ ):
+ self._consumable_change = True
+
+ if self._map_manager:
+ self._map_manager.editor.refresh_map()
+
+ def _off_peak_charging_changed(self, previous_off_peak_charging: Any = None) -> None:
+ off_peak_charging = self.get_property(DreameVacuumProperty.OFF_PEAK_CHARGING)
+ if off_peak_charging and off_peak_charging != "":
+ self.status.off_peak_charging_config = json.loads(off_peak_charging)
+
+ def _suction_level_changed(self, previous_suction_level: Any = None) -> None:
+ if previous_suction_level is not None and self.status.go_to_zone:
+ self.status.go_to_zone.suction_level = None
+
+ def _water_volume_changed(self, previous_water_volume: Any = None) -> None:
+ if self.capability.wetness and not self.capability.wetness_level:
+ self.status.mop_pad_humidity = self.status.water_volume.value
+ if previous_water_volume is not None and self.status.go_to_zone:
+ self.status.go_to_zone.water_volume = None
+
+ def _wetness_level_changed(self, previous_wetness_level: Any = None) -> None:
+ wetness_level = self.status.wetness_level
+ if wetness_level:
+ water_level = 2
+ if wetness_level > 32:
+ if wetness_level > 200:
+ water_level = 3
+ elif wetness_level < 200:
+ water_level = 1
+ else:
+ if wetness_level > (14 if self.capability.mop_clean_frequency else 26):
+ water_level = 3
+ elif wetness_level < 6:
+ water_level = 1
+
+ self.status.mop_pad_humidity = water_level
+
+ if previous_wetness_level is not None:
+ self._calculate_self_clean_area_limits()
+
+ def _error_changed(self, previous_error: Any = None) -> None:
+ if previous_error is not None and self.status.go_to_zone and self.status.has_error:
+ self._restore_go_to_zone(True)
+
+ if self._map_manager and previous_error is not None:
+ self._map_manager.editor.refresh_map()
+
+ def _battery_level_changed(self, previous_battery_level: Any = None) -> None:
+ if (
+ self._map_manager
+ and previous_battery_level is not None
+ and self.status.battery_level == self.status.battery_charge_level
+ ):
+ self._map_manager.editor.refresh_map()
+
+ def _request_cleaning_history(self) -> None:
+ """Get and parse the cleaning history from cloud event data and set it to memory"""
+ if (
+ self.cloud_connected
+ and self._cleaning_history_update != 0
+ and (
+ self._cleaning_history_update == -1
+ or self.status._cleaning_history is None
+ or (
+ time.time() - self._cleaning_history_update >= 5
+ and self.status.task_status is DreameVacuumTaskStatus.COMPLETED
+ )
+ )
+ ):
+ self._cleaning_history_update = 0
+
+ _LOGGER.info("Get Cleaning History")
+ try:
+ # Limit the results
+ start = None
+ max = 25
+ total = self.get_property(DreameVacuumProperty.CLEANING_COUNT)
if total > 0:
start = self.get_property(DreameVacuumProperty.FIRST_CLEANING_DATE)
@@ -603,108 +1712,567 @@ def _request_cleaning_history(self) -> None:
if total is None:
total = 5
limit = 40
- if total < 20:
- limit = total + 20
+ if total < max:
+ limit = total + max
+ changed = False
# Cleaning history is generated from events of status property that has been sent to cloud by the device when it changed
result = self._protocol.cloud.get_device_event(
- DIID(DreameVacuumProperty.STATUS, self.property_mapping), limit, start
+ DIID(DreameVacuumProperty.STATUS, self.property_mapping),
+ limit,
+ start,
)
if result:
cleaning_history = []
history_size = 0
for data in result:
- history_data = json.loads(data["value"])
-
- history = CleaningHistory()
-
- for history_data_item in history_data:
- piid = history_data_item["piid"]
- value = history_data_item["value"]
- if piid == PIID(DreameVacuumProperty.STATUS, self.property_mapping):
- if value in DreameVacuumStatus._value2member_map_:
- history.status = DreameVacuumStatus(value)
- else:
- history.status = DreameVacuumStatus.UNKNOWN
- elif piid == PIID(DreameVacuumProperty.CLEANING_TIME, self.property_mapping):
- history.cleaning_time = value
- elif piid == PIID(DreameVacuumProperty.CLEANED_AREA, self.property_mapping):
- history.cleaned_area = value
- elif piid == PIID(DreameVacuumProperty.SUCTION_LEVEL, self.property_mapping):
- if value in DreameVacuumSuctionLevel._value2member_map_:
- history.suction_level = DreameVacuumSuctionLevel(value)
- else:
- history.suction_level = DreameVacuumSuctionLevel.UNKNOWN
- elif piid == PIID(DreameVacuumProperty.CLEANING_START_TIME, self.property_mapping):
- history.date = datetime.fromtimestamp(value)
- elif piid == PIID(DreameVacuumProperty.CLEAN_LOG_FILE_NAME, self.property_mapping):
- history.file_name = value
- elif piid == PIID(DreameVacuumProperty.CLEAN_LOG_STATUS, self.property_mapping):
- history.completed = bool(value)
- elif piid == PIID(DreameVacuumProperty.WATER_TANK, self.property_mapping):
- if value in DreameVacuumWaterTank._value2member_map_:
- history.water_tank = DreameVacuumWaterTank(value)
- else:
- history.water_tank = DreameVacuumWaterTank.UNKNOWN
-
+ history = CleaningHistory(
+ json.loads(data["history"] if "history" in data else data["value"]),
+ self.property_mapping,
+ )
if history_size > 0 and cleaning_history[-1].date == history.date:
continue
+ if history.cleanup_method == CleanupMethod.CUSTOMIZED_CLEANING and self.capability.cleangenius:
+ history.cleanup_method = CleanupMethod.DEFAULT_MODE
+
cleaning_history.append(history)
history_size = history_size + 1
- if history_size >= 20 or history_size >= total:
+ if history_size >= max or history_size >= total:
break
if self.status._cleaning_history != cleaning_history:
- _LOGGER.debug("Cleaning History Changed")
+ _LOGGER.info("Cleaning History Changed")
self.status._cleaning_history = cleaning_history
+ self.status._cleaning_history_attrs = None
if cleaning_history:
self.status._last_cleaning_time = cleaning_history[0].date.replace(
tzinfo=datetime.now().astimezone().tzinfo
)
+ changed = True
- if self._ready:
- self._property_changed()
- except:
- _LOGGER.warning("Get Cleaning History failed!")
+ if self.capability.cruising:
+ # Cruising history is generated from events of water volume property that has been sent to cloud by the device when it changed
+ result = self._protocol.cloud.get_device_event(
+ DIID(DreameVacuumProperty.WATER_VOLUME, self.property_mapping),
+ limit,
+ start,
+ )
+ if result:
+ cruising_history = []
+ history_size = 0
+ for data in result:
+ history = CleaningHistory(
+ json.loads(data["history"] if "history" in data else data["value"]),
+ self.property_mapping,
+ )
+ if history_size > 0 and cruising_history[-1].date == history.date:
+ continue
+ cruising_history.append(history)
+ history_size = history_size + 1
+ if history_size >= max or history_size >= total:
+ break
+
+ if self.status._cruising_history != cruising_history:
+ _LOGGER.debug("Cruising History Changed")
+ self.status._cruising_history = cruising_history
+ self.status._cruising_history_attrs = None
+ if cruising_history:
+ self.status._last_cruising_time = cruising_history[0].date.replace(
+ tzinfo=datetime.now().astimezone().tzinfo
+ )
+ changed = True
+
+ if changed:
+ try:
+ self.history_map(1)
+ except:
+ pass
+
+ if self._ready:
+ for k, v in copy.deepcopy(self.status._history_map_data).items():
+ found = False
+ if self.status._cleaning_history:
+ for item in self.status._cleaning_history:
+ if k in item.file_name:
+ found = True
+ break
+
+ if found:
+ continue
+
+ if self.status._cruising_history:
+ for item in self.status._cruising_history:
+ if k in item.file_name:
+ found = True
+ break
+
+ if found:
+ continue
+
+ del self.status._history_map_data[k]
- def _property_changed(self) -> None:
+ if self._map_manager:
+ self._map_manager.editor.refresh_map()
+ self._property_changed()
+
+ except Exception as ex:
+ _LOGGER.warning("Get Cleaning History failed!: %s", ex)
+
+ def _property_changed(self, delay=True) -> None:
"""Call external listener when a property changed"""
if self._update_callback:
- _LOGGER.debug("Update Callback")
- self._update_callback()
+ if self._callback_timer is not None:
+ self._callback_timer.cancel()
+
+ if delay:
+ self._callback_timer = Timer(0.1, self._update_callback)
+ self._callback_timer.start()
+ else:
+ self._update_callback()
+
+ def _map_updated(self) -> None:
+ """Call external listener when a map updated from local"""
+ self._last_map_change_time = time.time()
+ self._property_changed()
+
+ def _map_changed(self, saved_map) -> None:
+ """Call external listener when a map changed"""
+ map_data = self.status.current_map
+ if self._map_select_time:
+ self._map_select_time = None
+ if not saved_map:
+ self._last_map_change_time = time.time()
+ if map_data and self.status.started:
+ if self.status.go_to_zone is None and not self.status._capability.cruising and self.status.zone_cleaning:
+ if map_data.active_areas and len(map_data.active_areas) == 1:
+ area = map_data.active_areas[0]
+ size = map_data.dimensions.grid_size * 2
+ if area.check_size(size):
+ new_cleaning_mode = None
+ if not (self.capability.self_wash_base or self.capability.mop_pad_lifting):
+ if (
+ self.status.cleaning_mode == DreameVacuumCleaningMode.MOPPING
+ and not self.status.water_tank_or_mop_installed
+ ):
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING.value
+ elif (
+ self.status.cleaning_mode == DreameVacuumCleaningMode.SWEEPING
+ and self.status.water_tank_or_mop_installed
+ ):
+ new_cleaning_mode = DreameVacuumCleaningMode.MOPPING_AND_SWEEPING.value
+
+ self.status.go_to_zone = GoToZoneSettings(
+ x=area.x0 + map_data.dimensions.grid_size,
+ y=area.y0 + map_data.dimensions.grid_size,
+ stop=bool(not self._map_manager.ready),
+ size=size,
+ cleaning_mode=new_cleaning_mode,
+ )
+ self._map_manager.editor.set_active_areas([])
+ else:
+ self.status.go_to_zone = False
+ else:
+ self.status.go_to_zone = False
+
+ if (
+ self.status.go_to_zone
+ and self.status.status != DreameVacuumStatus.REMOTE_CONTROL
+ and self.status.state != DreameVacuumState.REMOTE_CONTROL
+ ):
+ position = map_data.robot_position
+ if position:
+ size = self.status.go_to_zone.size
+ x = self.status.go_to_zone.x
+ y = self.status.go_to_zone.y
+ if (
+ position.x >= x - size
+ and position.x <= x + size
+ and position.y >= y - size
+ and position.y <= y + size
+ ):
+ self._restore_go_to_zone(True)
+
+ if self.status.docked != map_data.docked and self._protocol.prefer_cloud:
+ self.schedule_update(self._update_interval, True)
+
+ if self._map_manager.ready:
+ self._property_changed()
def _update_failed(self, ex) -> None:
"""Call external listener when update failed"""
if self._error_callback:
self._error_callback(ex)
- def _update_task(self) -> None:
+ def _action_update_task(self) -> None:
+ self._update_task(True)
+
+ def _update_task(self, force_request_properties=False) -> None:
"""Timer task for updating properties periodically"""
self._update_timer = None
-
try:
- self.update()
+ self.update(force_request_properties)
+ if self._ready:
+ self.available = True
self._update_fail_count = 0
+ self._last_update_failed = None
except Exception as ex:
self._update_fail_count = self._update_fail_count + 1
if self.available:
self._last_update_failed = time.time()
if self._update_fail_count <= 3:
- _LOGGER.warning("Update failed, retrying %s: %s", self._update_fail_count, ex)
- else:
- _LOGGER.debug("Update Failed: %s", ex)
+ _LOGGER.debug(
+ "Update failed, retrying %s: %s",
+ self._update_fail_count,
+ str(ex),
+ )
+ elif self._ready:
+ _LOGGER.warning("Update Failed: %s", str(ex))
self.available = False
self._update_failed(ex)
if not self.disconnected:
self.schedule_update(self._update_interval)
+ def _keep_alive_task(self):
+ self._keep_alive_timer = None
+
+ if (
+ self.device_connected
+ and not self.disconnected
+ and (not self._protocol.dreame_cloud or self.get_property(DreameVacuumProperty.KEEP_ALIVE) == 1)
+ ):
+ try:
+ self._request_properties([DreameVacuumProperty.KEEP_ALIVE])
+ except:
+ pass
+ self._keep_alive_timer = Timer(25, self._keep_alive_task)
+ self._keep_alive_timer.start()
+
+ def _update_cleaning_mode(self, cleaning_mode) -> int:
+ if self.capability.self_wash_base:
+ values = DreameVacuumDevice.split_group_value(
+ self.get_property(DreameVacuumProperty.CLEANING_MODE),
+ self.capability.mop_pad_lifting,
+ )
+ if not (values and len(values) == 3):
+ return False
+
+ if self.capability.mop_pad_lifting:
+ if cleaning_mode == 2:
+ values[0] = 0
+ elif cleaning_mode == 0:
+ values[0] = 2
+ else:
+ values[0] = cleaning_mode
+ elif cleaning_mode == 2:
+ values[0] = 0
+ cleaning_mode = DreameVacuumDevice.combine_group_value(values)
+ elif self.capability.mop_pad_lifting:
+ if cleaning_mode == 2:
+ cleaning_mode = 0
+ elif cleaning_mode == 0:
+ cleaning_mode = 2
+ return self.set_property(DreameVacuumProperty.CLEANING_MODE, cleaning_mode)
+
+ def _update_self_clean_value(self, self_clean_value) -> int:
+ if self.capability.self_wash_base:
+ values = DreameVacuumDevice.split_group_value(
+ self.get_property(DreameVacuumProperty.CLEANING_MODE),
+ self.capability.mop_pad_lifting,
+ )
+ if values and len(values) == 3:
+ values[1] = self_clean_value
+ return self.set_property(
+ DreameVacuumProperty.CLEANING_MODE,
+ DreameVacuumDevice.combine_group_value(values),
+ )
+ return False
+
+ def _update_self_clean_time(self, self_clean_time) -> int:
+ if self.capability.self_wash_base:
+ values = DreameVacuumDevice.split_group_value(
+ self.get_property(DreameVacuumProperty.CLEANING_MODE),
+ self.capability.mop_pad_lifting,
+ )
+ if values and len(values) == 3:
+ values[1] = self_clean_time
+ return self.set_property(
+ DreameVacuumProperty.CLEANING_MODE,
+ DreameVacuumDevice.combine_group_value(values),
+ )
+ return False
+
+ def _update_water_level(self, water_level) -> int:
+ if (
+ self.capability.mopping_settings
+ and self.capability.self_wash_base
+ and not self.capability.wetness_level
+ and water_level == 3
+ and self.status.self_clean_value > 15
+ and not self.status.self_clean_by_time
+ ):
+ self.set_self_clean_value(15)
+
+ if self.capability.custom_mopping_route and not self.status.custom_mopping_mode:
+ self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.MOPPING_MODE, water_level, False)
+
+ if self.capability.wetness:
+ wetness_level = 0
+ if self.capability.custom_mopping_route and not self.status.custom_mopping_mode:
+ if water_level == 1:
+ wetness_level = 100
+ elif water_level == 3:
+ wetness_level = 400
+ else:
+ wetness_level = 200
+ elif self.capability.mop_clean_frequency:
+ if water_level == 1:
+ wetness_level = 2
+ elif water_level == 3:
+ wetness_level = 14
+ else:
+ wetness_level = 8
+ else:
+ if water_level == 1:
+ wetness_level = 5
+ elif water_level == 3:
+ wetness_level = 27
+ else:
+ wetness_level = 16
+ result = self.set_wetness_level(wetness_level)
+ if self.capability.wetness_level:
+ return result
+
+ if not self.capability.self_wash_base:
+ result = self.set_property(DreameVacuumProperty.WATER_VOLUME, int(water_level))
+ else:
+ values = DreameVacuumDevice.split_group_value(
+ self.get_property(DreameVacuumProperty.CLEANING_MODE),
+ self.capability.mop_pad_lifting,
+ )
+ if values and len(values) == 3:
+ if self.capability.wetness and not self.capability.wetness_level and values[2] == 0:
+ return result
+ values[2] = water_level
+ return self.set_property(
+ DreameVacuumProperty.CLEANING_MODE,
+ DreameVacuumDevice.combine_group_value(values),
+ )
+ return False
+ return result
+
+ def _update_suction_level(self, suction_level) -> int:
+ return self.set_property(DreameVacuumProperty.SUCTION_LEVEL, int(suction_level))
+
+ def _set_go_to_zone(self, x, y, size):
+ current_cleaning_mode = int(self.status.cleaning_mode.value)
+ current_suction_level = int(self.status.suction_level.value)
+ current_water_level = int(
+ self.status.mop_pad_humidity if self.capability.self_wash_base else self.status.water_volume.value
+ )
+
+ new_cleaning_mode = None
+ new_suction_level = None
+ new_water_level = None
+
+ if self.capability.self_wash_base or self.capability.mop_pad_lifting or self.capability.wetness_level:
+ if current_cleaning_mode != DreameVacuumCleaningMode.SWEEPING.value:
+ new_cleaning_mode = DreameVacuumCleaningMode.SWEEPING.value
+ else:
+ current_cleaning_mode = None
+
+ if current_suction_level != DreameVacuumSuctionLevel.QUIET.value:
+ new_suction_level = DreameVacuumSuctionLevel.QUIET.value
+ else:
+ current_suction_level = None
+
+ current_water_level = None
+ else:
+ cleaning_mode = DreameVacuumCleaningMode.MOPPING.value
+ if self.status.water_tank_or_mop_installed:
+ if self.status.current_map and self.status.current_map.no_mopping_areas:
+ for area in self.status.current_map.no_mopping_areas:
+ if area.check_point(x, y, size):
+ cleaning_mode = DreameVacuumCleaningMode.SWEEPING.value
+ break
+
+ if current_cleaning_mode != cleaning_mode:
+ new_cleaning_mode = cleaning_mode
+ else:
+ if (
+ current_cleaning_mode == DreameVacuumCleaningMode.MOPPING.value
+ and not self.status.water_tank_or_mop_installed
+ ):
+ current_cleaning_mode = DreameVacuumCleaningMode.SWEEPING.value
+ elif (
+ current_cleaning_mode == DreameVacuumCleaningMode.SWEEPING.value
+ and self.status.water_tank_or_mop_installed
+ ):
+ current_cleaning_mode = DreameVacuumCleaningMode.SWEEPING_AND_MOPPING.value
+ else:
+ current_cleaning_mode = None
+
+ if current_water_level != DreameVacuumWaterVolume.LOW.value:
+ new_water_level = DreameVacuumWaterVolume.LOW.value
+ else:
+ current_water_level = None
+
+ current_suction_level = None
+
+ try:
+ if new_suction_level is not None:
+ self._update_suction_level(new_suction_level)
+
+ if new_water_level is not None:
+ self._update_water_level(new_water_level)
+
+ if new_cleaning_mode is not None:
+ self._update_cleaning_mode(new_cleaning_mode)
+ except:
+ pass
+
+ self.status.go_to_zone = GoToZoneSettings(
+ x=x,
+ y=y,
+ stop=True,
+ start=False,
+ suction_level=current_suction_level,
+ water_level=current_water_level,
+ cleaning_mode=current_cleaning_mode,
+ size=size,
+ )
+
+ def _restore_go_to_zone(self, stop=False):
+ if self.status.go_to_zone is not None:
+ if self.status.go_to_zone:
+ stop = stop and self.status.go_to_zone.stop
+ suction_level = self.status.go_to_zone.suction_level
+ water_level = self.status.go_to_zone.water_level
+ cleaning_mode = self.status.go_to_zone.cleaning_mode
+ self.status.go_to_zone = None
+ if stop:
+ self.schedule_update(10, True)
+ try:
+ mapping = self.action_mapping[DreameVacuumAction.STOP]
+ self._protocol.action(mapping["siid"], mapping["aiid"])
+ except:
+ pass
+
+ try:
+ self._cleaning_history_update = time.time()
+ if cleaning_mode is not None and self.status.cleaning_mode.value != cleaning_mode:
+ self._update_cleaning_mode(cleaning_mode)
+ if suction_level is not None and self.status.suction_level.value != suction_level:
+ self._update_suction_level(suction_level)
+ if water_level is not None and self.status.water_volume.value != water_level:
+ self._update_water_level(water_level)
+
+ if stop and self.status.started:
+ self._update_status(DreameVacuumTaskStatus.COMPLETED, DreameVacuumStatus.STANDBY)
+ except:
+ pass
+
+ if self._protocol.dreame_cloud:
+ self.schedule_update(3, True)
+ else:
+ self.status.go_to_zone = None
+
+ def _calculate_self_clean_area_limits(self):
+ if self.capability.self_wash_base:
+ if self.capability.mop_clean_frequency:
+ self.status.self_clean_area_min = 5
+ self.status.self_clean_area_max = 10
+ self.status.self_clean_area_default = 8
+ else:
+ default_self_clean_area = self.capability.self_clean_area_min == 10
+
+ if not default_self_clean_area:
+ self.status.self_clean_area_min = self.capability.self_clean_area_min
+ self.status.self_clean_area_max = self.capability.self_clean_area_max
+ self.status.self_clean_area_default = self.capability.self_clean_area_default
+ else:
+ if not self.capability.cleaning_route:
+ self.status.self_clean_area_max = 30
+
+ if self.capability.small_water_tank:
+ self.status.self_clean_area_min = 8
+
+ if self.capability.self_clean_frequency:
+ self.status.self_clean_time_min = self.capability.self_clean_time_min
+ self.status.self_clean_time_max = self.capability.self_clean_time_max
+ self.status.self_clean_time_default = (
+ self.capability.self_clean_time_fixed_default
+ if self.capability.self_clean_time_fixed_default > 0
+ else self.capability.self_clean_time_default
+ )
+
+ if self.capability.wetness_level:
+ if self.capability.small_water_tank:
+ if self.status.wetness_level > 22:
+ self.status.self_clean_area_max = 15
+ self.status.self_clean_area_default = 12
+
+ if self.capability.self_clean_frequency:
+ self.status.self_clean_time_min = 10
+ self.status.self_clean_time_max = 20
+ self.status.self_clean_time_default = 15
+ else:
+ self.status.self_clean_area_max = 25
+ self.status.self_clean_area_default = 15
+
+ if self.capability.self_clean_frequency:
+ self.status.self_clean_time_min = 10
+ self.status.self_clean_time_max = 40
+ self.status.self_clean_time_default = 20
+ else:
+ if self.status.wetness_level > 26:
+ if self.capability.self_clean_frequency:
+ self.status.self_clean_time_min = 10
+ self.status.self_clean_time_max = (
+ self.capability.self_clean_time_fixed_default
+ if self.capability.self_clean_time_fixed_default > 20
+ else 20
+ )
+ self.status.self_clean_time_default = (
+ self.capability.self_clean_time_fixed_default
+ if self.capability.self_clean_time_fixed_default > 0
+ else 20
+ )
+
+ if default_self_clean_area or self.capability.self_clean_frequency:
+ self.status.self_clean_area_max = (
+ self.capability.self_clean_area_fixed_default
+ if self.capability.self_clean_area_fixed_default > 20
+ else 20
+ )
+ if self.capability.self_clean_area_fixed_default > 0:
+ self.status.self_clean_area_default = self.capability.self_clean_area_fixed_default
+ elif default_self_clean_area or self.capability.self_clean_frequency:
+ self.status.self_clean_area_max = 35
+ if self.capability.self_clean_area_fixed_default > 0:
+ self.status.self_clean_area_default = self.capability.self_clean_area_fixed_default
+ elif self.capability.mopping_settings:
+ if self.status.mop_pad_humidity == 3:
+ self.status.self_clean_time_max = 20
+ self.status.self_clean_time_default = 20
+
+ if default_self_clean_area:
+ self.status.self_clean_area_max = 15
+ self.status.self_clean_area_default = 15
+ elif self.status.mop_pad_humidity:
+ self.status.self_clean_time_max = 50
+ self.status.self_clean_time_default = 25
+
+ if default_self_clean_area:
+ self.status.self_clean_area_max = 35 if self.capability.cleaning_route else 30
+ self.status.self_clean_area_default = 20
+
@staticmethod
- def split_group_value(value: int, mop_pad_lifting_available: bool = False) -> list[int]:
+ def split_group_value(value: int, mop_pad_lifting: bool = False) -> list[int]:
if value is not None:
value_list = []
- value_list.append((value & 3) if mop_pad_lifting_available else (value & 1))
+ value_list.append((value & 0x03) if mop_pad_lifting else (value & 1))
byte1 = value >> 8
byte1 = byte1 & -769
value_list.append(byte1)
@@ -714,70 +2282,75 @@ def split_group_value(value: int, mop_pad_lifting_available: bool = False) -> li
@staticmethod
def combine_group_value(values: list[int]) -> int:
if values and len(values) == 3:
- num = 0
- high = (num ^ values[2]) << 8
- mid = (high ^ values[1]) << 8
- low = mid ^ values[0]
- return low
+ return ((((0 ^ values[2]) << 8) ^ values[1]) << 8) ^ values[0]
def connect_device(self) -> None:
"""Connect to the device api."""
_LOGGER.info("Connecting to device")
- self.info = DreameVacuumDeviceInfo(self._protocol.connect())
- if self.mac is None:
- self.mac = self.info.mac_address
- _LOGGER.info("Connected to device: %s %s", self.info.model, self.info.firmware_version)
-
- self._last_settings_request = time.time()
- self._last_map_list_request = self._last_settings_request
- self._dirty_data = {}
- self._request_properties()
- self._last_update_failed = None
-
- if self.device_connected and self._protocol.cloud is not None and (not self._ready or not self.available):
- if self._map_manager:
- model = self.info.model.split(".")
- if len(model) == 3:
- key = json.loads(zlib.decompress(base64.b64decode(DEVICE_MAP_KEY), zlib.MAX_WBITS | 32)).get(
- model[2]
- )
- if key:
- self._map_manager.set_aes_iv(key)
-
- if not self.status.lidar_navigation:
- self._map_manager.set_vslam_map()
- self._map_manager.set_update_interval(self._map_update_interval)
- self._map_manager.set_device_running(
- self.status.running, self.status.docked and not self.status.started
- )
+ info = self._protocol.connect(self._message_callback, self._connected_callback)
+ if info:
+ self.info = DreameVacuumDeviceInfo(info)
+ if self.mac is None:
+ self.mac = self.info.mac_address
+ _LOGGER.info(
+ "Connected to device: %s %s",
+ self.info.model,
+ self.info.firmware_version,
+ )
- if self.status.current_map is None:
- self._map_manager.schedule_update(15)
- self._map_manager.update()
- self._last_map_request = self._last_settings_request
- self._map_manager.schedule_update()
- else:
- self.update_map()
+ self._last_settings_request = time.time()
+ self._last_map_list_request = self._last_settings_request
+ self._dirty_data = {}
+ self._dirty_auto_switch_data = {}
+ self._dirty_ai_data = {}
+ self._request_properties()
+
+ self._last_update_failed = None
+
+ if self.device_connected and self._protocol.cloud is not None and (not self._ready or not self.available):
+ if self._map_manager:
+ self._map_manager.set_capability(self.capability)
+ self._map_manager.set_update_interval(self._map_update_interval)
+ self._map_manager.set_device_running(
+ self.status.running,
+ self.status.docked and not self.status.started,
+ )
- if self.cloud_connected:
- self._cleaning_history_update = -1
- self._request_cleaning_history()
+ if self.status.current_map is None:
+ self._map_manager.schedule_update(15)
+ try:
+ self._map_manager.update()
+ self._last_map_request = self._last_settings_request
+ except Exception as ex:
+ _LOGGER.error("Initial map update failed! %s", str(ex))
+ self._map_manager.schedule_update()
+ else:
+ self.update_map()
- if self.status.ai_detection_available and not self.status.ai_policy_accepted:
- prop = "prop.s_ai_config"
- response = self._protocol.cloud.get_batch_device_datas([prop])
- if response and prop in response and response[prop]:
+ if self.cloud_connected:
+ self._cleaning_history_update = -1
+ self._request_cleaning_history()
+ if (self.capability.ai_detection and not self.status.ai_policy_accepted) or True:
try:
- self.status.ai_policy_accepted = json.loads(response[prop]).get("privacyAuthed")
+ prop = "prop.s_ai_config"
+ response = self._protocol.cloud.get_batch_device_datas([prop])
+ if response and prop in response and response[prop]:
+ value = json.loads(response[prop])
+ self.status.ai_policy_acepted = (
+ value.get("privacyAuthed")
+ if "privacyAuthed" in value
+ else value.get("aiPrivacyAuthed")
+ )
except:
pass
- if not self.available:
- self.available = True
- if self._ready:
- self._property_changed()
+ if not self.available:
+ self.available = True
- self._ready = True
+ if not self._ready:
+ self._ready = True
+ else:
+ self._property_changed(False)
def connect_cloud(self) -> None:
"""Connect to the cloud api."""
@@ -787,23 +2360,29 @@ def connect_cloud(self) -> None:
if self._protocol.cloud.logged_in is False:
if self._protocol.cloud.auth_failed:
self.auth_failed = True
- self._property_changed()
+ self._property_changed(False)
self._map_manager.schedule_update(-1)
elif self._protocol.cloud.logged_in:
if self._protocol.connected:
self._map_manager.schedule_update(5)
+
self.token, self.host = self._protocol.cloud.get_info(self.mac)
- self._protocol.set_credentials(self.host, self.token, self.mac)
+ if not self._protocol.dreame_cloud:
+ self._protocol.set_credentials(self.host, self.token, self.mac, self.account_type)
def disconnect(self) -> None:
"""Disconnect from device and cancel timers"""
_LOGGER.info("Disconnect")
self.disconnected = True
self.schedule_update(-1)
+ if self._keep_alive_timer is not None:
+ self._keep_alive_timer.cancel()
+ del self._keep_alive_timer
+ self._keep_alive_timer = None
self._protocol.disconnect()
if self._map_manager:
- self._map_manager.schedule_update(-1)
- self._property_changed()
+ self._map_manager.disconnect()
+ self._property_changed(False)
def listen(self, callback, property: DreameVacuumProperty = None) -> None:
"""Set callback functions for external listeners"""
@@ -823,9 +2402,9 @@ def listen_error(self, callback) -> None:
"""Set error callback function for external listeners"""
self._error_callback = callback
- def schedule_update(self, wait: float = None) -> None:
+ def schedule_update(self, wait: float = None, force_request_properties=False) -> None:
"""Schedule a device update for future"""
- if not wait:
+ if wait == None:
wait = self._update_interval
if self._update_timer is not None:
@@ -834,23 +2413,368 @@ def schedule_update(self, wait: float = None) -> None:
self._update_timer = None
if wait >= 0:
- self._update_timer = Timer(wait, self._update_task)
+ self._update_timer = Timer(
+ wait, self._action_update_task if force_request_properties else self._update_task
+ )
self._update_timer.start()
- def get_property(self, prop: DreameVacuumProperty) -> Any:
+ def get_property(
+ self,
+ prop: (
+ DreameVacuumProperty | DreameVacuumAutoSwitchProperty | DreameVacuumStrAIProperty | DreameVacuumAIProperty
+ ),
+ ) -> Any:
"""Get a device property from memory"""
+ if isinstance(prop, DreameVacuumAutoSwitchProperty):
+ return self.get_auto_switch_property(prop)
+ if isinstance(prop, DreameVacuumStrAIProperty) or isinstance(prop, DreameVacuumAIProperty):
+ return self.get_ai_property(prop)
if prop is not None and prop.value in self.data:
return self.data[prop.value]
return None
- def set_property(self, prop: DreameVacuumProperty, value: Any) -> bool:
+ def get_auto_switch_property(self, prop: DreameVacuumAutoSwitchProperty) -> int:
+ """Get a device auto switch property from memory"""
+ if self.capability.auto_switch_settings and self.auto_switch_data:
+ if prop is not None and prop.name in self.auto_switch_data:
+ return int(self.auto_switch_data[prop.name])
+ return None
+
+ def get_ai_property(self, prop: DreameVacuumStrAIProperty | DreameVacuumAIProperty) -> bool:
+ """Get a device AI property from memory"""
+ if self.capability.ai_detection and self.ai_data:
+ if prop is not None and prop.name in self.ai_data:
+ return bool(self.ai_data[prop.name])
+ return None
+
+ def set_property_value(self, prop: str, value: Any = None, params: Any = None):
+ if prop is not None and value is not None:
+ set_fn = "set_" + prop.lower()
+ if hasattr(self, set_fn):
+ set_fn = getattr(self, set_fn)
+ else:
+ set_fn = None
+
+ prop = prop.upper()
+ if prop in DreameVacuumProperty.__members__:
+ prop = DreameVacuumProperty(DreameVacuumProperty[prop])
+ if prop not in READ_WRITE_PROPERTIES:
+ raise InvalidActionException(f"Invalid property: {prop}")
+ elif prop in DreameVacuumAutoSwitchProperty.__members__:
+ prop = DreameVacuumAutoSwitchProperty(DreameVacuumAutoSwitchProperty[prop])
+ elif prop in DreameVacuumAIProperty.__members__:
+ prop = DreameVacuumAIProperty(DreameVacuumAIProperty[prop])
+ elif prop in DreameVacuumStrAIProperty.__members__:
+ prop = DreameVacuumStrAIProperty(DreameVacuumStrAIProperty[prop])
+ elif set_fn is None:
+ raise InvalidActionException(f"Invalid property: {prop}")
+
+ if set_fn is None and self.get_property(prop) is None:
+ raise InvalidActionException(f"Invalid property: {prop}")
+
+ prop_name = prop.lower() if isinstance(prop, str) else prop.name
+
+ if (
+ (
+ self.status.started
+ or not (
+ prop is DreameVacuumProperty.SUCTION_LEVEL
+ or prop is DreameVacuumProperty.WATER_VOLUME
+ or prop is DreameVacuumProperty.CLEANING_MODE
+ or prop is DreameVacuumProperty.WETNESS_LEVEL
+ or prop is DreameVacuumProperty.MOP_TEMPERATURE
+ or prop is DreameVacuumProperty.MOP_PRESSURE
+ or prop is DreameVacuumAutoSwitchProperty.CLEANING_ROUTE
+ or prop == "CUSTOM_MOPPING_ROUTE"
+ or prop == "MOP_PAD_HUMIDITY"
+ )
+ )
+ and prop_name in PROPERTY_AVAILABILITY
+ and not PROPERTY_AVAILABILITY[prop_name](self)
+ ):
+ raise InvalidActionException(f"Property unavailable: {prop_name}")
+
+ def get_int_value(enum, value, enum_list=None):
+ if isinstance(value, str):
+ value = value.upper().replace(" ", "_")
+ if value.isnumeric():
+ value = int(value)
+ elif value in enum.__members__:
+ value = enum[value].value
+ if enum_list is None:
+ return value
+
+ if isinstance(value, int):
+ if enum_list is None:
+ if value in enum._value2member_map_:
+ return value
+ elif value in enum_list.values():
+ return value
+
+ val = value
+ string_value = False
+ if prop is DreameVacuumProperty.SUCTION_LEVEL:
+ val = get_int_value(DreameVacuumSuctionLevel, val)
+ elif prop is DreameVacuumProperty.WATER_VOLUME:
+ val = get_int_value(DreameVacuumWaterVolume, val)
+ elif prop is DreameVacuumProperty.CLEANING_MODE:
+ val = get_int_value(DreameVacuumCleaningMode, val)
+ elif prop is DreameVacuumProperty.CARPET_SENSITIVITY:
+ val = get_int_value(DreameVacuumCarpetSensitivity, val)
+ elif prop is DreameVacuumProperty.CARPET_CLEANING:
+ val = get_int_value(DreameVacuumCarpetCleaning, val, self.status.carpet_cleaning_list)
+ elif prop is DreameVacuumProperty.MOP_WASH_LEVEL:
+ val = get_int_value(DreameVacuumMopWashLevel, val)
+ elif prop is DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE:
+ val = get_int_value(DreameVacuumVoiceAssistantLanguage, val, self.status.voice_assistant_language_list)
+ elif prop is DreameVacuumProperty.MOP_PRESSURE:
+ val = get_int_value(DreameVacuumMopPressure, val, self.status.mop_pressure_list)
+ elif prop is DreameVacuumProperty.MOP_TEMPERATURE:
+ val = get_int_value(DreameVacuumMopTemperature, val, self.status.mop_temperature_list)
+ elif prop is DreameVacuumProperty.LOW_LYING_AREA_FREQUENCY:
+ val = get_int_value(DreameVacuumLowLyingAreaFrequency, val, self.status.low_lying_area_frequency_list)
+ elif prop is DreameVacuumProperty.SCRAPER_FREQUENCY:
+ val = get_int_value(DreameVacuumScraperFrequency, val, self.status.scraper_frequency_list)
+ elif prop is DreameVacuumProperty.SCHEDULE: ## TODO: Convert this to service
+ valid = True
+ if val and val != "":
+ tasks = val.split(";")
+ for task in tasks:
+ props = task.split("-")
+ if len(props) < 9:
+ valid = False
+ break
+ id = int(props[0])
+ if not id:
+ valid = False
+ break
+ time = props[2]
+ if ":" not in time:
+ valid = False
+ break
+ if valid:
+ string_value = val
+ elif prop is DreameVacuumProperty.DND_TASK: ## TODO: Convert this to service
+ if not self.capability.dnd_task:
+ raise InvalidActionException(f"Invalid property: {prop}")
+ else:
+ valid = True
+ if val and val != "":
+ try:
+ data = json.loads(val)
+ if not isinstance(data, list):
+ valid = False
+ else:
+ required_keys = ["id", "st", "et", "en", "wk", "ss"]
+ for item in data:
+ if not all(key in item for key in required_keys):
+ valid = False
+ break
+ item_id = item[required_keys[0]]
+ if not isinstance(item_id, (int, float)) or item_id < 0:
+ valid = False
+ break
+ en = item[required_keys[3]]
+ if en not in [0, 1]:
+ valid = False
+ break
+ ss = item[required_keys[5]]
+ if not isinstance(ss, (int, float)) or ss < -1:
+ valid = False
+ break
+ times_valid = True
+ for key in [required_keys[1], required_keys[2]]:
+ t = item[key]
+ if not isinstance(t, str) or len(t) != 5 or t[2] != ":":
+ times_valid = False
+ break
+ h_m = t.split(":")
+ if not (h_m[0].isdigit() and h_m[1].isdigit()):
+ times_valid = False
+ break
+ if not (0 <= int(h_m[0]) <= 23 and 0 <= int(h_m[1]) <= 59):
+ times_valid = False
+ break
+ if not times_valid:
+ valid = False
+ break
+ wk = item[required_keys[4]]
+ if not isinstance(wk, int) or not (0 < wk <= 127):
+ valid = False
+ break
+
+ except:
+ valid = False
+
+ if valid:
+ string_value = val
+ elif prop is DreameVacuumProperty.CLEANGENIUS_MODE:
+ val = get_int_value(DreameVacuumCleanGeniusMode, val, self.status.cleangenius_mode_list)
+ elif prop is DreameVacuumProperty.WATER_TEMPERATURE:
+ val = get_int_value(DreameVacuumWaterTemperature, val, self.status.water_temperature_list)
+ elif prop is DreameVacuumAutoSwitchProperty.MOPPING_TYPE:
+ val = get_int_value(DreameVacuumMoppingType, val, self.status.mopping_type_list)
+ elif prop is DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE:
+ val = get_int_value(DreameVacuumWiderCornerCoverage, val, self.status.wider_corner_coverage_list)
+ elif prop is DreameVacuumAutoSwitchProperty.MOP_PAD_SWING:
+ val = get_int_value(DreameVacuumMopPadSwing, val, self.status.mop_pad_swing_list)
+ elif prop is DreameVacuumAutoSwitchProperty.MOP_EXTEND_FREQUENCY:
+ val = get_int_value(DreameVacuumMopExtendFrequency, val, self.status.mop_extend_frequency_list)
+ elif prop is DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY:
+ val = get_int_value(DreameVacuumSelfCleanFrequency, val)
+ elif (
+ prop is DreameVacuumAutoSwitchProperty.AUTO_RECLEANING
+ or prop is DreameVacuumAutoSwitchProperty.AUTO_REWASHING
+ ):
+ val = get_int_value(DreameVacuumSecondCleaning, val, self.status.second_cleaning_list)
+ elif prop is DreameVacuumAutoSwitchProperty.CLEANING_ROUTE:
+ val = get_int_value(DreameVacuumCleaningRoute, val, self.status.cleaning_route_list)
+ elif prop is DreameVacuumAutoSwitchProperty.CLEANGENIUS:
+ val = get_int_value(DreameVacuumCleanGenius, val, self.status.cleangenius_list)
+ elif prop is DreameVacuumProperty.AUTO_LDS_COVERAGE:
+ val = get_int_value(DreameVacuumAutoLDSCoverage, val, self.status.auto_lds_coverage_list)
+ elif prop == DreameVacuumProperty.BATTERY_CHARGE_LEVEL:
+ if val in ["80%", "90%", "100%"]:
+ val = int(val[:-1])
+ if val not in [80, 90, 100]:
+ val = None
+ elif prop == "MOP_PAD_HUMIDITY":
+ val = get_int_value(DreameVacuumMopPadHumidity, val)
+ elif prop == "CUSTOM_MOPPING_ROUTE":
+ val = get_int_value(DreameVacuumCustomMoppingRoute, val, self.status.custom_mopping_route_list)
+ elif prop == "AUTO_EMPTY_MODE":
+ val = (
+ get_int_value(DreameVacuumAutoEmptyModeV2, val, self.status.auto_empty_mode_list)
+ if self.capability.intelligent_auto_empty
+ else get_int_value(DreameVacuumAutoEmptyMode, val, self.status.auto_empty_mode_list)
+ )
+ elif prop == "WASHING_MODE":
+ val = get_int_value(DreameVacuumWashingMode, val, self.status.washing_mode_list)
+ elif (
+ prop == DreameVacuumProperty.DND_START
+ or prop == DreameVacuumProperty.DND_END
+ or prop == "OFF_PEAK_CHARGING_START"
+ or prop == "OFF_PEAK_CHARGING_END"
+ ):
+ string_value = re.match(r"([0-1][0-9]|2[0-3]):[0-5][0-9]$", val)
+ elif prop is DreameVacuumProperty.DRYING_TIME:
+ if self.capability.mop_clean_frequency:
+ if val < 2 or val > 12:
+ val = None
+ elif int(val) not in self.status.drying_time_list.values():
+ val = None
+ elif prop == "SELECTED_MAP" and (not self.status.map_data_list or val not in self.status.map_data_list):
+ val = None
+ elif isinstance(val, bool):
+ val = int(val)
+ elif isinstance(val, str):
+ val = val.upper()
+ if val == "TRUE" or val == "1":
+ val = 1
+ elif val == "FALSE" or val == "0":
+ val = 0
+ elif val.isnumeric():
+ val = int(val)
+ else:
+ val = None
+
+ if val is None or not (isinstance(val, int) or string_value):
+ raise InvalidActionException(f"Invalid value: {value}")
+
+ if prop == DreameVacuumProperty.VOLUME:
+ if val < 0 or val > 100:
+ val = None
+ elif prop == DreameVacuumProperty.MOP_CLEANING_REMAINDER:
+ if val < 0 or val > 180:
+ val = None
+ elif prop == DreameVacuumProperty.CAMERA_LIGHT_BRIGHTNESS:
+ if val < 40 or val > 100:
+ val = None
+ elif prop == DreameVacuumProperty.WETNESS_LEVEL:
+ if val < 1 or val > 32:
+ val = None
+ elif prop == DreameVacuumProperty.AUTO_EMPTY_AREA:
+ if val < 5 or val > 15:
+ val = None
+ elif prop == "SELF_CLEAN_AREA" or prop == "SELF_CLEAN_VALUE":
+ if val != 0 and (val < self.status.self_clean_area_min or val > self.status.self_clean_area_max):
+ val = None
+ elif prop == "SELF_CLEAN_TIME":
+ if val < self.status.self_clean_time_min or val > self.status.self_clean_time_max:
+ val = None
+
+ if val is None:
+ raise InvalidActionException(f"Invalid value: {value}")
+
+ if not self.device_connected:
+ raise InvalidActionException("Device unavailable")
+
+ if set_fn:
+ if params:
+ return set_fn(*params)
+ return set_fn(val)
+
+ if self.get_property(prop) == val or self.set_property(prop, val):
+ return
+ raise InvalidActionException(f"Property {prop} not updated: {val}")
+ raise InvalidActionException("Invalid property or value")
+
+ def call_action_value(self, action: str, params: None):
+ if action is not None:
+ if hasattr(self, action) and not action.startswith("_"):
+ action_fn = getattr(self, action)
+ else:
+ action_fn = None
+
+ action = action.upper()
+ if action in DreameVacuumAction.__members__:
+ action = DreameVacuumAction(DreameVacuumAction[action])
+ elif action_fn is None:
+ raise InvalidActionException(f"Invalid action: {action}")
+
+ if not self.device_connected:
+ raise InvalidActionException("Device is unavailable")
+
+ action_name = action.lower() if isinstance(action, str) else action.name
+
+ if action_name in ACTION_AVAILABILITY and not ACTION_AVAILABILITY[action_name](self):
+ raise InvalidActionException(f"Action unavailable: {action}")
+
+ if action_fn:
+ if params is not None:
+ return action_fn(params)
+ return action_fn()
+
+ result = self.call_action(action, params)
+ if result and result.get("code") == 0:
+ return
+ raise InvalidActionException(f"Unable to call action: {action}")
+ raise InvalidActionException(f"Invalid action: {action}")
+
+ def set_property(
+ self,
+ prop: (
+ DreameVacuumProperty | DreameVacuumAutoSwitchProperty | DreameVacuumStrAIProperty | DreameVacuumAIProperty
+ ),
+ value: Any,
+ ) -> bool:
"""Sets property value using the existing property mapping and notify listeners
Property must be set on memory first and notify its listeners because device does not return new value immediately.
"""
+ if value is None:
+ return False
+
+ if isinstance(prop, DreameVacuumAutoSwitchProperty):
+ return self.set_auto_switch_property(prop, value)
+ if isinstance(prop, DreameVacuumStrAIProperty) or isinstance(prop, DreameVacuumAIProperty):
+ return self.set_ai_property(prop, value)
self.schedule_update(10)
- current_value = self._update_property(prop, value)
+ current_value = self._update_property(prop, value, False)
if current_value is not None:
+ if prop not in DISCARDED_PROPERTIES:
+ self._dirty_data[prop.value] = DirtyData(value, current_value, time.time())
+
self._last_change = time.time()
self._last_settings_request = 0
@@ -858,16 +2782,28 @@ def set_property(self, prop: DreameVacuumProperty, value: Any) -> bool:
mapping = self.property_mapping[prop]
result = self._protocol.set_property(mapping["siid"], mapping["piid"], value)
- if result and result[0]["code"] != 0:
- _LOGGER.error("Property not updated: %s: %s -> %s", prop, current_value, value)
- self._update_property(prop, current_value)
+ if result is None or result[0]["code"] != 0:
+ _LOGGER.error(
+ "Property not updated: %s: %s -> %s",
+ prop.name,
+ current_value,
+ value,
+ )
+ if prop != DreameVacuumProperty.KEEP_ALIVE:
+ self._update_property(prop, current_value)
if prop.value in self._dirty_data:
del self._dirty_data[prop.value]
+ self._property_changed(False)
- # Schedule the update for getting the updated property value from the device
- # If property is actually updated nothing will happen otherwise it will return to previous value and notify its listeners. (Post optimistic approach)
- self.schedule_update(2)
- return True
+ self.schedule_update(2)
+ return False
+ else:
+ _LOGGER.info("Update Property: %s: %s -> %s", prop.name, current_value, value)
+ if prop.value in self._dirty_data:
+ self._dirty_data[prop.value].update_time = time.time()
+
+ self.schedule_update(3)
+ return True
except Exception as ex:
self._update_property(prop, current_value)
if prop.value in self._dirty_data:
@@ -878,88 +2814,466 @@ def set_property(self, prop: DreameVacuumProperty, value: Any) -> bool:
self.schedule_update(1)
return False
- def get_map_for_render(self, map_index: int) -> MapData | None:
+ def set_properties(self, properties: dict) -> bool:
+ """Sets multiple properties at once using the existing property mapping and notify listeners"""
+ if not properties:
+ return True
+
+ self.schedule_update(10)
+ values = []
+ current_value = {}
+ for prop, value in properties.items():
+ # if isinstance(prop, DreameVacuumAutoSwitchProperty):
+ # return self.set_auto_switch_property(prop, value)
+ # if isinstance(prop, DreameVacuumStrAIProperty) or isinstance(prop, DreameVacuumAIProperty):
+ # return self.set_ai_property(prop, value)
+
+ if prop in self.property_mapping:
+ current_value[prop] = self.get_property(prop)
+ if current_value[prop] != value:
+ self.data[prop.value] = value
+ if prop.value in self._property_update_callback:
+ for callback in self._property_update_callback[prop.value]:
+ callback(current_value[prop])
+
+ if current_value[prop] is None:
+ current_value[prop] = value
+
+ if prop not in DISCARDED_PROPERTIES:
+ self._dirty_data[prop.value] = DirtyData(value, current_value[prop], time.time())
+
+ self._last_change = time.time()
+ self._last_settings_request = 0
+
+ mapping = self.property_mapping[prop]
+ values.append((mapping["siid"], mapping["piid"], value))
+
+ if values:
+ self._property_changed(False)
+
+ try:
+ result = self._protocol.set_properties(values)
+
+ if result is None or result[0]["code"] != 0:
+ for prop, value in properties.items():
+ if prop in self.property_mapping and current_value[prop] != value:
+ _LOGGER.error(
+ "Property not updated: %s: %s -> %s",
+ prop.name,
+ current_value[prop],
+ value,
+ )
+ self._update_property(prop, current_value[prop])
+ if prop.value in self._dirty_data:
+ del self._dirty_data[prop.value]
+
+ self._property_changed(False)
+ self.schedule_update(2)
+ return False
+ else:
+ for prop, value in properties.items():
+ if prop in self.property_mapping and current_value[prop] != value:
+ _LOGGER.info("Update Property: %s: %s -> %s", prop.name, current_value[prop], value)
+ if prop.value in self._dirty_data:
+ self._dirty_data[prop.value].update_time = time.time()
+
+ self.schedule_update(3)
+ return True
+ except Exception as ex:
+ for prop, value in properties.items():
+ if prop in self.property_mapping:
+ self._update_property(prop, current_value[prop])
+ if prop.value in self._dirty_data:
+ del self._dirty_data[prop.value]
+
+ self.schedule_update(1)
+ raise DeviceUpdateFailedException("Set properties failed %s: %s", properties, ex) from None
+
+ self.schedule_update(1)
+ return False
+
+ def get_map_for_render(self, map_data: MapData) -> MapData | None:
"""Makes changes on map data for device related properties for renderer.
Map manager does not need any device property for parsing and storing map data but map renderer does.
For example if device is running but not mopping renderer does not show no mopping areas and this function handles that so renderer does not need device data too.
"""
-
- map_data = self.get_map(map_index)
if map_data:
- if map_data.need_optimization:
- map_data = self._map_manager.optimizer.optimize(
- map_data, self._map_manager.selected_map if map_data.saved_map_status == 2 else None
- )
- map_data.need_optimization = False
+ map_data = self._map_manager.optimizer.optimize(
+ map_data,
+ self._map_manager.selected_map if map_data.saved_map_status == 2 else None,
+ )
- map_data = copy.deepcopy(map_data)
+ render_map_data = copy.deepcopy(map_data)
+ if (
+ self.status.fast_mapping
+ and self.get_property(DreameVacuumProperty.CLEANING_TIME) <= 0
+ and render_map_data.saved_map_status == 2
+ and not render_map_data.empty_map
+ and not map_data.new_map
+ and not map_data.temporary_map
+ ):
+ render_map_data.saved_map_status = 0
+ render_map_data.empty_map = True
+ return render_map_data
- if map_data.optimized_pixel_type is not None:
- map_data.pixel_type = map_data.optimized_pixel_type
- map_data.dimensions = map_data.optimized_dimensions
- if map_data.optimized_charger_position is not None:
- map_data.charger_position = map_data.optimized_charger_position
+ if (
+ not self.capability.lidar_navigation
+ and self.status.docked
+ and not self.status.started
+ and map_data.saved_map_status == 1
+ ):
+ saved_map_data = self._map_manager.selected_map
+ render_map_data.segments = copy.deepcopy(saved_map_data.segments)
+ render_map_data.data = copy.deepcopy(saved_map_data.data)
+ render_map_data.pixel_type = copy.deepcopy(saved_map_data.pixel_type)
+ render_map_data.dimensions = copy.deepcopy(saved_map_data.dimensions)
+ render_map_data.charger_position = copy.deepcopy(saved_map_data.charger_position)
+ render_map_data.no_go_areas = saved_map_data.no_go_areas
+ render_map_data.no_mopping_areas = saved_map_data.no_mopping_areas
+ render_map_data.virtual_walls = saved_map_data.virtual_walls
+ render_map_data.robot_position = render_map_data.charger_position
+ render_map_data.docked = True
+ render_map_data.path = None
+ render_map_data.need_optimization = False
+ render_map_data.saved_map_status = 2
+ render_map_data.optimized_pixel_type = None
+ render_map_data.optimized_charger_position = None
+
+ if render_map_data.optimized_pixel_type is not None:
+ render_map_data.pixel_type = render_map_data.optimized_pixel_type
+ render_map_data.dimensions = render_map_data.optimized_dimensions
+ if render_map_data.optimized_charger_position is not None:
+ render_map_data.charger_position = render_map_data.optimized_charger_position
+ # if not self.status.started and render_map_data.docked and render_map_data.robot_position and render_map_data.charger_position:
+ # render_map_data.charger_position = copy.deepcopy(render_map_data.robot_position)
+ render_map_data.optimized_pixel_type = None
+
+ if render_map_data.combined_pixel_type is not None:
+ render_map_data.pixel_type = render_map_data.combined_pixel_type
+ render_map_data.dimensions = render_map_data.combined_dimensions
+
+ if render_map_data.wifi_map:
+ return render_map_data
+
+ if self.capability.lidar_navigation:
+ ## Second generation vacuum plugins calculates offsets wrong due to a bug which causes objects to be rendered shifted according to map rotation
+ if self.capability.object_shift:
+ offset = render_map_data.dimensions.grid_size
+ if render_map_data.rotation == 0 or render_map_data.rotation == 90:
+ render_map_data.dimensions.left = render_map_data.dimensions.original_left - offset
+ if render_map_data.rotation == 0 or render_map_data.rotation == 270:
+ render_map_data.dimensions.top = render_map_data.dimensions.original_top - offset
+ else:
+ render_map_data.dimensions.left = (
+ render_map_data.dimensions.original_left - render_map_data.dimensions.offset
+ )
+ render_map_data.dimensions.top = (
+ render_map_data.dimensions.original_top - render_map_data.dimensions.offset
+ )
- if (self.status.started and not self.status.zone_cleaning) or map_data.saved_map:
- # Map data always contains last active areas
- map_data.active_areas = None
+ if render_map_data.furniture_version == 2 and self.capability.furnitures_v2:
+ if self.capability.mijia:
+ render_map_data.furniture_version = 5
+ elif self.capability.furnitures_v3:
+ render_map_data.furniture_version = 6
+ else:
+ render_map_data.furniture_version = 4 if self.capability.extended_furnitures else 3
+
+ if not self.capability.cruising:
+ render_map_data.predefined_points = None
+
+ if not self.capability.floor_direction_cleaning:
+ render_map_data.virtual_thresholds = None
+
+ if not self.capability.auto_lds_lifting:
+ render_map_data.low_lying_areas = None
+
+ if self.capability.segment_visibility and render_map_data.hidden_segments is None:
+ render_map_data.hidden_segments = []
+
+ if self.capability.cleangenius_auto:
+ data = None
+ if render_map_data.cleaning_map_data:
+ data = render_map_data.cleaning_map_data
+ elif render_map_data.cleaning_map:
+ data = render_map_data
+
+ if data is not None:
+ data.has_dirty_area = False
+ for y in range(data.dimensions.height):
+ for x in range(data.dimensions.width):
+ if int(data.pixel_type[x, y]) == 250:
+ data.pixel_type[x, y] = 249
+
+ if not render_map_data.history_map:
+ if self.status.started and not (
+ self.status.zone_cleaning
+ or self.status.go_to_zone
+ or (
+ render_map_data.active_areas
+ and self.status.task_status is DreameVacuumTaskStatus.DOCKING_PAUSED
+ )
+ ):
+ # Map data always contains last active areas
+ render_map_data.active_areas = None
- if (self.status.started and not self.status.spot_cleaning) or map_data.saved_map:
- # Map data always contains last active areas
- map_data.active_points = None
+ if self.status.started and not self.status.spot_cleaning:
+ # Map data always contains last active points
+ render_map_data.active_points = None
- if not self.status.segment_cleaning or map_data.saved_map:
- # Map data always contains last active segments
- map_data.active_segments = None
+ if not self.status.segment_cleaning:
+ # Map data always contains last active segments
+ render_map_data.active_segments = None
- if not map_data.saved_map:
- if self.status.started and self.status.sweeping:
- # App does not render no mopping areas when cleaning mode is sweeping
- map_data.no_mopping_areas = None
+ if not self.status.cruising:
+ # Map data always contains last active path points
+ render_map_data.active_cruise_points = None
- if (self.status.zone_cleaning and map_data.active_areas) or (
- self.status.spot_cleaning and map_data.active_points
- ):
- # App does not render segments when zone or spot cleaning
- map_data.segments = None
+ if self.capability.cruising and render_map_data.predefined_points is None:
+ render_map_data.predefined_points = []
else:
- map_data.path = None
+ if not self.capability.cruising:
+ if render_map_data.active_areas and len(render_map_data.active_areas) == 1:
+ area = render_map_data.active_areas[0]
+ size = render_map_data.dimensions.grid_size * 2
+ if area.check_size(size):
+ x = area.x0 + render_map_data.dimensions.grid_size
+ y = area.y0 + render_map_data.dimensions.grid_size
+ render_map_data.task_cruise_points = {
+ 1: Coordinate(
+ x,
+ y,
+ False,
+ 0,
+ )
+ }
+
+ if render_map_data.completed == False:
+ if render_map_data.robot_position:
+ render_map_data.completed = bool(
+ render_map_data.robot_position.x >= x - size
+ and render_map_data.robot_position.x <= x + size
+ and render_map_data.robot_position.y >= y - size
+ and render_map_data.robot_position.y <= y + size
+ )
+ else:
+ render_map_data.completed = True
- if not self.status.customized_cleaning or map_data.saved_map:
- # App does not render customized cleaning settings on saved map list
- map_data.cleanset = None
+ render_map_data.active_areas = None
- # Device currently may not be docked but map data can be old and still showing when robot is docked
- map_data.docked = bool(map_data.docked or self.status.docked)
+ if render_map_data.active_areas or render_map_data.active_points:
+ render_map_data.zone_cleaning = True
- if (
- not map_data.saved_map
- and not self.status.lidar_navigation
- and map_data.saved_map_status == 1
- and map_data.docked
- ):
- # For correct scaling of vslam saved map
- map_data.saved_map_status = 2
+ if render_map_data.customized_cleaning != 1:
+ render_map_data.cleanset = None
+
+ if (
+ render_map_data.cleanup_method is None
+ or render_map_data.cleanup_method != CleanupMethod.CUSTOMIZED_CLEANING
+ ):
+ render_map_data.cleanset = None
+
+ if render_map_data.task_cruise_points:
+ render_map_data.active_cruise_points = render_map_data.task_cruise_points.copy()
+ render_map_data.task_cruise_points = True
+ render_map_data.active_areas = None
+ render_map_data.path = None
+ render_map_data.no_mopping_areas = None
+ render_map_data.cleanset = None
+ if render_map_data.furnitures is not None:
+ render_map_data.furnitures = {}
+
+ if render_map_data.segments and not render_map_data.zone_cleaning:
+ for segment in render_map_data.segments.values():
+ segment.calculate_coords(render_map_data.dimensions)
+
+ if render_map_data.task_cruise_points or (
+ render_map_data.cleanup_method is not None
+ and (
+ render_map_data.cleanup_method == CleanupMethod.CLEANGENIUS
+ and not self.capability.cleangenius_mode
+ )
+ ):
+ render_map_data.sequence = False
+ elif render_map_data.active_segments:
+ order = 1
+ render_map_data.sequence = True
+ for segment_id in list(
+ sorted(
+ render_map_data.segments,
+ key=lambda segment_id: (
+ render_map_data.segments[segment_id].order
+ if render_map_data.segments[segment_id].order
+ else 99
+ ),
+ )
+ ):
+ if (
+ len(render_map_data.active_segments) > 1
+ and render_map_data.segments[segment_id].order
+ and segment_id in render_map_data.active_segments
+ ):
+ render_map_data.segments[segment_id].order = order
+ order = order + 1
+ else:
+ render_map_data.segments[segment_id].order = None
+
+ if self.capability.cleaning_route:
+ for k, v in render_map_data.segments.items():
+ render_map_data.segments[k].custom_mopping_route = None
+
+ return render_map_data
+
+ if not render_map_data.saved_map and not render_map_data.recovery_map:
+ if (
+ render_map_data.no_mopping_areas
+ and self.status.started
+ and (self.status.sweeping or self.status.cruising)
+ ):
+ for area in render_map_data.no_mopping_areas:
+ area.hidden = True
+
+ if not self.status._capability.cruising:
+ if self.status.go_to_zone:
+ render_map_data.active_cruise_points = {
+ 1: Coordinate(
+ self.status.go_to_zone.x,
+ self.status.go_to_zone.y,
+ False,
+ 0,
+ )
+ }
+ render_map_data.active_areas = None
+ render_map_data.path = None
+
+ if render_map_data.active_areas and len(render_map_data.active_areas) == 1:
+ area = render_map_data.active_areas[0]
+ size = render_map_data.dimensions.grid_size * 2
+ if area.check_size(size):
+ if self.status.started and not self.status.go_to_zone and self.status.zone_cleaning:
+ render_map_data.active_cruise_points = {
+ 1: Coordinate(
+ area.x0 + render_map_data.dimensions.grid_size,
+ area.y0 + render_map_data.dimensions.grid_size,
+ False,
+ 0,
+ )
+ }
+ render_map_data.active_areas = None
+ render_map_data.path = None
+
+ if not self.status.go_to_zone and (
+ (self.status.zone_cleaning and render_map_data.active_areas)
+ or (self.status.spot_cleaning and render_map_data.active_points)
+ ):
+ render_map_data.zone_cleaning = True
+
+ # App does not render pet obstacles when pet detection turned off
+ # App does not render stain obstacles when stain avoidance turned off
+ if render_map_data.obstacles:
+ obstacles = copy.deepcopy(render_map_data.obstacles)
+ for k, v in obstacles.items():
+ if (v.type == ObstacleType.PET and self.status.ai_pet_detection == 0) or (
+ self.capability.fluid_detection
+ and (
+ v.type == ObstacleType.LIQUID_STAIN
+ or v.type == ObstacleType.DRIED_STAIN
+ or v.type == ObstacleType.DETECTED_STAIN
+ or v.type == ObstacleType.UNCLEANABLE_STAIN
+ )
+ and not self.status.ai_fluid_detection
+ ):
+ del render_map_data.obstacles[k]
+
+ if render_map_data.furnitures and self.status.ai_furniture_detection == 0:
+ render_map_data.furnitures = {}
+
+ # App adds robot position to paths as last line when map data is line to robot
+ if render_map_data.line_to_robot and render_map_data.path and render_map_data.robot_position:
+ render_map_data.path.append(
+ Path(
+ render_map_data.robot_position.x,
+ render_map_data.robot_position.y,
+ PathType.LINE,
+ )
+ )
- if map_data.charger_position == None and map_data.docked and map_data.robot_position:
- map_data.charger_position = copy.deepcopy(map_data.robot_position)
- if self.status.robot_shape != 2:
- map_data.charger_position.a = map_data.robot_position.a + 180
+ if not self.status.customized_cleaning or self.status.cruising or self.status.cleangenius_cleaning:
+ # App does not render customized cleaning settings on saved map list
+ render_map_data.cleanset = None
+ elif (
+ not render_map_data.saved_map
+ and not render_map_data.recovery_map
+ and render_map_data.cleanset is None
+ and self.status.customized_cleaning
+ and not self.status.cleangenius_cleaning
+ ):
+ DreameVacuumMapDecoder.set_segment_cleanset(render_map_data, {}, self.capability)
+ render_map_data.cleanset = True
+
+ if render_map_data.segments:
+ for segment in render_map_data.segments.values():
+ segment.calculate_coords(render_map_data.dimensions)
+ if not self.status.custom_order or render_map_data.saved_map or render_map_data.recovery_map:
+ render_map_data.sequence = False
+
+ render_map_data.change_mop = self.status.auto_change_mop and (
+ self.status.customized_cleaning
+ or self.status.cleaning_mode is not DreameVacuumCleaningMode.SWEEPING
+ )
- if map_data.saved_map:
- # App does not render robot position on saved map list
- map_data.robot_position = None
+ if self.capability.cleaning_route:
+ for k, v in render_map_data.segments.items():
+ render_map_data.segments[k].custom_mopping_route = None
- # App does not render restricted zones on saved map list
- map_data.walls = None
- map_data.no_go_areas = None
- map_data.no_mopping_areas = None
- map_data.obstacles = None
+ if render_map_data.robot_position:
+ # Device currently may not be docked but map data can be old and still showing when robot is docked
+ render_map_data.docked = bool(render_map_data.docked or self.status.docked)
- elif map_data.charger_position and map_data.docked:
- if not map_data.robot_position:
- map_data.robot_position = copy.deepcopy(map_data.charger_position)
+ if (
+ not self.capability.lidar_navigation
+ and not render_map_data.saved_map
+ and not render_map_data.recovery_map
+ and render_map_data.saved_map_status == 1
+ and render_map_data.docked
+ ):
+ # For correct scaling of vslam saved map
+ render_map_data.saved_map_status = 2
+ if (
+ render_map_data.docked
+ and render_map_data.robot_position
+ and not render_map_data.saved_map
+ and not render_map_data.recovery_map
+ ):
+ if render_map_data.charger_position == None:
+ if not self.status.multi_map:
+ render_map_data.charger_position = copy.deepcopy(render_map_data.robot_position)
+ if (
+ self.capability.robot_type != RobotType.MOPPING
+ and self.capability.robot_type != RobotType.SWEEPING_AND_MOPPING
+ ):
+ render_map_data.charger_position.a = render_map_data.robot_position.a + 180
+ elif (
+ not self.status.docked
+ and not self.status.started
+ and render_map_data.robot_position.x == render_map_data.charger_position.x
+ and render_map_data.robot_position.y == render_map_data.charger_position.y
+ ):
+ render_map_data.docked = False
+ render_map_data.robot_position = None
+
+ if render_map_data.saved_map or render_map_data.recovery_map:
+ render_map_data.active_areas = None
+ render_map_data.active_points = None
+ render_map_data.active_segments = None
+ render_map_data.active_cruise_points = None
+ render_map_data.path = None
+ render_map_data.cleanset = None
+ elif render_map_data.charger_position and render_map_data.docked and not self.status.fast_mapping:
+ if not render_map_data.robot_position:
+ render_map_data.robot_position = copy.deepcopy(render_map_data.charger_position)
+ return render_map_data
return map_data
def get_map(self, map_index: int) -> MapData | None:
@@ -974,8 +3288,10 @@ def get_map(self, map_index: int) -> MapData | None:
def update_map(self) -> None:
"""Trigger a map update.
- This function is used for requesting map data when a image request has been made to renderer"""
+ This function is used for requesting map data when a image request has been made to renderer
+ """
+ self._last_change = time.time()
if self._map_manager:
now = time.time()
if now - self._last_map_request > 120:
@@ -983,13 +3299,10 @@ def update_map(self) -> None:
self._map_manager.set_update_interval(self._map_update_interval)
self._map_manager.schedule_update(0.01)
- def update(self) -> None:
+ def update(self, force_request_properties=False) -> None:
"""Get properties from the device."""
_LOGGER.debug("Device update: %s", self._update_interval)
- if self._update_running:
- return
-
if not self.cloud_connected:
self.connect_cloud()
@@ -997,122 +3310,215 @@ def update(self) -> None:
self.connect_device()
if not self.device_connected:
- raise DeviceUpdateFailedException("Device cannot be reached")
+ raise DeviceUpdateFailedException("Device cannot be reached") from None
- self._update_running = True
+ properties = READ_ONLY_PROPERTIES.copy()
- # Read-only properties
- properties = [
- DreameVacuumProperty.STATE,
- DreameVacuumProperty.ERROR,
- DreameVacuumProperty.BATTERY_LEVEL,
- DreameVacuumProperty.CHARGING_STATUS,
- DreameVacuumProperty.STATUS,
- DreameVacuumProperty.WATER_TANK,
- DreameVacuumProperty.TASK_STATUS,
- DreameVacuumProperty.WARN_STATUS,
- DreameVacuumProperty.RELOCATION_STATUS,
- DreameVacuumProperty.SELF_WASH_BASE_STATUS,
- DreameVacuumProperty.DUST_COLLECTION,
- DreameVacuumProperty.AUTO_EMPTY_STATUS,
- DreameVacuumProperty.CLEANING_PAUSED,
- DreameVacuumProperty.CLEANING_CANCEL,
- DreameVacuumProperty.SCHEDULED_CLEAN,
- DreameVacuumProperty.MOP_IN_STATION,
- DreameVacuumProperty.MOP_PAD_INSTALLED,
- DreameVacuumProperty.NO_WATER_WARNING,
- # DreameVacuumProperty.SAVE_WATER_TIPS,
- ]
+ if self.capability.backup_map:
+ properties.append(DreameVacuumProperty.MAP_BACKUP_STATUS)
now = time.time()
if self.status.active:
# Only changed when robot is active
properties.extend([DreameVacuumProperty.CLEANED_AREA, DreameVacuumProperty.CLEANING_TIME])
- if self._consumable_reset:
+ if self._consumable_change:
# Consumable properties
- properties.extend(
- [
- DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT,
- DreameVacuumProperty.MAIN_BRUSH_LEFT,
- DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT,
- DreameVacuumProperty.SIDE_BRUSH_LEFT,
- DreameVacuumProperty.FILTER_LEFT,
- DreameVacuumProperty.FILTER_TIME_LEFT,
- DreameVacuumProperty.SENSOR_DIRTY_LEFT,
- DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT,
- DreameVacuumProperty.MOP_PAD_LEFT,
- DreameVacuumProperty.MOP_PAD_TIME_LEFT,
- ]
- )
+ properties.extend(CONSUMABLE_PROPERTIES)
+
+ if not self.capability.disable_mop_consumable:
+ properties.extend(
+ [
+ DreameVacuumProperty.MOP_PAD_LEFT,
+ DreameVacuumProperty.MOP_PAD_TIME_LEFT,
+ ]
+ )
+
+ if not self.capability.disable_sensor_cleaning:
+ properties.extend(
+ [
+ DreameVacuumProperty.SENSOR_DIRTY_LEFT,
+ DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT,
+ ]
+ )
if now - self._last_settings_request > 9.5:
self._last_settings_request = now
- # Read/Write properties
- properties.extend(
- [
- DreameVacuumProperty.SUCTION_LEVEL,
- DreameVacuumProperty.RESUME_CLEANING,
- DreameVacuumProperty.CARPET_BOOST,
- DreameVacuumProperty.MOP_CLEANING_REMAINDER,
- DreameVacuumProperty.OBSTACLE_AVOIDANCE,
- DreameVacuumProperty.AI_DETECTION,
- DreameVacuumProperty.DRYING_TIME,
- DreameVacuumProperty.AUTO_ADD_DETERGENT,
- DreameVacuumProperty.CARPET_AVOIDANCE,
- DreameVacuumProperty.CLEANING_MODE,
- DreameVacuumProperty.WATER_ELECTROLYSIS,
- DreameVacuumProperty.INTELLIGENT_RECOGNITION,
- DreameVacuumProperty.AUTO_WATER_REFILLING,
- DreameVacuumProperty.AUTO_MOUNT_MOP,
- DreameVacuumProperty.MOP_WASH_LEVEL,
- DreameVacuumProperty.CUSTOMIZED_CLEANING,
- DreameVacuumProperty.CHILD_LOCK,
- DreameVacuumProperty.CARPET_SENSITIVITY,
- DreameVacuumProperty.TIGHT_MOPPING,
- DreameVacuumProperty.CARPET_RECOGNITION,
- DreameVacuumProperty.SELF_CLEAN,
- DreameVacuumProperty.DND,
- DreameVacuumProperty.DND_START,
- DreameVacuumProperty.DND_END,
- DreameVacuumProperty.DND_TASK,
- DreameVacuumProperty.MULTI_FLOOR_MAP,
- DreameVacuumProperty.VOLUME,
- DreameVacuumProperty.AUTO_DUST_COLLECTING,
- DreameVacuumProperty.AUTO_EMPTY_FREQUENCY,
- DreameVacuumProperty.VOICE_PACKET_ID,
- DreameVacuumProperty.TIMEZONE,
- DreameVacuumProperty.MAP_SAVING,
- DreameVacuumProperty.AUTO_SWITCH_SETTINGS,
- DreameVacuumProperty.QUICK_COMMAND,
- ]
- )
+ if not self._consumable_change and self.status.washing:
+ properties.extend(CONSUMABLE_PROPERTIES)
+
+ if not self.capability.disable_mop_consumable:
+ properties.extend(
+ [
+ DreameVacuumProperty.MOP_PAD_LEFT,
+ DreameVacuumProperty.MOP_PAD_TIME_LEFT,
+ ]
+ )
- if not self.status.self_wash_base_available:
- properties.append(DreameVacuumProperty.WATER_VOLUME)
+ properties.extend(READ_WRITE_PROPERTIES)
if self._map_manager and not self.status.running and now - self._last_map_list_request > 60:
properties.extend([DreameVacuumProperty.MAP_LIST, DreameVacuumProperty.RECOVERY_MAP_LIST])
self._last_map_list_request = time.time()
try:
- self._request_properties(properties)
+ if self._protocol.dreame_cloud and (not self.device_connected or not self.cloud_connected):
+ force_request_properties = True
+
+ if not self._protocol.dreame_cloud or force_request_properties:
+ self._request_properties(properties)
+ elif self.status.map_backup_status:
+ self._request_properties([DreameVacuumProperty.MAP_BACKUP_STATUS])
+ elif self.status.map_recovery_status:
+ self._request_properties([DreameVacuumProperty.MAP_RECOVERY_STATUS])
except Exception as ex:
- self._update_running = False
raise DeviceUpdateFailedException(ex) from None
- if self._consumable_reset:
- self._consumable_reset = False
+ if self._dirty_data:
+ for k, v in copy.deepcopy(self._dirty_data).items():
+ if time.time() - v.update_time >= self._restore_timeout:
+ if v.previous_value is not None:
+ value = self.data.get(k)
+ if value is None or v.value == value:
+ _LOGGER.info(
+ "Property %s Value Restored: %s <- %s",
+ DreameVacuumProperty(k).name,
+ v.previous_value,
+ value,
+ )
+ self.data[k] = v.previous_value
+ if k in self._property_update_callback:
+ for callback in self._property_update_callback[k]:
+ callback(v.previous_value)
+
+ self._property_changed(False)
+ self.schedule_update(1, True)
+ del self._dirty_data[k]
+
+ if self._dirty_auto_switch_data:
+ for k, v in copy.deepcopy(self._dirty_auto_switch_data).items():
+ if time.time() - v.update_time >= self._restore_timeout:
+ if v.previous_value is not None:
+ value = self.auto_switch_data.get(k)
+ ## TODO
+ # if value is None or v.value == value:
+ # _LOGGER.info(
+ # "Property %s Value Restored: %s <- %s",
+ # k,
+ # v.previous_value,
+ # value,
+ # )
+ # self.auto_switch_data[k] = v.previous_value
+ # self._property_changed(False)
+ # self.schedule_update(1, True)
+ del self._dirty_auto_switch_data[k]
+
+ if self._dirty_ai_data:
+ for k, v in copy.deepcopy(self._dirty_ai_data).items():
+ if time.time() - v.update_time >= self._restore_timeout:
+ if v.previous_value is not None:
+ value = self.ai_data.get(k)
+ ## TODO
+ # if value is None or v.value == value:
+ # _LOGGER.info(
+ # "AI Property %s Value Restored: %s <- %s",
+ # k,
+ # v.previous_value,
+ # value,
+ # )
+ # self.ai_data[k] = v.previous_value
+ # self._property_changed(False)
+ # self.schedule_update(1, True)
+ del self._dirty_ai_data[k]
+
+ if self._consumable_change:
+ self._consumable_change = False
if self._map_manager:
+ if (
+ not self.status.started
+ and not self.status.running
+ and self._last_map_change_time is not None
+ and now - self._last_map_change_time > 120
+ ):
+ self._last_map_change_time = None
+ self._map_manager.request_next_map_list()
+ self._map_manager.request_next_recovery_map_list()
self._map_manager.set_update_interval(self._map_update_interval)
self._map_manager.set_device_running(self.status.running, self.status.docked and not self.status.started)
+ # Reset drainage status after 10 minutes
+ if self._draining_complete_time is not None and now - self._draining_complete_time > 600:
+ self._draining_complete_time = None
+ if self.status.draining_complete:
+ self.set_property(DreameVacuumProperty.DRAINAGE_STATUS, 0)
+
if self.cloud_connected:
self._request_cleaning_history()
- self._update_running = False
+ def call_stream_audio_action(self, property: DreameVacuumProperty, parameters=None):
+ return self.call_stream_action(DreameVacuumAction.STREAM_AUDIO, property, parameters)
+
+ def call_stream_video_action(self, property: DreameVacuumProperty, parameters=None):
+ return self.call_stream_action(DreameVacuumAction.STREAM_VIDEO, property, parameters)
+
+ def call_stream_property_action(self, property: DreameVacuumProperty, parameters=None):
+ return self.call_stream_action(DreameVacuumAction.STREAM_PROPERTY, property, parameters)
+
+ def call_stream_action(
+ self,
+ action: DreameVacuumAction,
+ property: DreameVacuumProperty,
+ parameters=None,
+ ):
+ params = {"session": self.status.stream_session}
+ if parameters:
+ params.update(parameters)
+ return self.call_action(
+ action,
+ [
+ {
+ "piid": PIID(property),
+ "value": str(json.dumps(params, separators=(",", ":"))).replace(" ", ""),
+ }
+ ],
+ )
+
+ def call_shortcut_action(self, command: str, parameters={}):
+ return self.call_action(
+ DreameVacuumAction.SHORTCUTS,
+ [
+ {
+ "piid": PIID(DreameVacuumProperty.CLEANING_PROPERTIES),
+ "value": str(
+ json.dumps(
+ {"cmd": command, "params": parameters},
+ separators=(",", ":"),
+ )
+ ).replace(" ", ""),
+ }
+ ],
+ )
+
+ def call_shortcut_action_async(self, callback, command: str, parameters={}):
+ mapping = self.action_mapping[DreameVacuumAction.SHORTCUTS]
+ return self._protocol.action_async(
+ callback,
+ mapping["siid"],
+ mapping["aiid"],
+ [
+ {
+ "piid": PIID(DreameVacuumProperty.CLEANING_PROPERTIES),
+ "value": str(
+ json.dumps(
+ {"cmd": command, "params": parameters},
+ separators=(",", ":"),
+ )
+ ).replace(" ", ""),
+ }
+ ],
+ )
def call_action(self, action: DreameVacuumAction, parameters: dict[str, Any] = None) -> dict[str, Any] | None:
"""Call an action."""
@@ -1123,207 +3529,605 @@ def call_action(self, action: DreameVacuumAction, parameters: dict[str, Any] = N
if "siid" not in mapping or "aiid" not in mapping:
raise InvalidActionException(f"{action} is not an action (missing siid or aiid)")
- if action is not DreameVacuumAction.REQUEST_MAP and action is not DreameVacuumAction.UPDATE_MAP_DATA:
- self.schedule_update(10)
+ if self.status.draining_complete:
+ self.set_property(DreameVacuumProperty.DRAINAGE_STATUS, 0)
+
+ map_action = bool(action is DreameVacuumAction.REQUEST_MAP or action is DreameVacuumAction.UPDATE_MAP_DATA)
+
+ if not map_action:
+ self.schedule_update(10, True)
+
+ cleaning_action = bool(
+ action
+ in [
+ DreameVacuumAction.START,
+ DreameVacuumAction.START_CUSTOM,
+ DreameVacuumAction.PAUSE,
+ DreameVacuumAction.STOP,
+ DreameVacuumAction.CHARGE,
+ ]
+ )
+
+ if not cleaning_action:
+ available_fn = ACTION_AVAILABILITY.get(action.name)
+ if available_fn and not available_fn(self):
+ raise InvalidActionException("Action unavailable")
+ elif self._map_select_time:
+ elapsed = time.time() - self._map_select_time
+ self._map_select_time = None
+ if elapsed < 5:
+ time.sleep(5 - elapsed)
# Reset consumable on memory
if action is DreameVacuumAction.RESET_MAIN_BRUSH:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.MAIN_BRUSH_LEFT, 100)
+ self._update_property(DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT, 300)
elif action is DreameVacuumAction.RESET_SIDE_BRUSH:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.SIDE_BRUSH_LEFT, 100)
+ self._update_property(DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT, 200)
elif action is DreameVacuumAction.RESET_FILTER:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.FILTER_LEFT, 100)
+ self._update_property(DreameVacuumProperty.FILTER_TIME_LEFT, 150)
elif action is DreameVacuumAction.RESET_SENSOR:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.SENSOR_DIRTY_LEFT, 100)
- elif action is DreameVacuumAction.RESET_SECONDARY_FILTER:
- self._consumable_reset = True
- self._update_property(DreameVacuumProperty.SECONDARY_FILTER_LEFT, 100)
+ self._update_property(DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT, 30)
+ elif action is DreameVacuumAction.RESET_TANK_FILTER:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.TANK_FILTER_LEFT, 100)
+ self._update_property(DreameVacuumProperty.TANK_FILTER_TIME_LEFT, 30)
elif action is DreameVacuumAction.RESET_MOP_PAD:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.MOP_PAD_LEFT, 100)
+ self._update_property(DreameVacuumProperty.MOP_PAD_TIME_LEFT, 80)
elif action is DreameVacuumAction.RESET_SILVER_ION:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.SILVER_ION_LEFT, 100)
+ self._update_property(DreameVacuumProperty.SILVER_ION_TIME_LEFT, 365)
elif action is DreameVacuumAction.RESET_DETERGENT:
- self._consumable_reset = True
+ self._consumable_change = True
self._update_property(DreameVacuumProperty.DETERGENT_LEFT, 100)
+ self._update_property(DreameVacuumProperty.DETERGENT_TIME_LEFT, 18)
+ elif action is DreameVacuumAction.RESET_SQUEEGEE:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.SQUEEGEE_LEFT, 100)
+ self._update_property(DreameVacuumProperty.SQUEEGEE_TIME_LEFT, 100)
+ elif action is DreameVacuumAction.RESET_ONBOARD_DIRTY_WATER_TANK:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_LEFT, 100)
+ self._update_property(DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_TIME_LEFT, 30)
+ elif action is DreameVacuumAction.RESET_DIRTY_WATER_CHANNEL:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_LEFT, 100)
+ self._update_property(DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_TIME_LEFT, 100)
+ elif action is DreameVacuumAction.RESET_DEODORIZER:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.DEODORIZER_LEFT, 100)
+ self._update_property(DreameVacuumProperty.DEODORIZER_TIME_LEFT, 180)
+ elif action is DreameVacuumAction.RESET_WHEEL:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.WHEEL_DIRTY_LEFT, 100)
+ self._update_property(DreameVacuumProperty.WHEEL_DIRTY_TIME_LEFT, 30)
+ elif action is DreameVacuumAction.RESET_SCALE_INHIBITOR:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.SCALE_INHIBITOR_LEFT, 100)
+ self._update_property(DreameVacuumProperty.SCALE_INHIBITOR_TIME_LEFT, 1095)
+ elif action is DreameVacuumAction.RESET_FLUFFING_ROLLER:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_LEFT, 100)
+ self._update_property(DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_TIME_LEFT, 30)
+ elif action is DreameVacuumAction.RESET_ROLLER_MOP_FILTER:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_LEFT, 100)
+ self._update_property(DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_TIME_LEFT, 100)
+ elif action is DreameVacuumAction.RESET_WATER_OUTLET_FILTER:
+ self._consumable_change = True
+ self._update_property(DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_LEFT, 100)
+ self._update_property(DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_TIME_LEFT, 30)
+
+ elif action is DreameVacuumAction.START_AUTO_EMPTY:
+ self._update_property(
+ DreameVacuumProperty.AUTO_EMPTY_STATUS,
+ DreameVacuumAutoEmptyStatus.ACTIVE.value,
+ )
# Update listeners
- if (
- action is DreameVacuumAction.START
- or action is DreameVacuumAction.START_CUSTOM
- or action is DreameVacuumAction.STOP
- or action is DreameVacuumAction.CHARGE
- or action is DreameVacuumAction.UPDATE_MAP_DATA
- or self._consumable_reset
- ):
- self._property_changed()
+ if cleaning_action or self._consumable_change:
+ self._property_changed(False)
try:
result = self._protocol.action(mapping["siid"], mapping["aiid"], parameters)
- if result and result.get("code") != 0:
- result = None
except Exception as ex:
_LOGGER.error("Send action failed %s: %s", action.name, ex)
- self.schedule_update(1)
+ self.schedule_update(1, True)
return
- if result:
- _LOGGER.info("Send action %s", action.name)
+ # Schedule update for retrieving new properties after action sent
+ self.schedule_update(6, bool(not map_action and self._protocol.dreame_cloud))
+ if result and isinstance(result, list):
+ result = result[0]
+ if result and result.get("code") == 0:
+ _LOGGER.info("Send action %s %s", action.name, parameters)
self._last_change = time.time()
- if action is not DreameVacuumAction.REQUEST_MAP and action is not DreameVacuumAction.UPDATE_MAP_DATA:
+ if not map_action:
self._last_settings_request = 0
+ else:
+ _LOGGER.error("Send action failed %s (%s): %s", action.name, parameters, result)
+ self.schedule_update(1, True)
+ return
- # Schedule update for retrieving new properties after action sent
- self.schedule_update(3)
return result
- def send_command(self, command: str, parameters: dict[str, Any]) -> dict[str, Any] | None:
+ def send_command(self, command: str, parameters: dict[str, Any] = None) -> dict[str, Any] | None:
"""Send a raw command to the device. This is mostly useful when trying out
commands which are not implemented by a given device instance. (Not likely)"""
- if command == "" or parameters is None:
- raise InvalidActionException("Invalid Command: (%s).", command)
+ if command == "":
+ raise InvalidActionException(f"Invalid Command: ({command}).")
- self.schedule_update(10)
- self._protocol.send(command, parameters, 1)
- self.schedule_update(2)
+ self.schedule_update(10, True)
+ response = self._protocol.send(command, parameters, 3)
+ if response:
+ _LOGGER.info("Send command response: %s", response)
+ self.schedule_update(2, True)
+
+ def set_volume(self, volume: int) -> bool:
+ """Set volume."""
+ result = self.set_property(DreameVacuumProperty.VOLUME, volume)
+ if result:
+ self.call_action(DreameVacuumAction.TEST_SOUND)
+ return result
def set_suction_level(self, suction_level: int) -> bool:
"""Set suction level."""
+ if self.status.cruising:
+ raise InvalidActionException("Cannot set suction level when cruising")
+
if self.status.started and (
self.status.customized_cleaning and not (self.status.zone_cleaning or self.status.spot_cleaning)
):
raise InvalidActionException("Cannot set suction level when customized cleaning is enabled")
- return self.set_property(DreameVacuumProperty.SUCTION_LEVEL, int(suction_level))
+ return self._update_suction_level(suction_level)
def set_cleaning_mode(self, cleaning_mode: int) -> bool:
"""Set cleaning mode."""
- if self.status.started:
- raise InvalidActionException("Cannot set cleaning mode while vacuum is running")
+ if self.status.cleaning_mode is None:
+ raise InvalidActionException("Cleaning mode is not supported on this device")
+
+ if self.status.cruising:
+ raise InvalidActionException("Cannot set cleaning mode when cruising")
+
+ if self.status.draining:
+ raise InvalidActionException("Cannot set cleaning mode when draining")
+
+ if self.status.scheduled_clean or self.status.shortcut_task:
+ raise InvalidActionException("Cannot set cleaning mode when scheduled cleaning or shortcut task")
+
+ if (
+ self.status.started
+ and self.capability.custom_cleaning_mode
+ and (self.status.customized_cleaning and not (self.status.zone_cleaning or self.status.spot_cleaning))
+ ):
+ raise InvalidActionException("Cannot set cleaning mode when customized cleaning is enabled")
+
+ cleaning_mode = int(cleaning_mode)
+ if cleaning_mode == DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING.value and (
+ not self.capability.mopping_after_sweeping
+ or (
+ self.status.started
+ and self.status.cleaning_mode is not DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
+ )
+ ):
+ raise InvalidActionException("Cannot set mopping after sweeping")
- if not self.status.auto_mount:
- if cleaning_mode is DreameVacuumCleaningMode.SWEEPING.value:
- if self.status.water_tank_or_mop_installed and not self.status.mop_pad_lifting_available:
- if self.status.self_wash_base_available:
+ if not self.status.auto_mount_mop or not self.status.mop_in_station:
+ if cleaning_mode == DreameVacuumCleaningMode.SWEEPING.value:
+ if self.status.water_tank_or_mop_installed and not self.capability.mop_pad_lifting:
+ if self.capability.self_wash_base:
raise InvalidActionException("Cannot set sweeping while mop pads are installed")
else:
raise InvalidActionException("Cannot set sweeping while water tank is installed")
elif not self.status.water_tank_or_mop_installed:
- if self.status.self_wash_base_available:
+ if self.capability.self_wash_base:
raise InvalidActionException("Cannot set mopping while mop pads are not installed")
else:
raise InvalidActionException("Cannot set mopping while water tank is not installed")
- if self.status.self_wash_base_available:
- values = DreameVacuumDevice.split_group_value(
- self.get_property(DreameVacuumProperty.CLEANING_MODE), self.status.mop_pad_lifting_available
- )
- if values and len(values) == 3:
- if self.status.mop_pad_lifting_available:
- if cleaning_mode == 2:
- values[0] = 0
- elif cleaning_mode == 0:
- values[0] = 2
- else:
- values[0] = cleaning_mode
- elif cleaning_mode == 2:
- values[0] = 0
+ if self.status.started and not PROPERTY_AVAILABILITY[DreameVacuumProperty.CLEANING_MODE.name](self):
+ raise InvalidActionException("Cleaning mode unavailable")
- cleaning_mode = DreameVacuumDevice.combine_group_value(values)
- elif self.status.mop_pad_lifting_available:
- if cleaning_mode == 2:
- cleaning_mode = 0
- elif cleaning_mode == 0:
- cleaning_mode = 2
+ return self._update_cleaning_mode(cleaning_mode)
+
+ def set_self_clean_area(self, self_clean_area: int) -> bool:
+ """Set self clean area."""
+ if self.capability.self_wash_base and (
+ not self.capability.self_clean_frequency
+ or not (self.status.self_clean_by_time or self.status.self_clean_intelligent)
+ ):
+ return self.set_self_clean_value(self_clean_area)
+
+ def set_self_clean_time(self, self_clean_time: int) -> bool:
+ """Set self clean time."""
+ if self.capability.self_wash_base and self.capability.self_clean_frequency and self.status.self_clean_by_time:
+ return self.set_self_clean_value(self_clean_time)
+
+ def set_self_clean_value(self, self_clean_value: int) -> bool:
+ """Set self clean value."""
+ if self.capability.self_wash_base:
+ current_self_clean_value = self.status.self_clean_value
+ if self._update_self_clean_value(self_clean_value):
+ if self_clean_value and self_clean_value != current_self_clean_value:
+ if self.status.self_clean_by_time:
+ self.status.previous_self_clean_time = self_clean_value
+ else:
+ self.status.previous_self_clean_area = self_clean_value
+ return True
+ return False
- return self.set_property(DreameVacuumProperty.CLEANING_MODE, int(cleaning_mode))
+ def set_mop_clean_frequency(self, mop_clean_frequency: int) -> bool:
+ """Set mop clean frequency."""
+ if self.capability.self_wash_base and self.capability.mop_clean_frequency:
+ return self.set_self_clean_value(mop_clean_frequency)
def set_mop_pad_humidity(self, mop_pad_humidity: int) -> bool:
"""Set mop pad humidity."""
- if self.status.self_wash_base_available:
+ if self.capability.self_wash_base:
+ if self.status.cruising:
+ raise InvalidActionException("Cannot set mop pad humidity when cruising")
+
if self.status.started and (
self.status.customized_cleaning and not (self.status.zone_cleaning or self.status.spot_cleaning)
):
raise InvalidActionException("Cannot set mop pad humidity when customized cleaning is enabled")
-
- values = DreameVacuumDevice.split_group_value(
- self.get_property(DreameVacuumProperty.CLEANING_MODE), self.status.mop_pad_lifting_available
- )
- if values and len(values) == 3:
- values[2] = mop_pad_humidity
- return self.set_property(
- DreameVacuumProperty.CLEANING_MODE, DreameVacuumDevice.combine_group_value(values)
- )
+ return self._update_water_level(mop_pad_humidity)
+ return False
def set_water_volume(self, water_volume: int) -> bool:
"""Set water volume."""
- if not self.status.self_wash_base_available:
+ if not self.capability.self_wash_base:
+ if self.status.cruising:
+ raise InvalidActionException("Cannot set water level when cruising")
+
if self.status.started and (
self.status.customized_cleaning and not (self.status.zone_cleaning or self.status.spot_cleaning)
):
raise InvalidActionException("Cannot set water volume when customized cleaning is enabled")
- return self.set_property(DreameVacuumProperty.WATER_VOLUME, int(water_volume))
+ return self._update_water_level(water_volume)
+ return False
+
+ def set_wetness_level(self, wetness_level: int) -> bool:
+ """Set wetness level."""
+ if self.capability.wetness:
+ if self.status.started and (
+ self.status.customized_cleaning and not (self.status.zone_cleaning or self.status.spot_cleaning)
+ ):
+ raise InvalidActionException("Cannot set wetness level when customized cleaning is enabled")
+
+ if self.capability.self_wash_base and self.capability.wetness_level:
+ if (
+ wetness_level > 26
+ and self.status.self_clean_value > 20
+ and (
+ not self.capability.self_clean_frequency
+ or (
+ self.status.self_clean_frequency == DreameVacuumSelfCleanFrequency.BY_TIME
+ or self.status.self_clean_frequency == DreameVacuumSelfCleanFrequency.BY_ROOM
+ )
+ )
+ ):
+ self.set_self_clean_value(20)
+
+ return self.set_property(DreameVacuumProperty.WETNESS_LEVEL, int(wetness_level))
+ return False
+
+ def set_dnd_tasks(self, enabled: bool, dnd_start: str, dnd_end: str) -> bool:
+ """Set do not disturb tasks"""
+ if dnd_start is None or dnd_start == "":
+ dnd_start = "22:00"
+
+ if dnd_end is None or dnd_end == "":
+ dnd_end = "08:00"
- def set_dnd_enabled(self, dnd_enabled: bool) -> bool:
+ time_pattern = re.compile("([0-1][0-9]|2[0-3]):[0-5][0-9]$")
+ if not re.match(time_pattern, dnd_start):
+ raise InvalidValueException("DnD start time is not valid: (%s).", dnd_start)
+ if not re.match(time_pattern, dnd_end):
+ raise InvalidValueException("DnD end time is not valid: (%s).", dnd_end)
+ if dnd_start == dnd_end:
+ raise InvalidValueException(
+ "DnD Start time must be different from DnD end time: (%s == %s).",
+ dnd_start,
+ dnd_end,
+ )
+
+ if self.status.dnd_tasks is None:
+ self.status.dnd_tasks = []
+
+ if len(self.status.dnd_tasks) == 0:
+ self.status.dnd_tasks.append(DNDTask(1, enabled, dnd_start, dnd_end, 127, 0))
+ else:
+ self.status.dnd_tasks[0].enabled = enabled
+ self.status.dnd_tasks[0].start = dnd_start
+ self.status.dnd_tasks[0].end = dnd_end
+
+ return self.set_property(
+ DreameVacuumProperty.DND_TASK,
+ str(
+ json.dumps(
+ [
+ {
+ "id": task.id,
+ "en": task.enabled,
+ "st": task.start,
+ "et": task.end,
+ "wk": task.repeats,
+ "ss": task.ss,
+ }
+ for task in self.status.dnd_tasks
+ ],
+ separators=(",", ":"),
+ )
+ ).replace(" ", ""),
+ )
+
+ def set_dnd(self, enabled: bool) -> bool:
"""Set do not disturb function"""
- return self.set_property(DreameVacuumProperty.DND, bool(dnd_enabled))
+ return (
+ self.set_property(DreameVacuumProperty.DND, bool(enabled))
+ if not self.capability.dnd_task
+ else self.set_dnd_tasks(bool(enabled), self.status.dnd_start, self.status.dnd_end)
+ )
def set_dnd_start(self, dnd_start: str) -> bool:
"""Set do not disturb function"""
- time_pattern = re.compile("([0-1][0-9]|2[0-3]):[0-5][0-9]$")
- if not re.match(time_pattern, dnd_start):
- raise InvalidValueException("DND start time is not valid: (%s).", dnd_start)
- return self.set_property(DreameVacuumProperty.DND_START, dnd_start)
+ return (
+ self.set_property(DreameVacuumProperty.DND_START, dnd_start)
+ if not self.capability.dnd_task
+ else self.set_dnd_tasks(self.status.dnd, str(dnd_start), self.status.dnd_end)
+ )
def set_dnd_end(self, dnd_end: str) -> bool:
"""Set do not disturb function"""
- time_pattern = re.compile("([0-1][0-9]|2[0-3]):[0-5][0-9]$")
- if not re.match(time_pattern, dnd_end):
- raise InvalidValueException("DND end time is not valid: (%s).", dnd_end)
- return self.set_property(DreameVacuumProperty.DND_END, dnd_end)
+ if not self.capability.dnd_task:
+ return self.set_property(DreameVacuumProperty.DND_END, dnd_end)
+ return self.set_dnd_tasks(self.status.dnd, self.status.dnd_start, str(dnd_end))
- def set_self_clean_area(self, self_clean_area: int) -> bool:
- """Set self clean area."""
- if self.status.self_wash_base_available:
- values = DreameVacuumDevice.split_group_value(
- self.get_property(DreameVacuumProperty.CLEANING_MODE), self.status.mop_pad_lifting_available
- )
- if values and len(values) == 3:
- values[1] = self_clean_area
- return self.set_property(
- DreameVacuumProperty.CLEANING_MODE, DreameVacuumDevice.combine_group_value(values)
+ def set_off_peak_charging_config(self, enabled: bool, start: str, end: str) -> bool:
+ """Set of peak charging config"""
+ if start is None or start == "":
+ start = "22:00"
+
+ if end is None or end == "":
+ end = "08:00"
+
+ time_pattern = re.compile("([0-1][0-9]|2[0-3]):[0-5][0-9]$")
+ if not re.match(time_pattern, start):
+ raise InvalidValueException("Start time is not valid: (%s).", start)
+ if not re.match(time_pattern, end):
+ raise InvalidValueException("End time is not valid: (%s).", end)
+ if start == end:
+ raise InvalidValueException("Start time must be different from end time: (%s == %s).", start, end)
+
+ self.status.off_peak_charging_config = {
+ "enable": enabled,
+ "startTime": start,
+ "endTime": end,
+ }
+ return self.set_property(
+ DreameVacuumProperty.OFF_PEAK_CHARGING,
+ str(json.dumps(self.status.off_peak_charging_config, separators=(",", ":"))).replace(" ", ""),
+ )
+
+ def set_off_peak_charging(self, enabled: bool) -> bool:
+ """Set off peak charging function"""
+ return self.set_off_peak_charging_config(
+ bool(enabled),
+ self.status.off_peak_charging_start,
+ self.status.off_peak_charging_end,
+ )
+
+ def set_off_peak_charging_start(self, off_peak_charging_start: str) -> bool:
+ """Set off peak charging function"""
+ return self.set_off_peak_charging_config(
+ self.status.off_peak_charging,
+ str(off_peak_charging_start),
+ self.status.off_peak_charging_end,
+ )
+
+ def set_off_peak_charging_end(self, off_peak_charging_end: str) -> bool:
+ """Set off peak charging function"""
+ return self.set_off_peak_charging_config(
+ self.status.off_peak_charging,
+ self.status.off_peak_charging_start,
+ str(off_peak_charging_end),
+ )
+
+ def set_voice_assistant_language(self, voice_assistant_language: str) -> bool:
+ if (
+ self.get_property(DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE) is None
+ or voice_assistant_language is None
+ or len(voice_assistant_language) < 2
+ or voice_assistant_language.upper() not in DreameVacuumVoiceAssistantLanguage.__members__
+ ):
+ raise InvalidActionException(f"Voice assistant language ({voice_assistant_language}) is not supported")
+ return self.set_property(
+ DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE,
+ DreameVacuumVoiceAssistantLanguage[voice_assistant_language.upper()],
+ )
+
+ def set_washing_mode(self, washing_mode: int) -> bool:
+ if self.capability.smart_mop_washing:
+ properties = {}
+ if washing_mode < 3:
+ if self.status.ultra_clean_mode:
+ self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.ULTRA_CLEAN_MODE, 0, False)
+ if washing_mode != self.status.mop_wash_level.value:
+ properties[DreameVacuumProperty.MOP_WASH_LEVEL] = washing_mode
+ elif self.capability.ultra_clean_mode:
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.ULTRA_CLEAN_MODE,
+ 1 if self.status.auto_water_refilling_enabled else 0,
+ False,
)
+ if self.status.smart_mop_washing:
+ properties[DreameVacuumProperty.SMART_MOP_WASHING] = 0
+
+ self.set_properties(properties)
+
+ def set_mop_wash_level(self, mop_wash_level: int) -> bool:
+ if not self.capability.smart_mop_washing:
+ if self.capability.ultra_clean_mode and (
+ self.status.ultra_clean_mode or not self.status.auto_water_refilling_enabled
+ ):
+ self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.ULTRA_CLEAN_MODE, 0, False)
+ self.set_property(DreameVacuumProperty.MOP_WASH_LEVEL, mop_wash_level)
+
+ def set_drying_time(self, drying_time: int) -> bool:
+ properties = {DreameVacuumProperty.DRYING_TIME: drying_time}
+ if self.capability.silent_drying and self.status.silent_drying:
+ properties[DreameVacuumProperty.SILENT_DRYING] = 0
+ self.set_properties(properties)
+
+ def delete_scheduled_task(self, schedule_id) -> dict[str, Any] | None:
+ """Delete a scheduled task."""
+ found = False
+ for schedule in self.status.schedule:
+ if str(schedule.id) == str(schedule_id):
+ found = True
+ break
+
+ if not found:
+ raise InvalidActionException(f"Schedule not found! (%s)", schedule_id)
+
+ schedule_list = self.get_property(DreameVacuumProperty.SCHEDULE)
+ if schedule_list and schedule_list != "":
+ tasks = schedule_list.split(";")
+ schedule = ""
+ for task in tasks:
+ props = task.split("-")
+ if props[0] != str(schedule_id):
+ if len(schedule) > 1:
+ schedule = f"{schedule};"
+ schedule = f"{schedule}{task}"
+ self.set_property(DreameVacuumProperty.SCHEDULE, schedule)
+
+ response = self.call_action(
+ DreameVacuumAction.DELETE_SCHEDULED_TASK,
+ [
+ {
+ "piid": PIID(DreameVacuumProperty.SCHEDULE_ID, self.property_mapping),
+ "value": schedule_id,
+ }
+ ]
+ )
+ self.schedule_update(3, True)
+ if not response or response.get("code") != 0:
+ self.set_property(DreameVacuumProperty.SCHEDULE, schedule_list)
+ return response
+
+ def delete_dnd_task(self, dnd_id) -> dict[str, Any] | None:
+ """Delete a dnd task."""
+ found = False
+ for dnd in self.status.dnd_tasks:
+ if str(dnd.id) == str(dnd_id):
+ found = True
+ break
+
+ if not found:
+ raise InvalidActionException(f"DnD task not found! (%s)", dnd_id)
+
+ dnd_list = self.get_property(DreameVacuumProperty.DND_TASK)
+ if dnd_list and dnd_list != "":
+ self.set_property(
+ DreameVacuumProperty.DND_TASK,
+ str(json.dumps([task for task in json.loads(dnd_list) if str(task.get("id")) != str(dnd_id)], separators=(",", ":"))).replace(" ", "")
+ )
+
+ response = self.call_action(
+ DreameVacuumAction.DELETE_DND_TASK,
+ [
+ {
+ "piid": PIID(DreameVacuumProperty.DND_TASK, self.property_mapping),
+ "value": dnd_id,
+ }
+ ],
+ )
+ self.schedule_update(3, True)
+ if not response or response.get("code") != 0:
+ self.set_property(DreameVacuumProperty.DND_TASK, dnd_list)
+ return response
+
def locate(self) -> dict[str, Any] | None:
"""Locate the vacuum cleaner."""
return self.call_action(DreameVacuumAction.LOCATE)
def start(self) -> dict[str, Any] | None:
"""Start or resume the cleaning task."""
- self.schedule_update(10)
-
if self.status.fast_mapping_paused:
+ self._update_status(DreameVacuumTaskStatus.FAST_MAPPING, DreameVacuumStatus.FAST_MAPPING)
return self.start_custom(DreameVacuumStatus.FAST_MAPPING.value)
+ if self.status.returning_paused:
+ return self.return_to_base()
+
+ if self.status.returning_to_wash_paused:
+ return self.start_washing()
+
+ if self.capability.cruising:
+ if self.status.cruising_paused:
+ return self.start_custom(self.status.status.value)
+ elif not self.status.paused:
+ self._restore_go_to_zone()
+
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException("Cannot start cleaning while draining or self repairing/testing")
+
+ self.schedule_update(10, True)
+
+ if self._map_manager and not self.status.started:
+ self._map_manager.editor.clear_path()
+
if not self.status.started:
self._update_status(DreameVacuumTaskStatus.AUTO_CLEANING, DreameVacuumStatus.CLEANING)
+ elif (
+ self.status.paused
+ and not self.status.cleaning_paused
+ and not self.status.cruising
+ and not self.status.scheduled_clean
+ ):
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.CLEANING.value)
+ if self.status.task_status is not DreameVacuumTaskStatus.COMPLETED:
+ new_state = DreameVacuumState.SWEEPING
+ if self.status.cleaning_mode is DreameVacuumCleaningMode.MOPPING:
+ new_state = DreameVacuumState.MOPPING
+ elif self.status.cleaning_mode is DreameVacuumCleaningMode.SWEEPING_AND_MOPPING:
+ new_state = DreameVacuumState.SWEEPING_AND_MOPPING
+ self._update_property(DreameVacuumProperty.STATE, new_state.value)
if self._map_manager:
self._map_manager.editor.refresh_map()
+
return self.call_action(DreameVacuumAction.START)
def start_custom(self, status, parameters: dict[str, Any] = None) -> dict[str, Any] | None:
"""Start custom cleaning task."""
- if status != DreameVacuumStatus.FAST_MAPPING.value and self.status.fast_mapping:
+ if not self.capability.cruising and status != DreameVacuumStatus.ZONE_CLEANING.value:
+ self._restore_go_to_zone()
+
+ if status is not DreameVacuumStatus.FAST_MAPPING.value and self.status.fast_mapping:
raise InvalidActionException("Cannot start cleaning while fast mapping")
- payload = [{"piid": PIID(DreameVacuumProperty.STATUS, self.property_mapping), "value": status}]
+ payload = [
+ {
+ "piid": PIID(DreameVacuumProperty.STATUS, self.property_mapping),
+ "value": status,
+ }
+ ]
if parameters is not None:
payload.append(
@@ -1337,36 +4141,86 @@ def start_custom(self, status, parameters: dict[str, Any] = None) -> dict[str, A
def stop(self) -> dict[str, Any] | None:
"""Stop the vacuum cleaner."""
- self.schedule_update(10)
-
if self.status.fast_mapping:
return self.return_to_base()
+ if (
+ self.status.station_cleaning
+ and self.capability.washboard_cleaning_status
+ and self._get_property(DreameVacuumProperty.WASHBOARD_CLEANING_STATUS) == 1
+ ):
+ self._update_property(DreameVacuumProperty.WASHBOARD_CLEANING_STATUS, 0)
+ return self.call_action(DreameVacuumAction.CHARGE)
+
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot stop while draining or self repairing/testing")
+
+ self.schedule_update(10, True)
+
+ response = None
+ if self.status.go_to_zone:
+ response = self.call_action(DreameVacuumAction.STOP)
+
if self.status.started:
+ self._update_status(DreameVacuumTaskStatus.COMPLETED, DreameVacuumStatus.STANDBY)
+
# Clear active segments on current map data
if self._map_manager:
+ if self.status.go_to_zone:
+ self._map_manager.editor.set_active_areas([])
+ self._map_manager.editor.set_cruise_points([])
self._map_manager.editor.set_active_segments([])
+ elif self.status.drying:
+ return self.stop_drying()
+
+ if response:
+ return response
- self._update_status(DreameVacuumTaskStatus.COMPLETED, DreameVacuumStatus.STANDBY)
return self.call_action(DreameVacuumAction.STOP)
def pause(self) -> dict[str, Any] | None:
"""Pause the cleaning task."""
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot pause while draining or self repairing/testing")
+
+ self.schedule_update(10, True)
+
+ if not self.status.started and self.status.washing:
+ return self.pause_washing()
+
if not self.status.paused and self.status.started:
- self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.PAUSED.value)
+ if self.status.cruising and not self.capability.cruising:
+ self._update_property(
+ DreameVacuumProperty.STATE,
+ DreameVacuumState.MONITORING_PAUSED.value,
+ )
+ else:
+ self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.PAUSED.value)
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.PAUSED.value)
+ if self.status.go_to_zone:
+ self._update_property(
+ DreameVacuumProperty.TASK_STATUS,
+ DreameVacuumTaskStatus.CRUISING_POINT_PAUSED.value,
+ )
return self.call_action(DreameVacuumAction.PAUSE)
def return_to_base(self) -> dict[str, Any] | None:
"""Set the vacuum cleaner to return to the dock."""
- if self.status.started:
+ if self._map_manager:
+ self._map_manager.editor.set_cruise_points([])
+
+ # if self.status.started:
+ if not self.status.docked:
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.BACK_HOME.value)
self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.RETURNING.value)
- # Clear active segments on current map data
- # if self._map_manager:
- # self._map_manager.editor.set_active_segments([])
- if self._map_manager:
- self._map_manager.editor.refresh_map()
+ # Clear active segments on current map data
+ # if self._map_manager:
+ # self._map_manager.editor.set_active_segments([])
+
+ if not self.capability.cruising:
+ self._restore_go_to_zone()
return self.call_action(DreameVacuumAction.CHARGE)
def start_pause(self) -> dict[str, Any] | None:
@@ -1379,147 +4233,302 @@ def start_pause(self) -> dict[str, Any] | None:
return self.start()
return self.pause()
- def clean_zone(self, zones: list[int] | list[list[int]], cleaning_times: int) -> dict[str, Any] | None:
+ def clean_zone(
+ self,
+ zones: list[int] | list[list[int]],
+ cleaning_times: int | list[int],
+ suction_level: int | list[int],
+ water_volume: int | list[int],
+ ) -> dict[str, Any] | None:
"""Clean selected area."""
- self.schedule_update(10)
- if zones and not isinstance(zones[0], list):
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot start cleaning while draining or self repairing/testing")
+
+ if not isinstance(zones, list) or not zones:
+ raise InvalidActionException(f"Invalid zone coordinates: %s", zones)
+
+ if not isinstance(zones[0], list):
zones = [zones]
- suction_level = self.status.suction_level.value
- if self.status.self_wash_base_available:
- water_volume = self.status.mop_pad_humidity.value
+ if suction_level is None or suction_level == "":
+ suction_level = self.status.suction_level.value
else:
+ self._update_suction_level(suction_level[0] if isinstance(suction_level, list) else suction_level)
+
+ if water_volume is None or water_volume == "":
water_volume = self.status.water_volume.value
+ else:
+ self._update_water_level(int(water_volume[0] if isinstance(water_volume, list) else water_volume))
- cleanlist = []
+ if cleaning_times is None or cleaning_times == "":
+ cleaning_times = 1
+
+ areas = []
+ index = 0
for zone in zones:
- cleanlist.append(
+ if not isinstance(zone, list) or len(zone) != 4:
+ raise InvalidActionException(f"Invalid zone coordinates: %s", zone)
+
+ if isinstance(cleaning_times, list):
+ if index < len(cleaning_times):
+ repeat = cleaning_times[index]
+ else:
+ repeat = 1
+ else:
+ repeat = cleaning_times
+
+ if isinstance(suction_level, list):
+ if index < len(suction_level):
+ fan = suction_level[index]
+ else:
+ fan = self.status.suction_level.value
+ else:
+ fan = suction_level
+
+ if isinstance(water_volume, list):
+ if index < len(water_volume):
+ water = water_volume[index]
+ else:
+ if self.capability.self_wash_base:
+ water = self.status.mop_pad_humidity
+ else:
+ water = self.status.water_volume.value
+ else:
+ water = water_volume
+
+ index = index + 1
+
+ x_coords = sorted([zone[0], zone[2]])
+ y_coords = sorted([zone[1], zone[3]])
+
+ size = (self.status.current_map.dimensions.grid_size * 2) if self.status.current_map else 100
+ w = (x_coords[1] - x_coords[0]) / size
+ h = (y_coords[1] - y_coords[0]) / size
+
+ if h <= 1.0 or w <= 1.0:
+ raise InvalidActionException(f"Zone {index} is smaller than minimum zone size ({h}, {w})")
+
+ areas.append(
[
int(round(zone[0])),
int(round(zone[1])),
int(round(zone[2])),
int(round(zone[3])),
- cleaning_times,
- suction_level,
- water_volume,
+ max(1, repeat),
+ fan,
+ water,
]
)
+ self.schedule_update(10, True)
+ if not self.capability.cruising:
+ self._restore_go_to_zone()
+
+ if self.status.cleangenius_cleaning:
+ self._previous_cleangenius = self.get_property(DreameVacuumAutoSwitchProperty.CLEANGENIUS)
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.CLEANGENIUS, DreameVacuumCleanGenius.OFF.value, False
+ )
+ else:
+ self._previous_cleangenius = None
+
if not self.status.started or self.status.paused:
if self._map_manager:
# Set active areas on current map data is implemented on the app
+ if not self.status.started:
+ self._map_manager.editor.clear_path()
self._map_manager.editor.set_active_areas(zones)
self._update_status(DreameVacuumTaskStatus.ZONE_CLEANING, DreameVacuumStatus.ZONE_CLEANING)
return self.start_custom(
DreameVacuumStatus.ZONE_CLEANING.value,
- str(json.dumps({"areas": cleanlist}, separators=(",", ":"))).replace(" ", ""),
+ str(json.dumps({"areas": areas}, separators=(",", ":"))).replace(" ", ""),
)
def clean_segment(
self,
selected_segments: int | list[int],
- cleaning_times: int | list[int],
- suction_level: int | list[int],
- water_volume: int | list[int],
+ cleaning_times: int | list[int] | None = None,
+ suction_level: int | list[int] | None = None,
+ water_volume: int | list[int] | None = None,
+ timestamp: int | None = None,
) -> dict[str, Any] | None:
"""Clean selected segment using id."""
- self.schedule_update(10)
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot start cleaning while draining or self repairing/testing")
+
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot clean segments on current map")
+
if not isinstance(selected_segments, list):
selected_segments = [selected_segments]
- if not suction_level or suction_level == "":
+ if suction_level is None or suction_level == "":
suction_level = self.status.suction_level.value
- if not water_volume or water_volume == "":
- if self.status.self_wash_base_available:
- water_volume = self.status.mop_pad_humidity.value
- else:
- water_volume = self.status.water_volume.value
+ if water_volume is None or water_volume == "":
+ water_volume = self.status.water_volume.value
+
+ if cleaning_times is None or cleaning_times == "":
+ cleaning_times = 1
cleanlist = []
index = 0
- segments = self.status.segments
- custom_order = self.get_property(DreameVacuumProperty.CLEANING_MODE) is not None and self.status.custom_order
+ segments = self.status.current_segments
for segment_id in selected_segments:
- if not cleaning_times:
- if segments and segment_id in segments and self.status.customized_cleaning:
- repeat = segments[segment_id].cleaning_times
+ if isinstance(cleaning_times, list):
+ if index < len(cleaning_times):
+ repeat = cleaning_times[index]
else:
- repeat = 1
- elif isinstance(cleaning_times, list):
- repeat = cleaning_times[index]
+ if segments and segment_id in segments and self.status.customized_cleaning:
+ repeat = segments[segment_id].cleaning_times
+ else:
+ repeat = 1
else:
repeat = cleaning_times
- if not suction_level:
- if segments and segment_id in segments and self.status.customized_cleaning:
+ if isinstance(suction_level, list):
+ if index < len(suction_level):
+ fan = suction_level[index]
+ elif segments and segment_id in segments and self.status.customized_cleaning:
fan = segments[segment_id].suction_level
else:
- fan = 1
- elif isinstance(suction_level, list):
- fan = suction_level[index]
+ fan = self.status.suction_level.value
else:
fan = suction_level
- if not water_volume:
- if segments and segment_id in segments and self.status.customized_cleaning:
+ if isinstance(water_volume, list):
+ if index < len(water_volume):
+ water = water_volume[index]
+ elif segments and segment_id in segments and self.status.customized_cleaning:
water = segments[segment_id].water_volume
else:
- water = 1
- elif isinstance(water_volume, list):
- water = water_volume[index]
+ if self.capability.self_wash_base:
+ water = self.status.mop_pad_humidity
+ else:
+ water = self.status.water_volume.value
else:
water = water_volume
- cleanlist.append([segment_id, repeat, fan, water, 1 if custom_order else (index + 1)])
index = index + 1
+ cleanlist.append(
+ [segment_id, max(1, repeat), fan, water, 1 if self.capability.customized_cleaning else index]
+ ) ## Sending index other than 1 breaks the operation of 5th gen devices
+ self.schedule_update(10, True)
if not self.status.started or self.status.paused:
if self._map_manager:
+ if not self.status.started:
+ self._map_manager.editor.clear_path()
+
# Set active segments on current map data is implemented on the app
self._map_manager.editor.set_active_segments(selected_segments)
- self._update_status(DreameVacuumTaskStatus.SEGMENT_CLEANING, DreameVacuumStatus.SEGMENT_CLEANING)
+ self._update_status(
+ DreameVacuumTaskStatus.SEGMENT_CLEANING,
+ DreameVacuumStatus.SEGMENT_CLEANING,
+ )
+
+ data = {"selects": cleanlist}
+ if timestamp is not None:
+ data["timestamp"] = timestamp
return self.start_custom(
DreameVacuumStatus.SEGMENT_CLEANING.value,
- str(json.dumps({"selects": cleanlist}, separators=(",", ":"))).replace(" ", ""),
+ str(json.dumps(data, separators=(",", ":"))).replace(" ", ""),
)
def clean_spot(
self,
points: list[int] | list[list[int]],
- cleaning_times: int | list[int],
- suction_level: int | list[int],
- water_volume: int | list[int],
+ cleaning_times: int | list[int] | None,
+ suction_level: int | list[int] | None,
+ water_volume: int | list[int] | None,
) -> dict[str, Any] | None:
- self.schedule_update(10)
- if points and not isinstance(points[0], list):
+ """Clean 1.5 square meters area of selected points."""
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot start cleaning while draining or self repairing/testing")
+
+ if not isinstance(points, list) or not points:
+ raise InvalidActionException(f"Invalid point coordinates: %s", points)
+
+ if not isinstance(points[0], list):
points = [points]
- suction_level = self.status.suction_level.value
- if self.status.self_wash_base_available:
- water_volume = self.status.mop_pad_humidity.value
+ if suction_level is None or suction_level == "":
+ suction_level = self.status.suction_level.value
else:
+ self._update_suction_level(suction_level[0] if isinstance(suction_level, list) else suction_level)
+
+ if water_volume is None or water_volume == "":
water_volume = self.status.water_volume.value
+ else:
+ self._update_water_level(int(water_volume[0] if isinstance(water_volume, list) else water_volume))
+
+ if cleaning_times is None or cleaning_times == "":
+ cleaning_times = 1
cleanlist = []
+ index = 0
for point in points:
+ if isinstance(cleaning_times, list):
+ if index < len(cleaning_times):
+ repeat = cleaning_times[index]
+ else:
+ repeat = 1
+ else:
+ repeat = cleaning_times
+
+ if isinstance(suction_level, list):
+ if index < len(suction_level):
+ fan = suction_level[index]
+ else:
+ fan = self.status.suction_level.value
+ else:
+ fan = suction_level
+
+ if isinstance(water_volume, list):
+ if index < len(water_volume):
+ water = water_volume[index]
+ else:
+ if self.capability.self_wash_base:
+ water = self.status.mop_pad_humidity
+ else:
+ water = self.status.water_volume.value
+ else:
+ water = water_volume
+
+ index = index + 1
+
+ if self.status.current_map and not self.status.current_map.check_point(point[0], point[1]):
+ raise InvalidActionException(f"Coordinate ({point[0]}, {point[1]}) is not inside the map")
+
cleanlist.append(
[
int(round(point[0])),
int(round(point[1])),
- cleaning_times,
- suction_level,
- water_volume,
+ repeat,
+ fan,
+ water,
]
)
+ self.schedule_update(10, True)
+
+ if self.status.cleangenius_cleaning:
+ self._previous_cleangenius = self.get_property(DreameVacuumAutoSwitchProperty.CLEANGENIUS)
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.CLEANGENIUS, DreameVacuumCleanGenius.OFF.value, False
+ )
+ else:
+ self._previous_cleangenius = None
+
if not self.status.started or self.status.paused:
if self._map_manager:
+ if not self.status.started:
+ self._map_manager.editor.clear_path()
# Set active points on current map data is implemented on the app
self._map_manager.editor.set_active_points(points)
@@ -1530,9 +4539,196 @@ def clean_spot(
str(json.dumps({"points": cleanlist}, separators=(",", ":"))).replace(" ", ""),
)
+ def go_to(self, x, y) -> dict[str, Any] | None:
+ """Go to a point and take pictures around."""
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot go to point while draining or self repairing/testing")
+
+ if self.status.current_map and not self.status.current_map.check_point(x, y):
+ raise InvalidActionException(f"Coordinate ({x}, {y}) is not inside the map")
+
+ if self.status.battery_level < 15:
+ raise InvalidActionException(
+ "Low battery capacity. Please start the robot for working after it being fully charged."
+ )
+
+ if not (self.status.started or self.status.paused):
+ if not self.capability.cruising and self.status.cleangenius_cleaning:
+ self._previous_cleangenius = self.get_property(DreameVacuumAutoSwitchProperty.CLEANGENIUS)
+ self.set_auto_switch_property(
+ DreameVacuumAutoSwitchProperty.CLEANGENIUS, DreameVacuumCleanGenius.OFF.value, False
+ )
+ else:
+ self._previous_cleangenius = None
+
+ self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.MONITORING.value)
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.CRUISING_POINT.value)
+ self._update_property(
+ DreameVacuumProperty.TASK_STATUS,
+ DreameVacuumTaskStatus.CRUISING_POINT.value,
+ )
+
+ if self.capability.cruising:
+ if self._map_manager:
+ # Set active cruise points on current map data is implemented on the app
+ self._map_manager.editor.set_cruise_points([[x, y, 0, 0]])
+
+ return self.start_custom(
+ DreameVacuumStatus.CRUISING_POINT.value,
+ str(
+ json.dumps(
+ {"tpoint": [[x, y, 0, 0]]},
+ separators=(",", ":"),
+ )
+ ).replace(" ", ""),
+ )
+ else:
+ size = (self.status.current_map.dimensions.grid_size * 2) if self.status.current_map else 100
+ if self.status.current_map and self.status.current_map.robot_position:
+ position = self.status.current_map.robot_position
+ if abs(x - position.x) <= size and abs(y - position.y) <= size:
+ raise InvalidActionException(f"Robot is already on selected coordinate")
+
+ self._set_go_to_zone(x, y, size)
+
+ if self._map_manager:
+ # Set active cruise points on current map data is implemented on the app
+ self._map_manager.editor.set_cruise_points([[x, y, 0, 0]])
+
+ size = int(size / 2)
+ response = self.start_custom(
+ DreameVacuumStatus.ZONE_CLEANING.value,
+ str(
+ json.dumps(
+ {
+ "areas": [
+ [
+ int(round(x - size)),
+ int(round(y - size)),
+ int(round(x + size)),
+ int(round(y + size)),
+ 1,
+ 0,
+ 1,
+ ]
+ ]
+ },
+ separators=(",", ":"),
+ )
+ ).replace(" ", ""),
+ )
+ if not response:
+ self._restore_go_to_zone()
+
+ return response
+
+ def follow_path(self, points: list[int] | list[list[int]]) -> dict[str, Any] | None:
+ """Start a survaliance job."""
+ if not self.capability.cruising:
+ raise InvalidActionException("Follow path is supported on this device")
+
+ if self.status.stream_status != DreameVacuumStreamStatus.IDLE:
+ raise InvalidActionException(f"Follow path only works with live camera streaming")
+
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot follow path while draining or self repairing/testing")
+
+ if self.status.battery_level < 15:
+ raise InvalidActionException(
+ "Low battery capacity. Please start the robot for working after it being fully charged."
+ )
+
+ if not points:
+ points = []
+
+ if points and not isinstance(points[0], list):
+ points = [points]
+
+ if self.status.current_map:
+ for point in points:
+ if not self.status.current_map.check_point(point[0], point[1]):
+ raise InvalidActionException(f"Coordinate ({point[0]}, {point[1]}) is not inside the map")
+
+ path = []
+ for point in points:
+ path.append([int(round(point[0])), int(round(point[1])), 0, 1])
+
+ predefined_points = []
+ if self.status.current_map and self.status.current_map.predefined_points:
+ for point in self.status.current_map.predefined_points:
+ predefined_points.append([int(round(point.x)), int(round(point.y)), 0, 1])
+
+ if len(path) == 0:
+ path.extend(predefined_points)
+
+ if len(path) == 0:
+ raise InvalidActionException("At least one valid or saved coordinate is required")
+
+ if not self.status.started or self.status.paused:
+ self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.MONITORING.value)
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.CRUISING_PATH.value)
+ self._update_property(
+ DreameVacuumProperty.TASK_STATUS,
+ DreameVacuumTaskStatus.CRUISING_PATH.value,
+ )
+
+ if self._map_manager:
+ # Set active cruise points on current map data is implemented on the app
+ self._map_manager.editor.set_cruise_points(path[:20])
+
+ return self.start_custom(
+ DreameVacuumStatus.CRUISING_PATH.value,
+ str(
+ json.dumps(
+ {"tpoint": path[:20]},
+ separators=(",", ":"),
+ )
+ ).replace(" ", ""),
+ )
+
+ def start_shortcut(self, shortcut_id: int) -> dict[str, Any] | None:
+ """Start shortcut job."""
+ if not self.capability.shortcuts and not self.status.shortcuts:
+ raise InvalidActionException(f"Shortcuts are not supported on this device")
+
+ if shortcut_id < 25 or shortcut_id > 128:
+ raise InvalidActionException(f"Invalid shortcut ID: {shortcut_id}")
+
+ if self.status.draining or self.status.self_repairing:
+ raise InvalidActionException(f"Cannot start cleaning while draining or self repairing/testing")
+
+ shortcut = None
+ if self.status.shortcuts and shortcut_id in self.status.shortcuts:
+ shortcut = self.status.shortcuts[shortcut_id]
+ if (
+ shortcut.map_id
+ and self._map_manager
+ and (not self._map_manager.selected_map or shortcut.map_id != self._map_manager.selected_map.map_id)
+ ):
+ if not self.set_selected_map(shortcut.map_id):
+ raise InvalidActionException("Failed to select map")
+
+ if not self.status.started:
+ if self.status.status is DreameVacuumStatus.STANDBY:
+ self._update_property(DreameVacuumProperty.STATE, DreameVacuumState.IDLE.value)
+
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.SEGMENT_CLEANING.value)
+ self._update_property(
+ DreameVacuumProperty.TASK_STATUS,
+ DreameVacuumTaskStatus.AUTO_CLEANING.value,
+ )
+
+ if shortcut:
+ self.status.shortcuts[shortcut_id].running = True
+ self._property_changed(True)
+
+ return self.start_custom(
+ DreameVacuumStatus.SHORTCUT.value,
+ str(shortcut_id),
+ )
+
def start_fast_mapping(self) -> dict[str, Any] | None:
"""Fast map."""
- self.schedule_update(10)
if self.status.fast_mapping:
return
@@ -1541,34 +4737,31 @@ def start_fast_mapping(self) -> dict[str, Any] | None:
"Low battery capacity. Please start the robot for working after it being fully charged."
)
- if (
- not self.status.self_wash_base_available
- and self.status.water_tank_or_mop_installed
- and not self.status.mop_pad_lifting_available
- ):
+ if self.status.water_tank_or_mop_installed and not self.capability.mop_pad_lifting:
raise InvalidActionException("Please make sure the mop pad is not installed before fast mapping.")
+ self.schedule_update(10, True)
self._update_status(DreameVacuumTaskStatus.FAST_MAPPING, DreameVacuumStatus.FAST_MAPPING)
+ self._update_property(DreameVacuumProperty.CLEANING_TIME, 0)
+ self._update_property(DreameVacuumProperty.CLEANED_AREA, 0)
if self._map_manager:
- self._map_manager.editor.refresh_map()
+ self._map_manager.editor.reset_map()
return self.start_custom(DreameVacuumStatus.FAST_MAPPING.value)
def start_mapping(self) -> dict[str, Any] | None:
"""Create a new map by cleaning whole floor."""
- self.schedule_update(10)
+ self.schedule_update(10, True)
+ self._update_status(DreameVacuumTaskStatus.AUTO_CLEANING, DreameVacuumStatus.CLEANING)
+
if self._map_manager:
self._map_manager.editor.reset_map()
- self._update_status(DreameVacuumTaskStatus.AUTO_CLEANING, DreameVacuumStatus.CLEANING)
return self.start_custom(DreameVacuumStatus.CLEANING.value, "3")
def start_self_wash_base(self, parameters: dict[str, Any] = None) -> dict[str, Any] | None:
"""Start self-wash base for cleaning or drying the mop."""
- if not self.status.self_wash_base_available:
- return
-
if self.info and self.info.version <= 1037:
parameters = None
@@ -1582,46 +4775,415 @@ def start_self_wash_base(self, parameters: dict[str, Any] = None) -> dict[str, A
]
return self.call_action(DreameVacuumAction.START_WASHING, payload)
+ def toggle_washing(self) -> dict[str, Any] | None:
+ """Toggle washing the mop if self-wash base is present."""
+ if self.status.washing:
+ return self.pause_washing()
+ return self.start_washing()
+
def start_washing(self) -> dict[str, Any] | None:
"""Start washing the mop if self-wash base is present."""
if self.status.washing_paused:
+ self._update_property(
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
+ DreameVacuumSelfWashBaseStatus.WASHING.value,
+ )
if self.info and self.info.version <= 1037:
return self.start()
return self.start_self_wash_base("1,1")
if self.status.washing_available or self.status.returning_to_wash_paused:
+ self._update_property(
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
+ DreameVacuumSelfWashBaseStatus.WASHING.value,
+ )
return self.start_self_wash_base("2,1")
def pause_washing(self) -> dict[str, Any] | None:
"""Pause washing the mop if self-wash base is present."""
if self.status.washing:
+ self._update_property(
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
+ DreameVacuumSelfWashBaseStatus.PAUSED.value,
+ )
if self.info and self.info.version <= 1037:
return self.pause()
return self.start_self_wash_base("1,0")
+ def toggle_drying(self) -> dict[str, Any] | None:
+ """Toggle drying the mop if self-wash base is present."""
+ if self.status.drying_available and self.status.drying:
+ return self.stop_drying()
+ return self.start_drying()
+
def start_drying(self) -> dict[str, Any] | None:
"""Start drying the mop if self-wash base is present."""
if self.status.drying_available and not self.status.drying:
+ self._update_property(
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
+ DreameVacuumSelfWashBaseStatus.DRYING.value,
+ )
+ if self.status.dust_bag_drying:
+ self.stop_dust_bag_drying()
return self.start_self_wash_base("3,1")
def stop_drying(self) -> dict[str, Any] | None:
"""Stop drying the mop if self-wash base is present."""
if self.status.drying_available and self.status.drying:
+ self._update_property(
+ DreameVacuumProperty.SELF_WASH_BASE_STATUS,
+ DreameVacuumSelfWashBaseStatus.IDLE.value,
+ )
return self.start_self_wash_base("3,0")
- def clear_warning(self) -> dict[str, Any] | None:
+ def toggle_dust_bag_drying(self) -> dict[str, Any] | None:
+ """Toggle drying the dust bag."""
+ if self.status.dust_bag_drying_available and self.status.dust_bag_drying:
+ return self.stop_dust_bag_drying()
+ return self.start_dust_bag_drying()
+
+ def start_dust_bag_drying(self) -> dict[str, Any] | None:
+ """Start drying the dust bag."""
+ if self.status.dust_bag_drying_available and not self.status.dust_bag_drying:
+ self._update_property(
+ DreameVacuumProperty.DUST_BAG_DRYING_STATUS,
+ DreameVacuumDustBagDryingStatus.DRYING.value,
+ )
+ if self.status.drying:
+ self.stop_drying()
+ return self.start_self_wash_base("14,1")
+
+ def stop_dust_bag_drying(self) -> dict[str, Any] | None:
+ """Stop drying the dust bag."""
+ if self.status.dust_bag_drying_available and self.status.dust_bag_drying:
+ self._update_property(
+ DreameVacuumProperty.DUST_BAG_DRYING_STATUS,
+ DreameVacuumDustBagDryingStatus.IDLE.value,
+ )
+ return self.start_self_wash_base("14,0")
+
+ def start_draining(self, clean_water_tank=False) -> dict[str, Any] | None:
+ """Start draining water if self-wash base is present."""
+ if clean_water_tank:
+ if self.status.water_tank_emptying_available:
+ return self.start_self_wash_base("9,1")
+ if self.status.water_tank_draining_available:
+ return self.start_self_wash_base("7,1")
+
+ def start_self_repairing(self) -> dict[str, Any] | None:
+ """Start self repairing if self-wash base is present."""
+ if not self.status.draining and not self.status.self_repairing:
+ current_status = self.status.status
+ self.schedule_update(10)
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.SELF_REPAIR.value)
+ mapping = self.property_mapping[DreameVacuumProperty.SELF_TEST_STATUS]
+ result = self._protocol.set_property(mapping["siid"], mapping["piid"], '{"bittest":[17,0]}')
+
+ self.schedule_update(3)
+ if result is None or result[0]["code"] != 0:
+ _LOGGER.error("Start self repairing failed")
+ self._update_property(DreameVacuumProperty.STATUS, current_status)
+ raise InvalidActionException(f"Start self repairing failed")
+ return result
+
+ def start_station_cleaning(self) -> dict[str, Any] | None:
+ """Start base station cleaning if self-wash base is present."""
+ if (
+ self.capability.station_cleaning
+ and not self.status.draining
+ and not self.status.self_repairing
+ and not self.status.station_cleaning
+ ):
+ if (
+ self.capability.washboard_cleaning_status
+ and self._get_property(DreameVacuumProperty.WASHBOARD_CLEANING_STATUS) == 1
+ ):
+ self._update_property(DreameVacuumProperty.WASHBOARD_CLEANING_STATUS, 0)
+ return self.call_action(DreameVacuumAction.CHARGE)
+
+ current_status = self.status.task_status
+ self.schedule_update(10)
+ if self.capability.washboard_cleaning_status:
+ self._update_property(DreameVacuumProperty.WASHBOARD_CLEANING_STATUS, 1)
+
+ self._update_property(DreameVacuumProperty.TASK_STATUS, DreameVacuumTaskStatus.STATION_CLEANING.value)
+ result = self.start_self_wash_base("5,1")
+ self.schedule_update(3)
+ if result is None or result[0]["code"] != 0:
+ _LOGGER.error("Start base station cleaning failed")
+ self._update_property(DreameVacuumProperty.TASK_STATUS, current_status)
+ raise InvalidActionException(f"Start base station cleaning failed")
+ return result
+
+ def start_recleaning(self) -> dict[str, Any] | None:
+ """Start self repairing if dirty areas or blocked rooms are present."""
+ if self.capability.auto_recleaning and self.status._cleaning_history and self.status.current_map:
+ history = self.status._cleaning_history[0]
+ map_data = self.status._history_map_data.get(history.object_name) if history.object_name else None
+ if map_data and self.status.current_map.map_id == map_data.map_id:
+ timestamp = history.multiple_cleaning_time if history.multiple_cleaning_time else ""
+ if (
+ history.cleanup_method != CleanupMethod.CLEANGENIUS
+ and not map_data.cleaned_segments
+ and map_data.blocked_segments
+ ):
+ return self.clean_segment(map_data.blocked_segments.keys(), timestamp=timestamp)
+ else:
+ data = {
+ "MopAgain": map_data.dos if map_data.dos is not None else 1,
+ "timestamp": timestamp,
+ "CleanArea": map_data.cleaned_segments if map_data.cleaned_segments else [],
+ "BigArea": map_data.blocked_segments.keys() if map_data.blocked_segments else [],
+ }
+ self.schedule_update(10, True)
+ self._update_property(
+ DreameVacuumProperty.STATE,
+ DreameVacuumState.SECOND_CLEANING.value,
+ )
+ self._update_property(DreameVacuumProperty.STATUS, DreameVacuumStatus.CLEANING.value)
+ self._update_property(
+ DreameVacuumProperty.TASK_STATUS,
+ DreameVacuumStatus.CLEANING.value,
+ )
+ return self.start_custom(
+ DreameVacuumStatus.CLEANING.value,
+ str(json.dumps(data, separators=(",", ":"))).replace(" ", ""),
+ )
+
+ def reload_shortcuts(self, sync=False) -> None:
+ shortcuts = self.get_property(DreameVacuumProperty.SHORTCUTS)
+ if shortcuts is not None:
+ if shortcuts and shortcuts != "":
+ shortcuts = json.loads(shortcuts)
+ if shortcuts:
+ new_shortcuts = {}
+ for i, shortcut in enumerate(shortcuts, 1):
+ id = shortcut["id"]
+ running = (
+ False
+ if "state" not in shortcut
+ else bool(shortcut["state"] == "0" or shortcut["state"] == "1")
+ )
+ name = base64.decodebytes(shortcut["name"].encode("utf8")).decode("utf-8")
+ new_shortcuts[id] = Shortcut(id=id, index=i, name=name, running=running, tasks=[])
+ if self.status.shortcuts is not None:
+ if id in self.status.shortcuts:
+ self.status.shortcuts[id].index = i
+ self.status.shortcuts[id].name = name
+ self.status.shortcuts[id].running = running
+ else:
+ self.status.shortcuts[id] = new_shortcuts[id]
+
+ if self.status.shortcuts:
+ for id in list(self.status.shortcuts.keys()):
+ if id not in new_shortcuts:
+ del self.status.shortcuts[id]
+
+ def callback(response):
+ detail = {}
+ if response and "out" in response:
+ data = response["out"]
+ if data and len(data):
+ if "value" in data[0] and data[0]["value"] != "":
+ for task in json.loads(data[0]["value"]):
+ detail[task["id"]] = task["mapId"]
+
+ for s, shortcut in enumerate(shortcuts, 1):
+ try:
+ id = shortcut["id"]
+ running = (
+ False
+ if "state" not in shortcut
+ else bool(shortcut["state"] == "0" or shortcut["state"] == "1")
+ )
+ name = base64.decodebytes(shortcut["name"].encode("utf8")).decode("utf-8")
+ if id == 25:
+ tasks = [
+ [
+ ShortcutTask(
+ order=1,
+ task_type=DreameVacuumShortcutTaskType.CUSTOMIZED_CLEANING,
+ )
+ ]
+ ]
+ else:
+ map_id = detail[id] if id in detail else None
+ tasks = None
+ response = self.call_shortcut_action("GET_COMMAND_BY_ID", {"id": id})
+ if response and "out" in response:
+ data = response["out"]
+ if data and len(data):
+ if "value" in data[0] and data[0]["value"] != "":
+ tasks = []
+ for task in json.loads(data[0]["value"]):
+ items = []
+ for o, item in enumerate(task, 1):
+ length = len(item)
+ index = 5
+ order = o
+ task_type = None
+ segment_id = None
+ suction_level = item[1]
+ water_volume = (
+ item[2] - 1 if item[2] > 1 and item[2] < 5 else 1
+ )
+ cleaning_times = item[3]
+ cleaning_mode = item[4]
+ mopping_settings = None
+ wetness_level = None
+ cleaning_route = None
+ custom_mopping_route = None
+ mop_temperature = None
+ mop_pressure = None
+ coords = None
+ values = None
+
+ if item[0] == -1:
+ task_type = DreameVacuumShortcutTaskType.ALL
+ elif item[0] == -2:
+ task_type = DreameVacuumShortcutTaskType.ZONE
+ coords = item[5:9]
+ order = item[9] + 1
+ index = 10
+ else:
+ segment_id = item[0]
+ task_type = DreameVacuumShortcutTaskType.SEGMENT
+
+ if length > index:
+ mopping_settings = item[index]
+ if mopping_settings > 0:
+ values = DreameVacuumMapDecoder.split_mopping_settings(
+ mopping_settings
+ )
+ if values[2] == 0:
+ custom_mopping_route = values[0] - 1
+ water_volume = values[1]
+ cleaning_route = values[0]
+ elif values[2] <= 3:
+ custom_mopping_route = -1
+ cleaning_route = 1 if values[2] == 2 else values[2]
+ water_volume = values[2]
+
+ if self.capability.wetness_level:
+ custom_mopping_route = None
+ if values[2] == 0 and values[1] == 0:
+ wetness_level = item[2] if item[2] else 16
+ if wetness_level > 26:
+ water_volume = 3
+ elif wetness_level < 6:
+ water_volume = 1
+ else:
+ water_volume = 2
+ elif water_volume == 1:
+ wetness_level = 5
+ elif water_volume == 3:
+ wetness_level = 27
+ else:
+ wetness_level = 16
+
+ if self.capability.cleaning_route:
+ custom_mopping_route = None
+
+ index = index + 1
+ if self.capability.mop_temperature:
+ mop_temperature = item[index] if length > index else 0
+
+ index = index + 2
+ if self.capability.mop_pressure:
+ mop_pressure = item[index] if length > index else 1
+
+ if self.capability.wetness_level and wetness_level is None:
+ wetness_level = item[2] if item[2] else 16
+
+ items.append(
+ ShortcutTask(
+ order=order,
+ segment_id=segment_id,
+ suction_level=suction_level,
+ water_volume=water_volume,
+ wetness_level=wetness_level,
+ cleaning_times=cleaning_times,
+ cleaning_mode=cleaning_mode,
+ mopping_settings=mopping_settings,
+ cleaning_route=cleaning_route,
+ custom_mopping_route=custom_mopping_route,
+ mop_temperature=mop_temperature,
+ mop_pressure=mop_pressure,
+ coords=coords,
+ task_type=task_type,
+ )
+ )
+ tasks.append(items)
+
+ new_shortcuts[id] = Shortcut(
+ id=id, index=s, name=name, map_id=map_id, running=running, tasks=tasks
+ )
+ except Exception as ex:
+ _LOGGER.error("Failed to parse shortcut task: %s", ex)
+
+ self.status.shortcuts = new_shortcuts
+ self._property_changed()
+
+ try:
+ if sync:
+ callback(self.call_shortcut_action("GET_COMMANDS"))
+ else:
+ self.call_shortcut_action_async(callback, "GET_COMMANDS")
+ except:
+ self.status.shortcuts = new_shortcuts
+ self._property_changed()
+ elif self.status.shortcuts:
+ self.status.shortcuts = {}
+ self._property_changed()
+ elif self.status.shortcuts:
+ self.status.shortcuts = {}
+ self._property_changed()
+
+ def clear_warning(self) -> dict[str, Any] | None:
"""Clear warning error code from the vacuum cleaner."""
+ if self.status.draining_complete:
+ return self.set_property(DreameVacuumProperty.DRAINAGE_STATUS, 0)
if self.status.has_warning:
- return self.call_action(
- DreameVacuumAction.CLEAR_WARNING,
- [
- {
- "piid": PIID(DreameVacuumProperty.CLEANING_PROPERTIES, self.property_mapping),
- "value": f"[{self.status.error.value}]",
- }
- ],
- )
+ error = self.status.error.value
+ if error in [
+ ## Only these warnings can be cleared according to the App source code
+ DreameVacuumErrorCode.BLOCKED.value,
+ DreameVacuumErrorCode.REMOVE_MOP.value,
+ DreameVacuumErrorCode.MOP_REMOVED_2.value,
+ DreameVacuumErrorCode.LOW_BATTERY_TURN_OFF.value,
+ DreameVacuumErrorCode.SLIPPERY_FLOOR.value,
+ DreameVacuumErrorCode.CLEAN_MOP_PAD.value,
+ DreameVacuumErrorCode.STATION_DISCONNECTED.value,
+ DreameVacuumErrorCode.DUST_BAG_FULL.value,
+ DreameVacuumErrorCode.SELF_TEST_FAILED.value,
+ DreameVacuumErrorCode.ONBOARD_WATER_TANK_EMPTY.value,
+ DreameVacuumErrorCode.ONBOARD_DIRTY_WATER_TANK_FULL.value,
+ ]:
+ if error in self.status.faults:
+ self.status.faults.remove(error)
+ self._update_property(DreameVacuumProperty.ERROR, DreameVacuumErrorCode.NO_ERROR.value)
+ return self.call_action(
+ DreameVacuumAction.CLEAR_WARNING,
+ [
+ {
+ "piid": PIID(
+ DreameVacuumProperty.CLEANING_PROPERTIES,
+ self.property_mapping,
+ ),
+ "value": f"[{error}]",
+ }
+ ],
+ )
+ else:
+ return self.clear_low_water_warning()
+
+ def clear_low_water_warning(self) -> dict[str, Any] | None:
+ """Clear low water warning error code from the vacuum cleaner."""
+ if self.status.low_water:
+ return self.set_property(DreameVacuumProperty.LOW_WATER_WARNING, 1)
- def remote_control_move_step(self, rotation: int = 0, velocity: int = 0) -> dict[str, Any] | None:
+ def remote_control_move_step(
+ self, rotation: int = 0, velocity: int = 0, prompt: bool | None = None
+ ) -> dict[str, Any] | None:
"""Send remote control command to device."""
if self.status.fast_mapping:
raise InvalidActionException("Cannot remote control vacuum while fast mapping")
@@ -1632,12 +5194,20 @@ def remote_control_move_step(self, rotation: int = 0, velocity: int = 0) -> dict
payload = '{"spdv":%(velocity)d,"spdw":%(rotation)d,"audio":"%(audio)s","random":%(random)d}' % {
"velocity": velocity,
"rotation": rotation,
- "audio": "false" if self._remote_control or self.status.status is DreameVacuumStatus.SLEEPING else "true",
+ "audio": (
+ "true"
+ if prompt == True
+ else (
+ "false"
+ if prompt == False or self._remote_control or self.status.status is DreameVacuumStatus.SLEEPING
+ else "true"
+ )
+ ),
"random": randrange(65535),
}
self._remote_control = True
mapping = self.property_mapping[DreameVacuumProperty.REMOTE_CONTROL]
- return self._protocol.set_property(mapping["siid"], mapping["piid"], payload, 0)
+ return self._protocol.set_property(mapping["siid"], mapping["piid"], payload, 1)
def install_voice_pack(self, lang_id: int, url: str, md5: str, size: int) -> dict[str, Any] | None:
"""install a custom language pack"""
@@ -1648,264 +5218,555 @@ def install_voice_pack(self, lang_id: int, url: str, md5: str, size: int) -> dic
"size": size,
}
mapping = self.property_mapping[DreameVacuumProperty.VOICE_CHANGE]
- return self._protocol.set_property(mapping["siid"], mapping["piid"], payload, 1)
+ return self._protocol.set_property(mapping["siid"], mapping["piid"], payload, 3)
+
+ def obstacle_image(self, index):
+ if self.capability.map and self.status.current_map:
+ map_data = self.status.current_map
+ if map_data:
+ return self._map_manager.get_obstacle_image(map_data, index)
+ return (None, None)
+
+ def obstacle_history_image(self, index, history_index, cruising=False):
+ if self.capability.map:
+ map_data = self.history_map(history_index, cruising)
+ if map_data:
+ return self._map_manager.get_obstacle_image(map_data, index)
+ return (None, None)
+
+ def history_map(self, index, cruising=False):
+ if self.capability.map and index and str(index).isnumeric():
+ item = None
+ index = int(index) - 1
+ if cruising:
+ if self.status._cruising_history and len(self.status._cruising_history) > index:
+ item = self.status._cruising_history[index]
+ elif self.status._cleaning_history and len(self.status._cleaning_history) > index:
+ item = self.status._cleaning_history[index]
+
+ if item and item.object_name:
+ if item.object_name not in self.status._history_map_data:
+ map_data = self._map_manager.get_history_map(item.object_name, item.key)
+ if map_data is None:
+ return None
+ map_data.last_updated = item.date.timestamp()
+ map_data.completed = item.completed
+ map_data.second_cleaning = item.second_cleaning
+ map_data.second_mopping = item.second_mopping
+ map_data.cleaned_area = item.cleaned_area
+ map_data.cleaning_time = item.cleaning_time
+ map_data.task_interrupt_reason = item.task_interrupt_reason
+ map_data.cleaning_status = item.cleaning_status
+ map_data.cleanup_method = item.cleanup_method
+ if map_data.cleaning_map_data:
+ map_data.cleaning_map_data.last_updated = item.date.timestamp()
+ map_data.cleaning_map_data.completed = item.completed
+ map_data.cleaning_map_data.second_cleaning = item.second_cleaning
+ map_data.cleaning_map_data.cleaned_area = item.cleaned_area
+ map_data.cleaning_map_data.cleaning_time = item.cleaning_time
+ self.status._history_map_data[item.object_name] = map_data
+ return self.status._history_map_data[item.object_name]
+
+ def recovery_map(self, map_id, index):
+ if self.capability.map and map_id and index and str(index).isnumeric():
+ if (map_id is None or map_id == "") and self.status.selected_map:
+ map_id = self.status.selected_map.map_id
+
+ return self._map_manager.get_recovery_map(map_id, index)
+
+ def recovery_map_file(self, map_id, index):
+ if self.capability.map and map_id and index and str(index).isnumeric():
+ if (map_id is None or map_id == "") and self.status.selected_map:
+ map_id = self.status.selected_map.map_id
+
+ return self._map_manager.get_recovery_map_file(map_id, index)
def set_ai_detection(self, settings: dict[str, bool] | int) -> dict[str, Any] | None:
"""Send ai detection parameters to the device."""
- if self.status.ai_detection_available:
- self._property_changed()
+ if self.capability.ai_detection:
+ # if (self.status.ai_obstacle_detection or self.status.ai_obstacle_image_upload) and (
+ # self._protocol.cloud and not self.status.ai_policy_accepted
+ # ):
+ # prop = "prop.s_ai_config"
+ # response = self._protocol.cloud.get_batch_device_datas([prop])
+ # if response and prop in response and response[prop]:
+ # try:
+ # self.status.ai_policy_accepted = json.loads(response[prop]).get("privacyAuthed")
+ # except:
+ # pass
+ # if not self.status.ai_policy_accepted:
+ # if self.status.ai_obstacle_detection:
+ # self.set_ai_property(DreameVacuumAIProperty.AI_OBSTACLE_DETECTION, False)
+ # if self.status.ai_obstacle_image_upload:
+ # self.set_ai_property(DreameVacuumAIProperty.AI_OBSTACLE_IMAGE_UPLOAD, False)
+ # self._property_changed(False)
+ # raise InvalidActionException(
+ # "You need to accept privacy policy from the App before enabling AI obstacle detection feature"
+ # )
+ mapping = self.property_mapping[DreameVacuumProperty.AI_DETECTION]
+ if isinstance(settings, int):
+ return self._protocol.set_property(mapping["siid"], mapping["piid"], settings, 3)
+ return self._protocol.set_property(
+ mapping["siid"],
+ mapping["piid"],
+ str(json.dumps(settings, separators=(",", ":"))).replace(" ", ""),
+ 3,
+ )
- if (self.status.ai_obstacle_detection or self.status.obstacle_image_upload) and (
- self._protocol.cloud and not self.status.ai_policy_accepted
- ):
- prop = "prop.s_ai_config"
- response = self._protocol.cloud.get_batch_device_datas([prop])
- if response and prop in response and response[prop]:
- try:
- self.status.ai_policy_accepted = json.loads(response[prop]).get("privacyAuthed")
- except:
- pass
+ def set_ai_property(
+ self, prop: DreameVacuumStrAIProperty | DreameVacuumAIProperty, value: bool
+ ) -> dict[str, Any] | None:
+ if self.capability.ai_detection:
+ if prop.name not in self.ai_data:
+ raise InvalidActionException("Not supported")
+ current_value = self.get_ai_property(prop)
+
+ self._dirty_ai_data[prop.name] = DirtyData(value, current_value, time.time())
+ self.ai_data[prop.name] = value
+ ai_value = self.get_property(DreameVacuumProperty.AI_DETECTION)
+ self._property_changed(False)
+ result = None
+ try:
+ if isinstance(ai_value, int):
+ bit = DreameVacuumAIProperty[prop.name].value
+ result = self.set_ai_detection((ai_value | bit) if value else (ai_value & -(bit + 1)))
+ else:
+ result = self.set_ai_detection({DreameVacuumStrAIProperty[prop.name].value: bool(value)})
+
+ if result is None or result[0]["code"] != 0:
+ _LOGGER.error(
+ "AI Property not updated: %s: %s -> %s",
+ prop.name,
+ current_value,
+ value,
+ )
+ if prop.name in self._dirty_ai_data:
+ del self._dirty_ai_data[prop.name]
+ self.ai_data[prop.name] = current_value
+ self._property_changed(False)
+ except Exception as ex:
+ if prop.name in self._dirty_ai_data:
+ del self._dirty_ai_data[prop.name]
+ self.ai_data[prop.name] = current_value
+ self._property_changed(False)
+ return result
+
+ def set_auto_switch_property(
+ self, prop: DreameVacuumAutoSwitchProperty, value: int, sync=True
+ ) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings:
+ if prop.name not in self.auto_switch_data:
+ raise InvalidActionException("Not supported")
+ current_value = self.get_auto_switch_property(prop)
+ if current_value != value:
+ self._dirty_auto_switch_data[prop.name] = DirtyData(value, current_value, time.time())
+ self.auto_switch_data[prop.name] = value
+ self._property_changed(True)
+ result = None
+ if prop is DreameVacuumAutoSwitchProperty.CLEANGENIUS and self._map_manager:
+ self._map_manager.editor.refresh_map()
+ try:
+ new_value = str(json.dumps({"k": prop.value, "v": int(value)}, separators=(",", ":"))).replace(
+ " ", ""
+ )
+ mapping = self.property_mapping[DreameVacuumProperty.AUTO_SWITCH_SETTINGS]
+ if sync:
+ result = self._protocol.set_property(
+ mapping["siid"],
+ mapping["piid"],
+ new_value,
+ 1,
+ )
+ else:
+ self._protocol.set_property_async(
+ None,
+ mapping["siid"],
+ mapping["piid"],
+ new_value,
+ 1,
+ )
+ result = True
+ if result is None or (result != True and result[0]["code"] != 0):
+ _LOGGER.error(
+ "Auto Switch Property not updated: %s: %s -> %s",
+ prop.name,
+ current_value,
+ value,
+ )
+ if prop.name in self._dirty_auto_switch_data:
+ del self._dirty_auto_switch_data[prop.name]
+ self.auto_switch_data[prop.name] = current_value
+ self._property_changed(False)
+ else:
+ _LOGGER.info("Update Property: %s: %s -> %s", prop.name, current_value, value)
+ if prop.name in self._dirty_auto_switch_data:
+ self._dirty_auto_switch_data[prop.name].update_time = time.time()
+ except:
+ if prop.name in self._dirty_auto_switch_data:
+ del self._dirty_auto_switch_data[prop.name]
+ self.auto_switch_data[prop.name] = current_value
+ self._property_changed(False)
+ return result
+ elif self.capability.self_wash_base and prop == DreameVacuumAutoSwitchProperty.AUTO_DRYING:
+ return self.set_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION, int(value))
+
+ def set_camera_light_brightness(self, brightness: int) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings:
+ if brightness < 40:
+ brightness = 40
+ current_value = self.status.camera_light_brightness
+ self._update_property(DreameVacuumProperty.CAMERA_LIGHT_BRIGHTNESS, str(brightness))
+ result = self.call_stream_property_action(
+ DreameVacuumProperty.CAMERA_LIGHT_BRIGHTNESS, {"value": str(brightness)}
+ )
+ if result is None or result.get("code") != 0:
+ self._update_property(DreameVacuumProperty.CAMERA_LIGHT_BRIGHTNESS, str(current_value))
+ return result
+
+ def set_wider_corner_coverage(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings:
+ current_value = self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE)
+ if current_value is not None and current_value > 0 and value <= 0:
+ value = -current_value
+ return self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE, value)
+
+ def set_mop_pad_swing(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings:
+ current_value = self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOP_PAD_SWING)
+ if current_value is not None and current_value > 0 and value <= 0:
+ value = -current_value
+ return self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.MOP_PAD_SWING, value)
+
+ def set_auto_recleaning(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings and self.capability.auto_recleaning:
+ current_value = self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_RECLEANING)
+ if current_value is not None and current_value > 0 and value <= 0:
+ value = -current_value
+ return self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_RECLEANING, value)
+
+ def set_auto_rewashing(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings and self.capability.auto_rewashing:
+ current_value = self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_REWASHING)
+ if current_value is not None and current_value > 0 and value <= 0:
+ value = -current_value
+ return self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_REWASHING, value)
+
+ def set_self_clean_frequency(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_switch_settings:
+ if value != DreameVacuumSelfCleanFrequency.INTELLIGENT.value and self.capability.self_clean_frequency:
+ current_value = self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY)
+ if (
+ current_value is not None
+ and current_value != DreameVacuumSelfCleanFrequency.BY_ROOM.value
+ and value == DreameVacuumSelfCleanFrequency.BY_ROOM.value
+ ):
+ if current_value == DreameVacuumSelfCleanFrequency.BY_TIME.value:
+ self.status.previous_self_clean_time = self.status.self_clean_value
+ elif current_value == DreameVacuumSelfCleanFrequency.BY_AREA.value:
+ self.status.previous_self_clean_area = self.status.self_clean_value
+
+ if self.capability.self_clean_frequency:
+ self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY, value, False)
+
+ if value != DreameVacuumSelfCleanFrequency.INTELLIGENT.value:
+ if value != DreameVacuumSelfCleanFrequency.BY_ROOM.value:
+ if self.capability.self_clean_frequency and value == DreameVacuumSelfCleanFrequency.BY_TIME.value:
+ self.set_self_clean_value(
+ self.status.previous_self_clean_time
+ if self.status.previous_self_clean_time
+ else self.status.self_clean_time_default
+ )
+ else:
+ self.set_self_clean_value(
+ self.status.previous_self_clean_area
+ if self.status.previous_self_clean_area
+ else self.status.self_clean_area_default
+ )
+ else:
+ self.set_self_clean_value(0)
+
+ def set_auto_empty_mode(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_empty_mode:
+ return self.set_property(DreameVacuumProperty.AUTO_DUST_COLLECTING, value)
+
+ def set_custom_mopping_route(self, value: int) -> dict[str, Any] | None:
+ if self.capability.custom_mopping_route:
+ if value < 0:
+ self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.CUSTOM_MOPPING_MODE, 0, False)
+ return self._update_water_level(
+ self.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOPPING_MODE)
+ )
+ if not self.status.custom_mopping_mode:
+ self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.CUSTOM_MOPPING_MODE, 1, False)
+ self._update_water_level(
+ self.status.mop_pad_humidity if self.capability.self_wash_base else self.status.water_volume.value
+ )
+ return self.set_auto_switch_property(DreameVacuumAutoSwitchProperty.MOPPING_TYPE, value)
- if not self.status.ai_policy_accepted:
- if self.status.ai_obstacle_detection:
- self.status.ai_obstacle_detection = False
+ def set_resume_cleaning(self, value: int) -> dict[str, Any] | None:
+ if self.capability.auto_charging and bool(value):
+ value = 2
+ return self.set_property(DreameVacuumProperty.RESUME_CLEANING, value)
- if self.status.obstacle_image_upload:
- self.status.obstacle_image_upload = False
+ def set_carpet_avoidance(self, value: bool) -> dict[str, Any] | None:
+ return self.set_property(DreameVacuumProperty.CARPET_CLEANING, 1 if value else 2)
- self._property_changed()
+ def set_carpet_cleaning(self, value: int) -> dict[str, Any] | None:
+ if self.get_property(DreameVacuumProperty.CARPET_CLEANING) is not None:
+ if (
+ value == DreameVacuumCarpetCleaning.ADAPTATION_WITHOUT_ROUTE.value
+ and (
+ not self.capability.mop_pad_lifting_plus
+ or self.capability.auto_carpet_cleaning
+ or self.capability.carpet_crossing
+ )
+ ) or (
+ value == DreameVacuumCarpetCleaning.IGNORE.value
+ and (not self.capability.mop_pad_lifting_plus and not self.capability.auto_carpet_cleaning)
+ ):
+ raise InvalidActionException(
+ "Selected cleaning setting is not supported on this device: %s", DreameVacuumCarpetCleaning(value)
+ )
+
+ properties = {}
+ if value == DreameVacuumCarpetCleaning.IGNORE.value:
+ return self.set_carpet_recognition(0)
+ elif not self.status.carpet_recognition:
+ properties[DreameVacuumProperty.CARPET_RECOGNITION] = 1
+ if self.get_property(DreameVacuumProperty.CARPET_RECOGNITION) == 3:
+ properties[DreameVacuumProperty.CARPET_BOOST] = 1
+ properties[DreameVacuumProperty.CARPET_CLEANING] = value
+ if (
+ self.capability.mop_pad_unmounting
+ and value == DreameVacuumCarpetCleaning.REMOVE_MOP.value
+ and not self.status.auto_mount_mop
+ ):
+ properties[DreameVacuumProperty.AUTO_MOUNT_MOP] = 1
+ self.set_properties(properties)
- raise InvalidActionException(
- "You need to accept privacy policy from the App before enabling AI obstacle detection feature"
+ def set_carpet_recognition(self, value: int) -> dict[str, Any] | None:
+ if self.capability.carpet_recognition:
+ current_value = self.get_property(DreameVacuumProperty.CARPET_RECOGNITION)
+ if current_value is not None:
+ value = 1 if bool(value) else 3 if self.get_property(DreameVacuumProperty.CARPET_BOOST) == 1 else 0
+ if current_value != value:
+ self.set_properties(
+ {
+ DreameVacuumProperty.CARPET_RECOGNITION: value,
+ DreameVacuumProperty.CARPET_BOOST: int(value == 1 and current_value == 3),
+ }
)
- mapping = self.property_mapping[DreameVacuumProperty.AI_DETECTION]
- if isinstance(settings, int):
- return self._protocol.set_property(mapping["siid"], mapping["piid"], settings, 1)
- return self._protocol.set_property(
- mapping["siid"], mapping["piid"], str(json.dumps(settings, separators=(",", ":"))).replace(" ", ""), 1
- )
-
- def set_ai_obstacle_detection(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable AI detection feature."""
- if self.status.ai_detection_available:
- current_value = self.status.ai_obstacle_detection
- self.status.ai_obstacle_detection = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- value = (value | 2) if self.status.ai_obstacle_detection else (value & -3)
- result = self.set_ai_detection(value)
- else:
- result = self.set_ai_detection({AI_SETTING_SWITCH: self.status.ai_obstacle_detection})
- if result and result[0]["code"] != 0:
- self.status.ai_obstacle_detection = current_value
- self._property_changed()
- return result
+ def set_multi_floor_map(self, enabled: bool) -> bool:
+ properties = {DreameVacuumProperty.MULTI_FLOOR_MAP: int(enabled)}
+ if (
+ self.capability.auto_switch_settings
+ and not enabled
+ and self.get_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION) == 1
+ ):
+ properties[DreameVacuumProperty.INTELLIGENT_RECOGNITION] = 0
+ self.set_properties(properties)
- def set_obstacle_image_upload(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable obstacle picture uploading to the cloud."""
- if self.status.ai_detection_available:
- current_value = self.status.obstacle_image_upload
- self.status.obstacle_image_upload = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- value = (value | 32) if self.status.obstacle_image_upload else (value & -33)
- result = self.set_ai_detection(value)
- else:
- result = self.set_ai_detection({AI_SETTING_UPLOAD: self.status.obstacle_image_upload})
- if result and result[0]["code"] != 0:
- self.status.obstacle_image_upload = current_value
- self._property_changed()
- return result
+ def rename_shortcut(self, shortcut_id: int, shortcut_name: str = "") -> dict[str, Any] | None:
+ """Rename a shortcut"""
+ shortcut_id = int(shortcut_id)
- def set_pet_detection(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable AI pet detection feature."""
- if self.status.ai_detection_available:
- current_value = self.status.pet_detection
- self.status.pet_detection = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- value = (value | 16) if self.status.pet_detection else (value & -17)
- result = self.set_ai_detection(value)
- else:
- result = self.set_ai_detection({AI_SETTING_PET: self.status.pet_detection})
- if result and result[0]["code"] != 0:
- self.status.pet_detection = current_value
- self._property_changed()
- return result
+ if self.status.started:
+ raise InvalidActionException("Cannot rename a shortcut while vacuum is running")
- def set_human_detection(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable AI human detection feature."""
- if self.status.ai_detection_available:
- current_value = self.status.human_detection
- self.status.human_detection = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- return None
- else:
- result = self.set_ai_detection({AI_SETTING_HUMAN: self.status.human_detection})
- if result and result[0]["code"] != 0:
- self.status.human_detection = current_value
- self._property_changed()
- return result
+ if not self.capability.shortcuts or not self.status.shortcuts:
+ raise InvalidActionException("Shortcuts are not supported on this device")
- def set_furniture_detection(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable AI furnitue detection feature."""
- if self.status.ai_detection_available:
- current_value = self.status.furniture_detection
- self.status.furniture_detection = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- value = (value | 1) if self.status.furniture_detection else (value & -2)
- result = self.set_ai_detection(value)
- else:
- result = self.set_ai_detection({AI_SETTING_FURNITURE: self.status.furniture_detection})
- if result and result[0]["code"] != 0:
- self.status.furniture_detection = current_value
- self._property_changed()
- return result
+ if shortcut_id < 25 or shortcut_id > 128:
+ raise InvalidActionException(f"Invalid shortcut ID: {shortcut_id}")
- def set_fluid_detection(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable AI fluid detection feature."""
- if self.status.ai_detection_available:
- current_value = self.status.fluid_detection
- self.status.fluid_detection = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- value = (value | 8) if self.status.fluid_detection else (value & -9)
- result = self.set_ai_detection(value)
- else:
- result = self.set_ai_detection({AI_SETTING_FLUID: self.status.fluid_detection})
- if result and result[0]["code"] != 0:
- self.status.fluid_detection = current_value
- self._property_changed()
- return result
+ if shortcut_id not in self.status.shortcuts:
+ raise InvalidActionException(f"Shortcut {shortcut_id} not found")
- def set_obstacle_picture(self, enabled: bool) -> dict[str, Any] | None:
- """Enable or disable AI obstacle picture display feature."""
- if self.status.ai_detection_available:
- current_value = self.status.obstacle_picture
- self.status.obstacle_picture = bool(enabled)
- value = self.get_property(DreameVacuumProperty.AI_DETECTION)
- if isinstance(value, int):
- value = (value | 4) if self.status.obstacle_picture else (value & -5)
- result = self.set_ai_detection(value)
- else:
- result = self.set_ai_detection({AI_SETTING_FLUID: self.status.obstacle_picture})
- if result and result[0]["code"] != 0:
- self.status.obstacle_picture = current_value
- self._property_changed()
- return result
+ if shortcut_name and len(shortcut_name) > 0:
+ current_name = self.status.shortcuts[shortcut_id]
+ if current_name != shortcut_name:
+ counter = 1
+ for id, shortcut in self.status.shortcuts.items():
+ if shortcut.name == shortcut_name and id != shortcut_id:
+ counter = counter + 1
- def set_auto_switch_settings(self, settings) -> dict[str, Any] | None:
- if self.status.ai_detection_available:
- self._property_changed()
+ if counter > 1:
+ shortcut_name = f"{shortcut_name}{counter}"
- mapping = self.property_mapping[DreameVacuumProperty.AUTO_SWITCH_SETTINGS]
- return self._protocol.set_property(
- mapping["siid"], mapping["piid"], str(json.dumps(settings, separators=(",", ":"))).replace(" ", ""), 1
- )
+ self.status.shortcuts[shortcut_id].name = shortcut_name
+ shortcut_name = base64.b64encode(shortcut_name.encode("utf-8")).decode("utf-8")
+ self._property_changed(False)
- def set_fill_light(self, enabled: bool) -> dict[str, Any] | None:
- if self.status.auto_switch_settings_available:
- current_value = self.status.fill_light
- self.status.fill_light = 1 if enabled else 0
- result = self.set_auto_switch_settings({"k": "FillinLight", "v": self.status.fill_light})
- if result and result[0]["code"] != 0:
- self.status.fill_light = current_value
- self._property_changed()
- return result
+ success = False
+ response = self.call_shortcut_action(
+ "EDIT_COMMAND",
+ {"id": shortcut_id, "name": shortcut_name, "type": 3},
+ )
+ if response and "out" in response:
+ data = response["out"]
+ if data and len(data):
+ if "value" in data[0] and data[0]["value"] != "":
+ success = data[0]["value"] == "0"
+ if not success:
+ self.status.shortcuts[shortcut_id].name = current_name
+ self._property_changed(False)
+ return response
- def set_collision_avoidance(self, enabled: bool) -> dict[str, Any] | None:
- if self.status.auto_switch_settings_available:
- current_value = self.status.collision_avoidance
- self.status.collision_avoidance = 1 if enabled else 0
- result = self.set_auto_switch_settings({"k": "LessColl", "v": self.status.collision_avoidance})
- if result and result[0]["code"] != 0:
- self.status.collision_avoidance = current_value
- self._property_changed()
- return result
+ def delete_shortcut(self, shortcut_id: int) -> dict[str, Any] | None:
+ """Delete a shortcut"""
+ shortcut_id = int(shortcut_id)
- def set_auto_drying(self, enabled: bool) -> dict[str, Any] | None:
- if self.status.auto_switch_settings_available:
- current_value = self.status.auto_drying
- self.status.auto_drying = 1 if enabled else 0
- result = self.set_auto_switch_settings({"k": "AutoDry", "v": self.status.auto_drying})
- if result and result[0]["code"] != 0:
- self.status.auto_drying = current_value
- self._property_changed()
- return result
- else:
- current_value = self.status.auto_drying
- self.status.auto_drying = 1 if enabled else 0
- if not self.set_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION, self.status.auto_drying):
- self.status.auto_drying = current_value
- self._property_changed()
- return False
- return True
+ if not self.capability.shortcuts or not self.status.shortcuts:
+ raise InvalidActionException("Shortcuts are not supported on this device")
- def set_stain_avoidance(self, stain_avoidance: int) -> dict[str, Any] | None:
- if self.status.auto_switch_settings_available:
- current_value = self.status.stain_avoidance
- self.status.stain_avoidance = stain_avoidance
- result = self.set_auto_switch_settings({"k": "StainIdentify", "v": self.status.stain_avoidance})
- if result and result[0]["code"] != 0:
- self.status.stain_avoidance = current_value
- self._property_changed()
- return result
+ if shortcut_id < 25 or shortcut_id > 128:
+ raise InvalidActionException(f"Invalid shortcut ID: {shortcut_id}")
- def set_mopping_type(self, mopping_type: int) -> dict[str, Any] | None:
- if self.status.auto_switch_settings_available:
- current_value = self.status.mopping_type
- self.status.mopping_type = mopping_type
- result = self.set_auto_switch_settings({"k": "CleanType", "v": self.status.mopping_type})
- if result and result[0]["code"] != 0:
- self.status.mopping_type = current_value
- self._property_changed()
- return result
+ if shortcut_id not in self.status.shortcuts:
+ raise InvalidActionException(f"Shortcut {shortcut_id} not found")
- def set_carpet_recognition(self, value: int) -> dict[str, Any] | None:
- if self.capability.carpet_recognition:
- current_value = self.get_property(DreameVacuumProperty.CARPET_RECOGNITION)
- if current_value is not None:
- if bool(value):
- value = 1
- else:
- value = 3 if self.get_property(DreameVacuumProperty.CARPET_BOOST) == 1 else 0
- if self.set_property(DreameVacuumProperty.CARPET_RECOGNITION, value):
- if value == 1 and current_value == 3:
- self.set_property(DreameVacuumProperty.CARPET_BOOST, 1)
- else:
- self._update_property(DreameVacuumProperty.CARPET_BOOST, 0)
+ current_shortcut = copy.deepcopy(self.status.shortcuts[shortcut_id])
- def set_multi_map(self, enabled: bool) -> bool:
- if self.set_property(DreameVacuumProperty.MULTI_FLOOR_MAP, int(enabled)):
- if (
- self.status.auto_switch_settings_available
- and not enabled
- and self.get_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION) == 1
- ):
- self.set_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION, 0)
- return True
- return False
+ if self.status.started and current_shortcut.running:
+ raise InvalidActionException("Cannot delete this shortcut while vacuum is running")
+
+ del self.status.shortcuts[shortcut_id]
+ self._property_changed(False)
+
+ success = False
+ response = self.call_shortcut_action(
+ "EDIT_COMMAND",
+ {"id": shortcut_id, "type": 4},
+ )
+ if response and "out" in response:
+ data = response["out"]
+ if data and len(data):
+ if "value" in data[0] and data[0]["value"] != "":
+ success = data[0]["value"] == "0"
+ if not success:
+ self.status.shortcuts[shortcut_id] = current_shortcut
+ self._property_changed(False)
+ return response
+
+ def set_obstacle_ignore(self, x, y, obstacle_ignored) -> dict[str, Any] | None:
+ if not self.capability.ai_detection:
+ raise InvalidActionException("Obstacle detection is not available on this device")
+
+ if not self._map_manager:
+ raise InvalidActionException("Obstacle ignore requires cloud connection")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set obstacle ignore status while vacuum is running")
+
+ if not self.status.current_map and not self.status.current_map.obstacles:
+ raise InvalidActionException("Obstacle not found")
+
+ if self.status.current_map.obstacles is None or (
+ len(self.status.current_map.obstacles)
+ and next(iter(self.status.current_map.obstacles.values())).ignore_status is None
+ ):
+ raise InvalidActionException("Obstacle ignore is not supported on this device")
+
+ found = False
+ obstacle_type = 142
+ for k, v in self.status.current_map.obstacles.items():
+ if int(v.x) == int(x) and int(v.y) == int(y):
+ if v.ignore_status.value == 2:
+ raise InvalidActionException("Cannot ignore a dynamically ignored obstacle")
+ obstacle_type = v.type.value
+ found = True
+ break
+
+ if not found:
+ raise InvalidActionException("Obstacle not found")
+
+ self._map_manager.editor.set_obstacle_ignore(x, y, obstacle_ignored)
+ return self.update_map_data_async(
+ {
+ "obstacleignore": [
+ int(x),
+ int(y),
+ obstacle_type,
+ 1 if bool(obstacle_ignored) else 0,
+ ]
+ }
+ )
+
+ def set_router_position(self, x, y):
+ if not self.capability.wifi_map:
+ raise InvalidActionException("WiFi map is not available on this device")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set router position while vacuum is running")
+
+ if self._map_manager:
+ self._map_manager.editor.set_router_position(x, y)
+ return self.update_map_data_async({"wrp": [int(x), int(y)]})
def request_map(self) -> dict[str, Any] | None:
"""Send map request action to the device.
Device will upload a new map on cloud after this command if it has a saved map on memory.
- Otherwise this action will timeout when device is spot cleaning or a restored map exists on memory."""
+ Otherwise this action will timeout when device is spot cleaning or a restored map exists on memory.
+ """
if self._map_manager:
return self._map_manager.request_new_map()
return self.call_action(
DreameVacuumAction.REQUEST_MAP,
- [{"piid": PIID(DreameVacuumProperty.FRAME_INFO, self.property_mapping), "value": '{"frame_type":"I"}'}],
+ [
+ {
+ "piid": PIID(DreameVacuumProperty.FRAME_INFO, self.property_mapping),
+ "value": '{"frame_type":"I"}',
+ }
+ ],
)
+ def update_map_data_async(self, parameters: dict[str, Any]):
+ """Send update map action to the device."""
+ if self._map_manager:
+ self._map_manager.schedule_update(10)
+ self._property_changed(False)
+ self._last_map_request = time.time()
+
+ parameters = [
+ {
+ "piid": PIID(DreameVacuumProperty.MAP_EXTEND_DATA, self.property_mapping),
+ "value": str(json.dumps(parameters, separators=(",", ":"))),
+ }
+ ]
+
+ def callback(result):
+ if result and result.get("code") == 0:
+ _LOGGER.info("Send action UPDATE_MAP_DATA async %s", parameters)
+ self._last_change = time.time()
+ else:
+ _LOGGER.error(
+ "Send action failed UPDATE_MAP_DATA async (%s): %s",
+ parameters,
+ result,
+ )
+
+ self.schedule_update(5)
+
+ if self._map_manager:
+ if self._protocol.dreame_cloud:
+ self._map_manager.schedule_update(3)
+ self._map_manager.request_next_map_list()
+ else:
+ self._last_map_change_time = self._last_change
+ self._map_manager.request_next_map(True)
+ self._map_manager.request_next_map_list()
+ self._last_map_list_request = 0
+
+ mapping = self.action_mapping[DreameVacuumAction.UPDATE_MAP_DATA]
+ self._protocol.action_async(callback, mapping["siid"], mapping["aiid"], parameters)
+
def update_map_data(self, parameters: dict[str, Any]) -> dict[str, Any] | None:
"""Send update map action to the device."""
if self._map_manager:
self._map_manager.schedule_update(10)
- self._property_changed()
+ self._property_changed(False)
self._last_map_request = time.time()
response = self.call_action(
@@ -1913,16 +5774,22 @@ def update_map_data(self, parameters: dict[str, Any]) -> dict[str, Any] | None:
[
{
"piid": PIID(DreameVacuumProperty.MAP_EXTEND_DATA, self.property_mapping),
- "value": str(json.dumps(parameters, separators=(",", ":"))).replace(" ", ""),
+ "value": str(json.dumps(parameters, separators=(",", ":"))),
}
],
)
- self.schedule_update(5)
+ self.schedule_update(5, True)
if self._map_manager:
- self._map_manager.request_next_map()
- self._last_map_list_request = 0
+ if self._protocol.dreame_cloud:
+ self._map_manager.schedule_update(3)
+ self._map_manager.request_next_map_list()
+ else:
+ self._last_map_change_time = self._last_change
+ self._map_manager.request_next_map(True)
+ self._map_manager.request_next_map_list()
+ self._last_map_list_request = 0
return response
@@ -1931,13 +5798,17 @@ def rename_map(self, map_id: int, map_name: str = "") -> dict[str, Any] | None:
if self.status.has_temporary_map:
raise InvalidActionException("Cannot rename a map when temporary map is present")
- if map_name != "":
- map_name = map_name.replace(" ", "-")
- if self._map_manager:
- self._map_manager.editor.set_map_name(map_id, map_name)
- return self.update_map_data({"nrism": {map_id: {"name": map_name}}})
+ if map_name is None:
+ map_name = ""
- def set_map_rotation(self, map_id: int, rotation: int) -> dict[str, Any] | None:
+ if self._map_manager:
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! (%s)", map_id)
+ self._map_manager.editor.set_map_name(map_id, map_name)
+ return self.update_map_data_async({"nrism": {map_id: {"name": map_name if len(map_name) else None}}})
+
+ def set_map_rotation(self, rotation: int, map_id: int = None) -> dict[str, Any] | None:
"""Set rotation of a map"""
if self.status.has_temporary_map:
raise InvalidActionException("Cannot rotate a map when temporary map is present")
@@ -1948,96 +5819,452 @@ def set_map_rotation(self, map_id: int, rotation: int) -> dict[str, Any] | None:
rotation = 0
if self._map_manager:
+ if map_id is None:
+ map_id = self.status.selected_map.map_id
self._map_manager.editor.set_rotation(map_id, rotation)
- return self.update_map_data({"smra": {map_id: {"ra": rotation}}})
+
+ if map_id is not None:
+ return self.update_map_data_async({"smra": {map_id: {"ra": rotation}}})
def set_restricted_zone(self, walls=[], zones=[], no_mops=[]) -> dict[str, Any] | None:
- """Set restricted zones on current map."""
+ """Set restricted zones on current saved map."""
+ if walls == "":
+ walls = []
+ if zones == "":
+ zones = []
+ if no_mops == "":
+ no_mops = []
+
if self._map_manager:
self._map_manager.editor.set_zones(walls, zones, no_mops)
- return self.update_map_data({"vw": {"line": walls, "rect": zones, "mop": no_mops}})
- def select_map(self, map_id: int) -> dict[str, Any] | None:
- """Change currently selected map when multi floor map is enabled."""
- if self.status.multi_map:
- if self._map_manager:
- self._map_manager.editor.select_map(map_id)
- return self.update_map_data({"sm": {}, "mapid": map_id})
+ payload = {"line": walls, "rect": zones, "mop": no_mops}
+ current_map = self.status.current_map
+ if current_map and current_map.saved_map_status != 2: # and self.capability.lidar_navigation:
+ payload["temp"] = {}
- def delete_map(self, map_id: int = None) -> dict[str, Any] | None:
- """Delete a map."""
- if self.status.has_temporary_map:
- raise InvalidActionException("Cannot delete a map when temporary map is present")
+ return self.update_map_data_async({"vw": payload})
+
+ def set_carpet_area(self, carpets=[], deleted_carpets=[]) -> dict[str, Any] | None:
+ """Set carpet areas on current saved map."""
+ if carpets == "":
+ carpets = []
+ if deleted_carpets == "":
+ deleted_carpets = []
if self.status.started:
- raise InvalidActionException("Cannot delete a map while vacuum is running")
+ raise InvalidActionException("Cannot edit carpets while vacuum is running")
if self._map_manager:
- if map_id == 0:
- map_id = None
+ if self.status.current_map and not (
+ self.status.current_map.carpets is not None
+ or self.status.current_map.detected_carpets is not None
+ or self.status.current_map.deleted_carpets is not None
+ ):
+ raise InvalidActionException("Carpets are not supported on this device")
- # Device do not deletes saved maps when you disable multi floor map feature
- # but it deletes all maps if you delete any map when multi floor map is disabled.
- if self.status.multi_map:
- if not map_id and self._map_manager.selected_map:
- map_id = self._map_manager.selected_map.map_id
- else:
- if self._map_manager.selected_map and map_id == self._map_manager.selected_map.map_id:
- self._map_manager.editor.delete_map()
- else:
- self._map_manager.editor.delete_map(map_id)
- parameters = {"cm": {}}
- if map_id:
- parameters["mapid"] = map_id
- return self.update_map_data(parameters)
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit carpets on current map")
- def save_temporary_map(self) -> dict[str, Any] | None:
- """Replace new map with an old one when multi floor map is disabled."""
- if self.status.has_temporary_map:
- if self._map_manager:
- self._map_manager.editor.save_temporary_map()
- return self.update_map_data({"cw": 5})
+ carpets, deleted_carpets, carpet_type, carpet_tassel = self._map_manager.editor.set_carpet_area(
+ carpets, deleted_carpets
+ )
+ else:
+ if not self.capability.carpet_recognition:
+ raise InvalidActionException("Carpets are not supported on this device")
+ data = {"cpt": {"addcpt": carpets, "nocpt": deleted_carpets}}
+ if carpet_type:
+ data["carpetmaterial"] = {"addcpt": carpet_type}
+ if carpet_tassel:
+ data["carpettassel"] = {"addcpt": carpet_tassel}
+ self.update_map_data_async(data)
+
+ def set_carpet_type(
+ self,
+ id: int | list[int],
+ object_type: int | list[int],
+ type: int | list[int] = None,
+ ) -> dict[str, Any] | None:
+ """Set carpet types on current map."""
+ if not self.capability.carpet_type:
+ raise InvalidActionException("Custom carpet type is not supported on this device")
- def discard_temporary_map(self) -> dict[str, Any] | None:
- """Discard new map when device have reached maximum number of maps it can store."""
- if self.status.has_temporary_map:
- if self._map_manager:
- self._map_manager.editor.discard_temporary_map()
- return self.update_map_data({"cw": 0})
+ if self.status.started:
+ raise InvalidActionException("Cannot edit carpets while vacuum is running")
+
+ if id is None or object_type is None:
+ raise InvalidActionException("Missing id or object type")
- def replace_temporary_map(self, map_id: int = None) -> dict[str, Any] | None:
- """Replace new map with an old one when device have reached maximum number of maps it can store."""
if self.status.has_temporary_map:
- if self.status.multi_map:
- raise InvalidActionException("Cannot replace a map when multi floor map is disabled")
+ raise InvalidActionException("Cannot edit carpets when temporary map is present")
- if self._map_manager:
- self._map_manager.editor.replace_temporary_map(map_id)
- parameters = {"cw": 1}
- if map_id:
- parameters["mapid"] = map_id
- return self.update_map_data(parameters)
+ if not isinstance(id, list):
+ id = [id]
- def restore_map(self, map_id: int, map_url: str) -> dict[str, Any] | None:
- """Replace a map with previously saved version by device."""
+ carpet_types = {}
+ index = 0
+ for carpet_id in id:
+ if isinstance(object_type, list):
+ if index < len(object_type):
+ carpet_object_type = object_type[index]
+ else:
+ raise InvalidActionException("Missing object type")
+ else:
+ carpet_object_type = object_type
- if not self.status.has_temporary_map:
- if self._map_manager:
- self._map_manager.editor.restore_map(map_id, map_url)
- self._last_map_request = time.time()
- self._map_manager.schedule_update(10)
+ if isinstance(type, list):
+ if index < len(type):
+ carpet_type = type[index]
+ else:
+ raise InvalidActionException("Missing carpet cleaning")
+ else:
+ carpet_type = type
- mapping = self.property_mapping[DreameVacuumProperty.MAP_RECOVERY]
- response = self._protocol.set_property(
- mapping["siid"],
- mapping["piid"],
- str(json.dumps({"map_id": map_id, "map_url": map_url}, separators=(",", ":"))).replace(" ", ""),
- 1,
- )
+ if not (carpet_object_type == 0 or carpet_object_type == 1 or carpet_object_type == 2):
+ raise InvalidActionException(
+ "Invalid object type: %s (0 = Automatically Detected Carpet, 1 = Manually Created Carpet, 2 = Room Carpet)",
+ carpet_object_type,
+ )
+
+ if carpet_object_type == 2 and not self.capability.carpet_material:
+ raise InvalidActionException("Room carpets are not supported on this device")
+
+ if carpet_type is None or carpet_type == 0:
+ carpet_type = 7
+
+ if not (
+ (carpet_type >= 5 and carpet_type <= 8)
+ or (carpet_object_type == 2 and (carpet_type == 0 or carpet_type == 8))
+ ) or (carpet_type == 8 and not self.capability.floor_mats):
+ raise InvalidActionException("Invalid carpet type: %s", carpet_type)
+ index = index + 1
+
+ if carpet_object_type == 0:
+ key = "origincpt"
+ elif carpet_object_type == 1:
+ key = "addcpt"
+ elif carpet_object_type == 2:
+ key = "roomcpt"
+
+ if key not in carpet_types:
+ carpet_types[key] = []
+ carpet_types[key].append([carpet_id, carpet_type])
+
+ if carpet_types:
+ if self.capability.map:
+ current_map = self.status.current_map
+ if current_map:
+ carpet_types = self._map_manager.editor.set_carpet_type(carpet_types)
+ if not carpet_types:
+ raise InvalidActionException("Cannot find selected carpet(s)")
+
+ return self.update_map_data_async({"carpetmaterial": carpet_types})
+
+ def set_virtual_threshold(self, virtual_thresholds=[]) -> dict[str, Any] | None:
+ """Set virtual thresholds on current saved map."""
+ if virtual_thresholds == "" or not virtual_thresholds:
+ virtual_thresholds = []
+
+ if self._map_manager:
+ if self.status.current_map and not (
+ self.status.current_map.virtual_thresholds is not None
+ or self.status.current_map.passable_thresholds is not None
+ or self.capability.floor_material
+ ):
+ raise InvalidActionException("Virtual thresholds are not supported on this device")
+
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit virtual thresholds on current map")
+ self._map_manager.editor.set_virtual_thresholds(virtual_thresholds)
+ else:
+ if not (
+ self.get_property(DreameVacuumProperty.CARPET_RECOGNITION) is not None
+ or self.get_property(DreameVacuumProperty.CARPET_CLEANING) is not None
+ ):
+ raise InvalidActionException("Virtual thresholds are not supported on this device")
+ return self.update_map_data_async({"vws": {"vwsl": virtual_thresholds}})
+
+ def set_threshold(self, passable_thresholds=[], impassable_thresholds=[], ramps=[]) -> dict[str, Any] | None:
+ """Set thresholds on current saved map."""
+ if passable_thresholds == "" or not passable_thresholds:
+ passable_thresholds = []
+ if impassable_thresholds == "" or not impassable_thresholds:
+ impassable_thresholds = []
+ if ramps == "" or not ramps:
+ ramps = []
+
+ if self._map_manager:
+ if self.status.current_map and not (
+ self.status.current_map.passable_thresholds is not None
+ or self.status.current_map.impassable_thresholds is not None
+ or self.status.current_map.ramps is not None
+ ):
+ raise InvalidActionException("Thresholds are not supported on this device")
+
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit thresholds on current map")
+ self._map_manager.editor.set_thresholds(passable_thresholds, impassable_thresholds, ramps)
+ return self.update_map_data_async(
+ {"vws": {"vwsl": passable_thresholds, "npthrsd": impassable_thresholds, "ramp": ramps}}
+ )
+
+ def set_furniture(self, furnitures=[]) -> dict[str, Any] | None:
+ """Set furnitures on current saved map."""
+ if furnitures == "" or not furnitures:
+ furnitures = []
+
+ if self._map_manager:
+ if self.status.current_map and not self.status.current_map.furniture_version:
+ raise InvalidActionException("Furnitures are not supported on this device")
+
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit furnitures on current map")
+
+ return self.update_map_data_async(self._map_manager.editor.set_furnitures(furnitures))
+
+ def set_curtain(self, curtains=[]) -> dict[str, Any] | None:
+ """Set curtains on current saved map."""
+ if curtains == "" or not curtains:
+ curtains = []
+
+ if self._map_manager:
+ if self.status.current_map and self.status.current_map.curtains is None:
+ raise InvalidActionException("Curtains are not supported on this device")
+
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit curtains on current map")
+ self._map_manager.editor.set_curtains(curtains)
+ return self.update_map_data_async({"curtain": {"line": curtains}})
+
+ def set_low_lying_area(self, areas=[]) -> dict[str, Any] | None:
+ """Set low lying areas on current saved map."""
+ if areas == "" or not areas:
+ areas = []
+
+ if self._map_manager:
+ if self.status.current_map and self.status.current_map.low_lying_areas is None:
+ raise InvalidActionException("Low lying areas are not supported on this device")
+
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit low lying areas on current map")
+
+ raise InvalidActionException("Low lying area editing not supported yet!")
+
+ def set_predefined_points(self, points=[]) -> dict[str, Any] | None:
+ """Set predefined points on current saved map."""
+ if points == "" or not points:
+ points = []
+
+ if not self.capability.cruising:
+ raise InvalidActionException("Predefined points are not supported on this device")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set predefined points while vacuum is running")
+
+ if self._map_manager and self.status.current_map:
+ for point in points:
+ if not self.status.current_map.check_point(point[0], point[1]):
+ raise InvalidActionException(f"Coordinate ({point[0]}, {point[1]}) is not inside the map")
+
+ predefined_points = []
+ for point in points:
+ predefined_points.append([point[0], point[1], 0, 1])
+
+ if self._map_manager:
+ if self.status.current_map and not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit predefined points on current map")
+ self._map_manager.editor.set_predefined_points(predefined_points[:20])
+
+ return self.update_map_data_async({"spoint": predefined_points[:20], "tpoint": []})
+
+ def set_selected_map(self, map_id: int) -> dict[str, Any] | None:
+ """Change currently selected map when multi floor map is enabled."""
+ if self._map_manager:
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! (%s)", map_id)
+ self._map_manager.editor.set_selected_map(map_id)
+ self._map_select_time = time.time()
+ return self.update_map_data({"sm": {}, "mapid": map_id})
+
+ def delete_map(self, map_id: int = None) -> dict[str, Any] | None:
+ """Delete a map."""
+ map_id = int(map_id)
+
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot delete a map when temporary map is present")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot delete a map while vacuum is running")
+
+ if self._map_manager:
+ if map_id is not None and map_id != 0:
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! (%s)", map_id)
+
+ if map_id == 0:
+ map_id = None
+ # Device do not deletes saved maps when you disable multi floor map feature
+ # but it deletes all maps if you delete any map when multi floor map is disabled.
+ if self.status.multi_map:
+ if not map_id and self._map_manager.selected_map:
+ map_id = self._map_manager.selected_map.map_id
+ self._map_manager.editor.delete_map(map_id)
+ else:
+ if self._map_manager.selected_map and map_id == self._map_manager.selected_map.map_id:
+ self._map_manager.editor.delete_map()
+ else:
+ self._map_manager.editor.delete_map(map_id)
+ parameters = {"cm": {}}
+ if map_id:
+ parameters["mapid"] = map_id
+ return self.update_map_data(parameters)
+
+ def save_temporary_map(self) -> dict[str, Any] | None:
+ """Replace new map with an old one when multi floor map is disabled."""
+ if self.status.has_temporary_map:
if self._map_manager:
- self._map_manager.request_next_map()
+ self._map_manager.editor.save_temporary_map()
+ return self.update_map_data({"cw": 5})
+
+ def discard_temporary_map(self) -> dict[str, Any] | None:
+ """Discard new map when device have reached maximum number of maps it can store."""
+ if self.status.has_temporary_map:
+ if self._map_manager:
+ self._map_manager.editor.discard_temporary_map()
+ return self.update_map_data({"cw": 0})
+
+ def replace_temporary_map(self, map_id: int = None) -> dict[str, Any] | None:
+ """Replace new map with an old one when device have reached maximum number of maps it can store."""
+ if self.status.has_temporary_map:
+ if self._map_manager:
+ self._map_manager.editor.replace_temporary_map(map_id)
+ parameters = {"cw": 1}
+ if map_id:
+ parameters["mapid"] = map_id
+ return self.update_map_data(parameters)
+
+ def restore_map_from_file(self, map_url: int, map_id: int = None) -> dict[str, Any] | None:
+ map_recovery_status = self.status.map_recovery_status
+ if map_recovery_status is None:
+ raise InvalidActionException("Map recovery is not supported on this device")
+
+ if map_recovery_status == DreameVacuumMapRecoveryStatus.RUNNING.value:
+ raise InvalidActionException("Map recovery in progress")
+
+ if map_id is None or map_id == "":
+ if self.status.selected_map is None:
+ raise InvalidActionException("Map ID is required")
+
+ map_id = self.status.selected_map.map_id
+
+ if self.status.map_data_list and not (map_id in self.status.map_data_list):
+ raise InvalidActionException("Map not found")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set restore a map while vacuum is running")
+
+ self.schedule_update(15)
+ if self._map_manager:
+ self._last_map_request = time.time()
+ self._map_manager.schedule_update(15)
+
+ self._update_property(
+ DreameVacuumProperty.MAP_RECOVERY_STATUS,
+ DreameVacuumMapRecoveryStatus.RUNNING.value,
+ )
+ mapping = self.property_mapping[DreameVacuumProperty.MAP_RECOVERY]
+ response = self._protocol.set_property(
+ mapping["siid"],
+ mapping["piid"],
+ str(json.dumps({"map_id": map_id, "map_url": map_url}, separators=(",", ":"))).replace(" ", ""),
+ )
+ if not response or response[0]["code"] != 0:
+ self._update_property(DreameVacuumProperty.MAP_RECOVERY_STATUS, map_recovery_status)
+ raise InvalidActionException("Map recovery failed with error code %s", response[0]["code"])
+ self._map_manager.schedule_update(5)
+ self.schedule_update(1)
+ return response
+
+ def restore_map(self, recovery_map_index: int, map_id: int = None) -> dict[str, Any] | None:
+ """Replace a map with previously saved version by device."""
+ map_recovery_status = self.status.map_recovery_status
+ if map_recovery_status is None:
+ raise InvalidActionException("Map recovery is not supported on this device")
+
+ if not self._map_manager:
+ raise InvalidActionException("Map recovery requires cloud connection")
+
+ if map_recovery_status == DreameVacuumMapRecoveryStatus.RUNNING.value:
+ raise InvalidActionException("Map recovery in progress")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set restore a map while vacuum is running")
+
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Restore a map when temporary map is present")
+
+ if (map_id is None or map_id == "") and self.status.selected_map:
+ map_id = self.status.selected_map.map_id
+
+ if not map_id or map_id not in self.status.map_data_list:
+ raise InvalidActionException("Map not found")
+
+ if len(self.status.map_data_list[map_id].recovery_map_list) <= int(recovery_map_index) - 1:
+ raise InvalidActionException("Invalid recovery map index")
+
+ recovery_map_info = self.status.map_data_list[map_id].recovery_map_list[int(recovery_map_index) - 1]
+ object_name = recovery_map_info.object_name
+ if object_name and object_name != "":
+ file, map_url, object_name = self.recovery_map_file(map_id, recovery_map_index)
+ if map_url == None:
+ raise InvalidActionException("Failed get recovery map file url: %s", object_name)
+
+ if file == None:
+ raise InvalidActionException("Failed to download recovery map file: %s", map_url)
+
+ response = self.restore_map_from_file(map_url, map_id)
+ if response and response[0]["code"] == 0:
+ self._map_manager.editor.restore_map(recovery_map_info)
return response
+ raise InvalidActionException("Invalid recovery map object name")
+
+ def backup_map(self, map_id: int = None) -> dict[str, Any] | None:
+ """Save a map map to cloud for later use of restoring."""
+ if not self.capability.backup_map:
+ raise InvalidActionException("Map backup is not supported on this device")
+
+ if self.status.map_backup_status == DreameVacuumMapBackupStatus.RUNNING.value:
+ raise InvalidActionException("Map backup in progress")
+
+ if map_id is None or map_id == "":
+ if self.status.selected_map is None:
+ raise InvalidActionException("Map ID is required")
+
+ map_id = self.status.selected_map.map_id
+
+ if self.status.map_data_list and not (map_id in self.status.map_data_list):
+ raise InvalidActionException("Map not found")
+
+ response = self.call_action(
+ DreameVacuumAction.BACKUP_MAP,
+ [
+ {
+ "piid": PIID(DreameVacuumProperty.MAP_EXTEND_DATA, self.property_mapping),
+ "value": str(map_id),
+ }
+ ],
+ )
+ self.schedule_update(3, True)
+ if response and response.get("code") == 0:
+ self._last_map_change_time = time.time()
+ self._update_property(
+ DreameVacuumProperty.MAP_BACKUP_STATUS,
+ DreameVacuumMapBackupStatus.RUNNING.value,
+ )
+ return response
def merge_segments(self, map_id: int, segments: list[int]) -> dict[str, Any] | None:
"""Merge segments on a map"""
@@ -2050,19 +6277,19 @@ def merge_segments(self, map_id: int, segments: list[int]) -> dict[str, Any] | N
if self._map_manager:
if not map_id:
- if self.status.lidar_navigation and self._map_manager.selected_map:
+ if self.capability.lidar_navigation and self._map_manager.selected_map:
map_id = self._map_manager.selected_map.map_id
else:
map_id = 0
- self._map_manager.editor.merge_segments(map_id, segments)
- if not map_id and self.status.lidar_navigation:
+ if map_id != self._map_manager.selected_map.map_id and self.capability.lidar_navigation:
+ if not self.set_selected_map(map_id):
+ raise InvalidActionException("Failed to select map")
+
+ if not map_id and self.capability.lidar_navigation:
raise InvalidActionException("Map ID is required")
- data = {"msr": [segments[0], segments[1]]}
- if map_id:
- data["mapid"] = map_id
- return self.update_map_data(data)
+ return self.update_map_data({"msr": [segments[0], segments[1]], "mapid": map_id})
def split_segments(self, map_id: int, segment: int, line: list[int]) -> dict[str, Any] | None:
"""Split segments on a map"""
@@ -2075,25 +6302,28 @@ def split_segments(self, map_id: int, segment: int, line: list[int]) -> dict[str
if self._map_manager:
if not map_id:
- if self.status.lidar_navigation and self._map_manager.selected_map:
+ if self.capability.lidar_navigation and self._map_manager.selected_map:
map_id = self._map_manager.selected_map.map_id
else:
map_id = 0
- self._map_manager.editor.split_segments(map_id, segment, line)
- if not map_id and self.status.lidar_navigation:
+ if map_id != self._map_manager.selected_map.map_id and self.capability.lidar_navigation:
+ if not self.set_selected_map(map_id):
+ raise InvalidActionException("Failed to select map")
+
+ if not map_id and self.capability.lidar_navigation:
raise InvalidActionException("Map ID is required")
line.append(segment)
- data = {"dsrid": line}
- if map_id:
- data["mapid"] = map_id
- return self.update_map_data(data)
+ return self.update_map_data({"dsrid": line, "mapid": map_id})
def set_cleaning_sequence(self, cleaning_sequence: list[int]) -> dict[str, Any] | None:
"""Set cleaning sequence on current map.
Device will use this order even you specify order in segment cleaning."""
+ if not self.capability.customized_cleaning:
+ raise InvalidActionException("Cleaning sequence is not supported on this device")
+
if self.status.has_temporary_map:
raise InvalidActionException("Cannot edit segments when temporary map is present")
@@ -2104,33 +6334,188 @@ def set_cleaning_sequence(self, cleaning_sequence: list[int]) -> dict[str, Any]
cleaning_sequence = []
if self._map_manager:
- if (
- cleaning_sequence
- and self.status.segments
- and len(cleaning_sequence) != len(self.status.segments.items())
- ):
- raise InvalidValueException("Invalid size for cleaning sequence")
+ if not self.status.has_saved_map:
+ raise InvalidActionException("Cannot set cleaning sequence on current map")
+
+ if self.capability.cleaning_sequence_v2 and not cleaning_sequence:
+ raise InvalidActionException("Cannot disable cleaning sequence on this device")
+
+ if cleaning_sequence and self.status.segments:
+ for k in cleaning_sequence:
+ if int(k) not in self.status.segments.keys():
+ raise InvalidValueException("Segment not found! (%s)", k)
+
+ map_data = self.status.current_map
+ if map_data and map_data.segments and not map_data.temporary_map:
+ if not cleaning_sequence and not self.capability.cleaning_sequence_v2:
+ current = self._map_manager.cleaning_sequence
+ if current and len(current):
+ self.status._previous_cleaning_sequence[map_data.map_id] = current
+ elif map_data.map_id in self.status._previous_cleaning_sequence:
+ del self.status._previous_cleaning_sequence[map_data.map_id]
+
+ cleaning_sequence = self._map_manager.editor.set_cleaning_sequence(cleaning_sequence)
+ else:
+ raise InvalidActionException("Cannot set cleaning sequence on current map")
+ elif self.capability.cleaning_sequence_v2:
+ raise InvalidActionException("Cannot set cleaning sequence without map data on this device")
- cleaning_sequence = self._map_manager.editor.set_cleaning_sequence(cleaning_sequence)
+ if not cleaning_sequence:
+ raise InvalidActionException("Cannot set cleaning sequence current map")
- return self.update_map_data({"cleanOrder": cleaning_sequence})
+ return self.update_map_data_async(
+ {"cleanareaorder": [{str(item): i} for i, item in enumerate(cleaning_sequence, 1)]}
+ if self.capability.cleaning_sequence_v2
+ else {"cleanOrder": cleaning_sequence}
+ )
def set_cleanset(self, cleanset: dict[str, list[int]]) -> dict[str, Any] | None:
- """Set customized cleaning settings on current map.
- Device will use these settings even you pass another setting for custom segment cleaning."""
-
+ """Set customized cleaning settings on current map. Device will use these settings even you pass another setting for custom segment cleaning."""
if self.status.has_temporary_map:
- raise InvalidActionException("Cannot edit segments when temporary map is present")
+ raise InvalidActionException("Cannot edit customized cleaning settings when temporary map is present")
if cleanset is not None:
- return self.update_map_data({"customeClean": cleanset})
+ return self.update_map_data_async({"customeClean": cleanset})
def set_custom_cleaning(
- self, segment_id: list[int], suction_level: list[int], water_volume: list[int], cleaning_times: list[int]
+ self,
+ segment_id: list[int],
+ suction_level: list[int],
+ water_volume: list[int],
+ cleaning_times: list[int],
+ cleaning_mode: list[int] = None,
+ custom_mopping_route: list[int] = None,
+ cleaning_route: list[int] = None,
+ wetness_level: list[int] = None,
+ mop_temperature: list[int] = None,
+ mop_pressure: list[int] = None,
) -> dict[str, Any] | None:
"""Set customized cleaning settings on current map.
- Device will use these settings even you pass another setting for custom segment cleaning."""
+ Device will use these settings even you pass another setting for custom segment cleaning.
+ """
+
+ if not self.capability.customized_cleaning:
+ raise InvalidActionException("Customized cleaning is not supported on this device")
+
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit customized cleaning parameters when temporary map is present")
+ if self.status.started:
+ raise InvalidActionException("Cannot edit customized cleaning parameters while vacuum is running")
+
+ if suction_level is not None:
+ for v in suction_level:
+ if int(v) < 0 or int(v) > 3:
+ raise InvalidActionException("Invalid suction level: %s", v)
+
+ if water_volume is not None:
+ for v in water_volume:
+ if int(v) < 1 or int(v) > 3:
+ raise InvalidActionException("Invalid water volume: %s", v)
+
+ if cleaning_times is not None:
+ for v in cleaning_times:
+ if int(v) < 1 or int(v) > 3:
+ raise InvalidActionException("Invalid cleaning times: %s", v)
+
+ if cleaning_mode is not None:
+ for v in cleaning_mode:
+ if int(v) < 0 or int(v) > 2:
+ raise InvalidActionException("Invalid cleaning mode: %s", v)
+
+ if custom_mopping_route is not None:
+ if self.capability.segment_mopping_settings and not self.capability.cleaning_route:
+ if not self.capability.map:
+ raise InvalidActionException("Cannot set custom mopping route without map support")
+ for v in custom_mopping_route:
+ if int(v) < -1 or int(v) > 2:
+ raise InvalidActionException("Invalid custom mopping route: %s", v)
+ else:
+ raise InvalidActionException("Custom mopping route is not supported on this device")
+
+ if cleaning_route is not None:
+ if self.capability.cleaning_route:
+ if not self.capability.map:
+ raise InvalidActionException("Cannot set cleaning route without map support")
+ for v in cleaning_route:
+ if int(v) < 1 or int(v) > (3 if self.capability.segment_slow_clean_route else 4):
+ raise InvalidActionException("Invalid cleaning route: %s", v)
+ else:
+ raise InvalidActionException("Cleaning route is not supported on this device")
+
+ if wetness_level is not None:
+ if self.capability.wetness_level:
+ if not self.capability.map:
+ raise InvalidActionException("Cannot set wetness level without map support")
+ for v in wetness_level:
+ if int(v) < 1 or int(v) > 32:
+ raise InvalidActionException("Invalid wetness level: %s", v)
+ else:
+ raise InvalidActionException("Wetness level is not supported on this device")
+
+ if mop_temperature is not None:
+ if self.capability.mop_temperature:
+ for v in mop_temperature:
+ if not self.capability.map:
+ raise InvalidActionException("Cannot set mop temperature without map support")
+ if int(v) < 0 or int(v) > 1:
+ raise InvalidActionException("Invalid mop temperature: %s", v)
+ else:
+ raise InvalidActionException("Mop temperature is not supported on this device")
+
+ if mop_pressure is not None:
+ if self.capability.mop_pressure:
+ for v in mop_pressure:
+ if not self.capability.map:
+ raise InvalidActionException("Cannot set mop pressure without map support")
+ if int(v) != 0 and int(v) != 2:
+ raise InvalidActionException("Invalid mop pressure: %s", v)
+ else:
+ raise InvalidActionException("Mop pressure is not supported on this device")
+
+ if self.capability.map:
+ if not self.status.has_saved_map:
+ raise InvalidActionException("Cannot edit customized cleaning parameters on current map")
+
+ current_map = self.status.current_map
+ if current_map:
+ segments = self.status.segments
+ index = 0
+ if not segment_id or segment_id == "":
+ raise InvalidActionException("Segment ID is required")
+
+ for k in segment_id:
+ id = int(k)
+ if not segments or id not in segments:
+ raise InvalidActionException("Invalid Segment ID: %s", id)
+ self._map_manager.editor.set_segment_suction_level(id, int(suction_level[index]), False)
+ if self.capability.wetness_level and wetness_level is not None:
+ self._map_manager.editor.set_segment_wetness_level(id, int(wetness_level[index]), False)
+ else:
+ self._map_manager.editor.set_segment_water_volume(id, int(water_volume[index]), False)
+ if self.capability.mop_temperature and mop_temperature is not None:
+ self._map_manager.editor.set_segment_mop_temperature(id, int(mop_temperature[index]), False)
+ if self.capability.mop_pressure and mop_pressure is not None:
+ self._map_manager.editor.set_segment_mop_pressure(id, int(mop_pressure[index]), False)
+ self._map_manager.editor.set_segment_cleaning_times(id, int(cleaning_times[index]), False)
+ if self.capability.custom_cleaning_mode and cleaning_mode is not None:
+ self._map_manager.editor.set_segment_cleaning_mode(id, int(cleaning_mode[index]), False)
+ if (
+ self.capability.segment_mopping_settings
+ and not self.capability.cleaning_route
+ and custom_mopping_route is not None
+ ):
+ self._map_manager.editor.set_segment_custom_mopping_route(
+ id, int(custom_mopping_route[index]), False
+ )
+ elif self.capability.cleaning_route and cleaning_route is not None:
+ self._map_manager.editor.set_segment_cleaning_route(id, int(cleaning_route[index]), False)
+ index = index + 1
+ self._map_manager.editor.refresh_map()
+ return self.set_cleanset(self._map_manager.editor.cleanset(current_map))
+
+ custom_cleaning_mode = self.capability.custom_cleaning_mode
+ has_cleaning_mode = cleaning_mode != "" and cleaning_mode is not None
if (
segment_id != ""
and segment_id
@@ -2141,178 +6526,661 @@ def set_custom_cleaning(
and cleaning_times != ""
and cleaning_times is not None
):
- segments = self.status.segments
+ if has_cleaning_mode and not custom_cleaning_mode:
+ raise InvalidActionException(
+ "Setting custom cleaning mode for segments is not supported by the device!"
+ )
+ elif not has_cleaning_mode and custom_cleaning_mode:
+ raise InvalidActionException("Cleaning mode is required")
+
if segments:
count = len(segments.items())
if (
len(segment_id) != count
or len(suction_level) != count
or len(water_volume) != count
- or len(cleaning_times) != cleaning_times
+ or len(cleaning_times) != count
+ or (custom_cleaning_mode and cleaning_mode is not None and len(cleaning_mode) != count)
):
- return
+ raise InvalidActionException("Parameter count mismatch!")
custom_cleaning = []
index = 0
- for segment in segment_id:
- custom_cleaning.append(
- # for some reason cleanset uses different int values for water volume
- [segment, suction_level[index], water_volume[index] + 1, cleaning_times[index]]
- )
+ water_level = water_volume[index]
+ if self.capability.wetness_level:
+ if water_level == 1:
+ water_level = 5
+ elif water_level == 3:
+ water_level = 27
+ else:
+ water_level = 16
+ else:
+ water_level = water_level + 1
+
+ for id in segment_id:
+ # for some reason cleanset uses different int values for water volume
+ values = [
+ id,
+ suction_level[index],
+ water_level,
+ cleaning_times[index],
+ ]
+ if custom_cleaning_mode:
+ values.append(cleaning_mode[index])
+ if segments:
+ if id not in segments:
+ raise InvalidActionException("Invalid Segment ID: %s", id)
+
+ if segments[id].custom_mopping_route is not None:
+ mopping_values = DreameVacuumMapDecoder.split_mopping_settings(
+ segments[id].mopping_settings
+ )
+ if mopping_values:
+ if self.capability.wetness_level:
+ mopping_values[1] = 0
+ mopping_values[2] = 0
+ else:
+ # Set mopping mode or water volume according to the mopping effect switch
+ mopping_values[2 if segments[id].custom_mopping_route == -1 else 1] = water_volume[
+ index
+ ]
+ values.append(DreameVacuumMapDecoder.combine_mopping_settings(mopping_values))
+ else:
+ values.append(segments[id].mopping_settings)
+ custom_cleaning.append(values)
index = index + 1
return self.set_cleanset(custom_cleaning)
- def set_segment_name(self, segment_id: int, segment_type: int, custom_name: str = None) -> dict[str, Any] | None:
- """Update name of a segment on current map"""
- if self.status.has_temporary_map:
- raise InvalidActionException("Cannot edit segment when temporary map is present")
+ raise InvalidActionException("Missing parameters!")
- if self._map_manager:
- segment_info = self._map_manager.editor.set_segment_name(segment_id, segment_type, custom_name)
- if segment_info:
- return self.update_map_data({"nsr": segment_info})
+ def set_custom_carpet_cleaning(
+ self,
+ id: int | list[int],
+ object_type: int | list[int],
+ carpet_cleaning: int | list[int] = None,
+ carpet_preferences: list[int] | list[list[int]] = None,
+ ) -> dict[str, Any] | None:
+ """Set customized carpet cleaning settings on current map."""
+ if not self.capability.carpet_recognition:
+ raise InvalidActionException("Custom carpet cleaning is not supported on this device")
- def set_segment_order(self, segment_id: int, order: int) -> dict[str, Any] | None:
- """Update cleaning order of a segment on current map"""
- if self._map_manager and not self.status.has_temporary_map:
- return self.update_map_data({"cleanOrder": self._map_manager.editor.set_segment_order(segment_id, order)})
+ if carpet_preferences is not None and not self.capability.carpet_cleanset_v3:
+ raise InvalidActionException("Custom carpet preferences is not supported on this device")
- def set_segment_suction_level(self, segment_id: int, suction_level: int) -> dict[str, Any] | None:
- """Update suction level of a segment on current map"""
- if self._map_manager and not self.status.has_temporary_map:
- return self.set_cleanset(self._map_manager.editor.set_segment_suction_level(segment_id, suction_level))
+ if id is None or object_type is None:
+ raise InvalidActionException("Missing id or object type")
- def set_segment_water_volume(self, segment_id: int, water_volume: int) -> dict[str, Any] | None:
- """Update water volume of a segment on current map"""
- if not self.status.self_wash_base_available and self._map_manager and not self.status.has_temporary_map:
- return self.set_cleanset(self._map_manager.editor.set_segment_water_volume(segment_id, water_volume))
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit carpets when temporary map is present")
- def set_segment_mop_pad_humidity(self, segment_id: int, mop_pad_humidity: int) -> dict[str, Any] | None:
- """Update mop pad humidity of a segment on current map"""
- if self.status.self_wash_base_available and self._map_manager and not self.status.has_temporary_map:
- return self.set_cleanset(self._map_manager.editor.set_segment_water_volume(segment_id, mop_pad_humidity))
+ if not isinstance(id, list):
+ id = [id]
- def set_segment_cleaning_times(self, segment_id: int, cleaning_times: int) -> dict[str, Any] | None:
- """Update cleaning times of a segment on current map."""
- if self.status.started:
- raise InvalidActionException("Cannot set room cleaning times while vacuum is running")
+ carpet_cleanset = []
+ index = 0
+ for carpet_id in id:
+ if isinstance(object_type, list):
+ if index < len(object_type):
+ carpet_object_type = object_type[index]
+ else:
+ raise InvalidActionException("Missing object type")
+ else:
+ carpet_object_type = object_type
- if self._map_manager and not self.status.has_temporary_map:
- return self.set_cleanset(self._map_manager.editor.set_segment_cleaning_times(segment_id, cleaning_times))
+ if isinstance(carpet_cleaning, list):
+ if index < len(carpet_cleaning):
+ cleaning_setting = carpet_cleaning[index]
+ else:
+ raise InvalidActionException("Missing carpet cleaning")
+ else:
+ cleaning_setting = carpet_cleaning
- @property
- def _update_interval(self) -> float:
- """Dynamic update interval of the device for the timer."""
- now = time.time()
- if self._last_update_failed:
- return 5 if now - self._last_update_failed <= 60 else 10 if now - self._last_update_failed <= 300 else 30
- if not -self._last_change <= 60:
- return 3 if self.status.active else 5
- if self.status.active or self.status.started:
- return 3 if self.status.running else 5
- if self._map_manager:
- return min(self._map_update_interval, 5 if not self._protocol.prefer_cloud else 10)
- return 5 if not self._protocol.prefer_cloud else 10
+ if (
+ carpet_preferences is not None
+ and isinstance(carpet_preferences, list)
+ and carpet_preferences
+ and isinstance(carpet_preferences[0], list)
+ ):
+ if index < len(carpet_preferences):
+ enabled_settings = carpet_preferences[index]
+ else:
+ enabled_settings = None
+ else:
+ enabled_settings = carpet_preferences
- @property
- def _map_update_interval(self) -> float:
- """Dynamic map update interval for the map manager."""
- if self._map_manager:
- now = time.time()
- if now - self._last_map_request <= 120 or now - self._last_change <= 60:
- return 2.5 if self.status.active or self.status.started else 5
- return 3 if self.status.running else 10 if self.status.active else 30
- return -1
+ if not (carpet_object_type == 0 or carpet_object_type == 1 or carpet_object_type == 2):
+ raise InvalidActionException(
+ "Invalid object type: %s (0 = Automatically Detected Carpet, 1 = Manually Created Carpet, 2 = Room Carpet)",
+ carpet_object_type,
+ )
- @property
- def name(self) -> str:
- """Return the name of the device."""
- return self._name
+ if carpet_object_type == 2 and not self.capability.carpet_material:
+ raise InvalidActionException("Room carpets are not supported on this device: %s", cleaning_setting)
- @property
- def device_connected(self) -> bool:
- """Return connection status of the device."""
- return self._protocol.connected
+ if cleaning_setting is None or cleaning_setting == 0:
+ cleaning_setting = -1
- @property
- def cloud_connected(self) -> bool:
- """Return connection status of the device."""
- return self._protocol.cloud and self._protocol.cloud.logged_in and self._protocol.cloud.connected
+ if not (cleaning_setting >= -1 and cleaning_setting <= 7):
+ raise InvalidActionException("Invalid carpet cleaning setting: %s", cleaning_setting)
+ if (
+ cleaning_setting == 4
+ and (
+ not self.capability.mop_pad_lifting_plus
+ or self.capability.auto_carpet_cleaning
+ or self.capability.carpet_crossing
+ )
+ ) or (
+ cleaning_setting == 6
+ and (not self.capability.mop_pad_lifting_plus and not self.capability.auto_carpet_cleaning)
+ ):
+ raise InvalidActionException(
+ "Selected cleaning setting is not supported on this device: %s", cleaning_setting
+ )
-class DreameVacuumDeviceStatus:
- """Helper class for device status and int enum type properties.
- This class is used for determining various states of the device by its properties.
+ index = index + 1
+ cleanset = [carpet_object_type, carpet_id, cleaning_setting]
+
+ if self.capability.carpet_cleanset_v3:
+ if cleaning_setting == -1 or enabled_settings is None:
+ settings = -1
+ else:
+ settings = 0
+ if self.capability.clean_carpets_first and "clean_carpets_first" in enabled_settings:
+ settings |= 1
+ if (
+ self.get_property(DreameVacuumProperty.CARPET_BOOST) is not None
+ and "carpet_boost" in enabled_settings
+ ):
+ settings |= 2
+ if self.capability.intensive_carpet_cleaning and "intensive_carpet_cleaning" in enabled_settings:
+ settings |= 4
+ if self.capability.side_brush_carpet_rotate and "side_brush_carpet_rotate" in enabled_settings:
+ settings |= 8
+ if self.capability.lift_chassis_on_carpet and "lift_chassis_on_carpet" in enabled_settings:
+ settings |= 16
+
+ cleanset.append(settings)
+ carpet_cleanset.append(cleanset)
+
+ if carpet_cleanset:
+ if self.capability.map:
+ current_map = self.status.current_map
+ if current_map:
+ if current_map.carpet_cleanset is None:
+ raise InvalidActionException("Cannot set sustom carpet cleaning on selected map")
+ carpet_cleanset = self._map_manager.editor.set_custom_carpet_cleaning(carpet_cleanset)
+ if not carpet_cleanset:
+ raise InvalidActionException("Cannot find selected carpet(s)")
+
+ return self.update_map_data_async({"carpetcleanset": carpet_cleanset})
+
+ def set_floor_material(
+ self,
+ material: dict[int, int],
+ map_id: int = None,
+ ) -> dict[str, Any] | None:
+ """Update segment floor materials"""
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit segments when temporary map is present")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set floor material while vacuum is running")
+
+ if self._map_manager:
+ if not map_id:
+ if not self.status.selected_map:
+ raise InvalidActionException("Map ID is required")
+
+ map_id = self.status.selected_map.map_id
+
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! ({map_id})")
+
+ if map_id != self._map_manager.selected_map.map_id:
+ if not self.set_selected_map(map_id):
+ raise InvalidActionException("Failed to select map")
+
+ material_info, carpet_type = self._map_manager.editor.set_floor_material(material, map_id)
+ data = {"nsm": material_info, "mapid": map_id}
+ if carpet_type:
+ data["carpetmaterial"] = {"roomcpt": carpet_type}
+ self.update_map_data_async(data)
+
+ def set_hidden_segments(self, hidden_segments: list[int], map_id=None):
+ if not self.capability.segment_visibility:
+ raise InvalidActionException("Segment visibility is not supported on this device")
+
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit segments when temporary map is present")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set hidden segments while vacuum is running")
+
+ if hidden_segments == "" or not hidden_segments:
+ hidden_segments = []
+
+ if self._map_manager:
+ if not map_id:
+ if not self.status.selected_map:
+ raise InvalidActionException("Map ID is required")
+
+ map_id = self.status.selected_map.map_id
+
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! ({map_id})")
+
+ if map_id != self._map_manager.selected_map.map_id:
+ if not self.set_selected_map(map_id):
+ raise InvalidActionException("Failed to select map")
+
+ return self.update_map_data_async(
+ {"delsr": self._map_manager.editor.set_hidden_segments(hidden_segments, map_id), "mapid": map_id}
+ )
+
+ def set_mop_type(
+ self,
+ mop_type: dict[int, str],
+ map_id: int = None,
+ ) -> dict[str, Any] | None:
+ """Update segment mop types"""
+ if not self.capability.auto_change_mop:
+ raise InvalidActionException("Segment mop type is not supported on this device")
+
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit segments when temporary map is present")
+
+ if self.status.started:
+ raise InvalidActionException("Cannot set mop type while vacuum is running")
+
+ if self._map_manager:
+ if not map_id:
+ if not self.status.selected_map:
+ raise InvalidActionException("Map ID is required")
+
+ map_id = self.status.selected_map.map_id
+
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! ({map_id})")
+
+ if map_id != self._map_manager.selected_map.map_id:
+ if not self.set_selected_map(map_id):
+ raise InvalidActionException("Failed to select map")
+
+ self.update_map_data_async({"RoomMopType": self._map_manager.editor.set_mop_type(mop_type, map_id)})
+
+ def set_segment_type(
+ self,
+ segment_type: dict[int, int],
+ map_id: int = None,
+ ) -> dict[str, Any] | None:
+ """Update type of segments"""
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit segment when temporary map is present")
+
+ if self._map_manager:
+ if not map_id:
+ if not self.status.selected_map:
+ raise InvalidActionException("Map ID is required")
+
+ map_id = self.status.selected_map.map_id
+
+ map_data_list = self.status.map_data_list
+ if not map_data_list or map_id not in map_data_list:
+ raise InvalidActionException(f"Map not found! ({map_id})")
+
+ if map_id != self._map_manager.selected_map.map_id and self.capability.lidar_navigation:
+ if not self.set_selected_map(map_id):
+ raise InvalidActionException("Failed to select map")
+
+ segment_info = self._map_manager.editor.set_segment_type(segment_type, map_id)
+ if segment_info:
+ data = {"nsr": segment_info, "mapid": map_id}
+ if self.capability.auto_rename_segment:
+ data["autonsr"] = True
+ return self.update_map_data_async(data)
+
+ def set_segment_name(self, segment_id: int, segment_type: int, custom_name: str = None) -> dict[str, Any] | None:
+ """Update name of a segment on current map"""
+ if self.status.has_temporary_map:
+ raise InvalidActionException("Cannot edit segment when temporary map is present")
+
+ if self._map_manager:
+ segment_info = self._map_manager.editor.set_segment_name(segment_id, segment_type, custom_name)
+ if segment_info:
+ data = {"nsr": segment_info}
+ if self.status.current_map:
+ data["mapid"] = self.status.current_map.map_id
+ if self.capability.auto_rename_segment:
+ data["autonsr"] = True
+ return self.update_map_data_async(data)
+
+ def set_segment_order(self, segment_id: int, order: int) -> dict[str, Any] | None:
+ """Update cleaning order of a segment on current map"""
+ if self._map_manager and not self.status.has_temporary_map:
+ cleaning_sequence = self._map_manager.editor.set_segment_order(segment_id, order)
+ return self.update_map_data_async(
+ {"cleanareaorder": [{str(item): i} for i, item in enumerate(cleaning_sequence, 1)]}
+ if self.capability.cleaning_sequence_v2
+ else {"cleanOrder": cleaning_sequence}
+ )
+
+ def set_segment_suction_level(self, segment_id: int, suction_level: int) -> dict[str, Any] | None:
+ """Update suction level of a segment on current map"""
+ if self._map_manager and not self.status.has_temporary_map:
+ return self.set_cleanset(self._map_manager.editor.set_segment_suction_level(segment_id, suction_level))
+
+ def set_segment_water_volume(self, segment_id: int, water_volume: int) -> dict[str, Any] | None:
+ """Update water volume of a segment on current map"""
+ if not self.capability.self_wash_base and self._map_manager and not self.status.has_temporary_map:
+ if self.capability.wetness_level:
+ if self.capability.mop_clean_frequency:
+ if water_volume == 1:
+ water_volume = 5
+ elif water_volume == 3:
+ water_volume = 15
+ else:
+ water_volume = 10
+ else:
+ if water_volume == 1:
+ water_volume = 5
+ elif water_volume == 3:
+ water_volume = 27
+ else:
+ water_volume = 16
+
+ return self.set_cleanset(self._map_manager.editor.set_segment_wetness_level(segment_id, water_volume))
+
+ return self.set_cleanset(self._map_manager.editor.set_segment_water_volume(segment_id, water_volume))
+
+ def set_segment_mop_pad_humidity(self, segment_id: int, mop_pad_humidity: int) -> dict[str, Any] | None:
+ """Update mop pad humidity of a segment on current map"""
+ if self.capability.self_wash_base and self._map_manager and not self.status.has_temporary_map:
+ if self.capability.wetness_level:
+ if self.capability.mop_clean_frequency:
+ if mop_pad_humidity == 1:
+ mop_pad_humidity = 2
+ elif mop_pad_humidity == 3:
+ mop_pad_humidity = 14
+ else:
+ mop_pad_humidity = 8
+ else:
+ if mop_pad_humidity == 1:
+ mop_pad_humidity = 5
+ elif mop_pad_humidity == 3:
+ mop_pad_humidity = 27
+ else:
+ mop_pad_humidity = 16
+
+ return self.set_cleanset(
+ self._map_manager.editor.set_segment_wetness_level(segment_id, mop_pad_humidity)
+ )
+
+ return self.set_cleanset(self._map_manager.editor.set_segment_water_volume(segment_id, mop_pad_humidity))
+
+ def set_segment_wetness_level(self, segment_id: int, wetness_level: int) -> dict[str, Any] | None:
+ """Update wetness level of a segment on current map"""
+ if self.capability.wetness_level and self._map_manager and not self.status.has_temporary_map:
+ return self.set_cleanset(
+ self._map_manager.editor.set_segment_wetness_level(segment_id, int(wetness_level))
+ )
+
+ def set_segment_cleaning_mode(self, segment_id: int, cleaning_mode: int) -> dict[str, Any] | None:
+ """Update mop pad humidity of a segment on current map"""
+ if self._map_manager and not self.status.has_temporary_map:
+ return self.set_cleanset(self._map_manager.editor.set_segment_cleaning_mode(segment_id, cleaning_mode))
+
+ def set_segment_custom_mopping_route(self, segment_id: int, custom_mopping_route: int) -> dict[str, Any] | None:
+ """Update custom mopping route of a segment on current map"""
+ if (
+ self.capability.self_wash_base
+ and self.capability.custom_mopping_route
+ and self._map_manager
+ and not self.status.has_temporary_map
+ ):
+ return self.set_cleanset(
+ self._map_manager.editor.set_segment_custom_mopping_route(segment_id, custom_mopping_route)
+ )
+
+ def set_segment_cleaning_route(self, segment_id: int, cleaning_route: int) -> dict[str, Any] | None:
+ """Update cleaning route of a segment on current map"""
+ if (
+ self.capability.self_wash_base
+ and self.capability.cleaning_route
+ and self._map_manager
+ and not self.status.has_temporary_map
+ ):
+ return self.set_cleanset(self._map_manager.editor.set_segment_cleaning_route(segment_id, cleaning_route))
+
+ def set_segment_cleaning_times(self, segment_id: int, cleaning_times: int) -> dict[str, Any] | None:
+ """Update cleaning times of a segment on current map."""
+ if self.status.started:
+ raise InvalidActionException("Cannot set room cleaning times while vacuum is running")
+
+ if self._map_manager and not self.status.has_temporary_map:
+ return self.set_cleanset(self._map_manager.editor.set_segment_cleaning_times(segment_id, cleaning_times))
+
+ def set_segment_mop_temperature(self, segment_id: int, mop_temperature: int) -> dict[str, Any] | None:
+ """Update mop temperature of a segment on current map"""
+ if self._map_manager and not self.status.has_temporary_map:
+ return self.set_cleanset(self._map_manager.editor.set_segment_mop_temperature(segment_id, mop_temperature))
+
+ def set_segment_mop_pressure(self, segment_id: int, mop_pressure: int) -> dict[str, Any] | None:
+ """Update mop pressure of a segment on current map"""
+ if self._map_manager and not self.status.has_temporary_map:
+ return self.set_cleanset(self._map_manager.editor.set_segment_mop_pressure(segment_id, mop_pressure))
+
+ def set_segment_floor_material(
+ self, segment_id: int, floor_material: int, direction: int = None
+ ) -> dict[str, Any] | None:
+ """Update floor material of a segment on current map"""
+ if self._map_manager and not self.status.has_temporary_map:
+ if (
+ floor_material > 4
+ and floor_material < 8
+ and not (self.capability.carpet_material and self.capability.carpet_type)
+ ):
+ raise InvalidActionException("Setting floor material as carpet is not supported on this device")
+
+ if not self.capability.floor_direction_cleaning:
+ direction = None
+ else:
+ if floor_material != 1:
+ direction = None
+ elif direction is None:
+ segment = self.status.segments[segment_id]
+ direction = (
+ segment.floor_material_rotated_direction
+ if segment.floor_material_rotated_direction is not None
+ else (
+ 0
+ if self.status.current_map.rotation == 0 or self.status.current_map.rotation == 90
+ else 90
+ )
+ )
+
+ floor_material, carpet_type = self._map_manager.editor.set_segment_floor_material(
+ segment_id, floor_material, direction
+ )
+ data = {"nsm": floor_material}
+ if self.status.selected_map:
+ data["mapid"] = self.status.selected_map.map_id
+ if carpet_type:
+ data["carpetmaterial"] = {"roomcpt": carpet_type}
+ self.update_map_data_async(data)
+
+ def set_segment_floor_material_direction(
+ self, segment_id: int, floor_material_direction: int
+ ) -> dict[str, Any] | None:
+ """Update floor material direction of a segment on current map"""
+ if self.capability.floor_direction_cleaning and self._map_manager and not self.status.has_temporary_map:
+ floor_material, carpet_type = self._map_manager.editor.set_segment_floor_material(
+ segment_id, 1, floor_material_direction
+ )
+ data = {"nsm": floor_material}
+ if self.status.selected_map:
+ data["mapid"] = self.status.selected_map.map_id
+ if carpet_type:
+ data["carpetmaterial"] = {"roomcpt": carpet_type}
+ self.update_map_data_async(data)
+
+ def set_segment_visibility(self, segment_id: int, visibility: int) -> dict[str, Any] | None:
+ """Update visibility of a segment on current map"""
+ if self.capability.segment_visibility and self._map_manager and not self.status.has_temporary_map:
+ return self.update_map_data_async(
+ {"delsr": self._map_manager.editor.set_segment_visibility(segment_id, int(visibility))}
+ )
+
+ def set_segment_mop_type(self, segment_id: int, mop_type: str) -> dict[str, Any] | None:
+ """Update mop type of a segment on current map"""
+ if self.capability.auto_change_mop and self._map_manager and not self.status.has_temporary_map:
+ return self.update_map_data_async(
+ {"RoomMopType": self._map_manager.editor.set_segment_mop_type(segment_id, mop_type)}
+ )
+
+ @property
+ def _update_interval(self) -> float:
+ """Dynamic update interval of the device for the timer."""
+ now = time.time()
+ if self.status.map_backup_status or self.status.map_recovery_status:
+ return 2
+
+ if self._last_update_failed:
+ dt = now - self._last_update_failed
+ if dt <= 60:
+ return 5
+ if dt <= 300:
+ return 10
+ return 30
+
+ if now - self._last_change <= 60 or self.status.active or self.status.started:
+ return 3 if self.status.active or not self._protocol.prefer_cloud else 5
+
+ interval = 10 if self._protocol.prefer_cloud else 5
+ return min(self._map_update_interval, interval) if self._map_manager else interval
+
+ @property
+ def _map_update_interval(self) -> float:
+ """Dynamic map update interval for the map manager."""
+ if self._map_manager:
+ if self._protocol.dreame_cloud:
+ return 10 if self.status.active else 30
+ now = time.time()
+ if now - self._last_map_request <= 120 or now - self._last_change <= 60:
+ return 2.5 if self.status.active or self.status.started else 5
+ return 3 if self.status.running else 10 if self.status.active else 30
+ return -1
+
+ @property
+ def name(self) -> str:
+ """Return the name of the device."""
+ return self._name
+
+ @property
+ def device_connected(self) -> bool:
+ """Return connection status of the device."""
+ return self._protocol.connected
+
+ @property
+ def cloud_connected(self) -> bool:
+ """Return connection status of the device."""
+ return (
+ self._protocol.cloud
+ and self._protocol.cloud.connected
+ and (not self._protocol.prefer_cloud or self.device_connected)
+ )
+
+
+class DreameVacuumDeviceStatus:
+ """Helper class for device status and int enum type properties.
+ This class is used for determining various states of the device by its properties.
Determined states are used by multiple validation and rendering condition checks.
- Almost of the rules are extracted from mobile app that has a similar class with same purpose."""
-
- _cleaning_history = None
- _last_cleaning_time = None
-
- suction_level_list = {v: k for k, v in SUCTION_LEVEL_CODE_TO_NAME.items()}
- water_volume_list = {v: k for k, v in WATER_VOLUME_CODE_TO_NAME.items()}
- mop_pad_humidity_list = {v: k for k, v in MOP_PAD_HUMIDITY_CODE_TO_NAME.items()}
- cleaning_mode_list = {v: k for k, v in CLEANING_MODE_CODE_TO_NAME.items()}
- carpet_sensitivity_list = {v: k for k, v in CARPET_SENSITIVITY_CODE_TO_NAME.items()}
- self_clean_area_list = {v: k for k, v in SELF_AREA_CLEAN_TO_NAME.items()}
- mop_wash_level_list = {v: k for k, v in MOP_WASH_LEVEL_TO_NAME.items()}
- mopping_type_list = {v: k for k, v in MOPPING_TYPE_TO_NAME.items()}
-
- ai_policy_accepted = False
- ai_obstacle_detection = None
- obstacle_image_upload = None
- pet_detection = None
- human_detection = None
- furniture_detection = None
- fluid_detection = None
- obstacle_picture = None
- ai_picture = None
- collision_avoidance = None
- fill_light = None
- auto_drying = None
- stain_avoidance = None
- mopping_type = None
-
- lidar_navigation = None
- ai_detection_available = None
- self_wash_base_available = None
- auto_empty_base_available = None
- mop_pad_lifting_available = None
- customized_cleaning_available = None
- auto_switch_settings_available = None
- robot_shape = None
+ Almost of the rules are extracted from mobile app that has a similar class with same purpose.
+ """
def __init__(self, device):
- self._device = device
+ self._device: DreameVacuumDevice = device
+ self._cleaning_history = None
+ self._cleaning_history_attrs = None
+ self._last_cleaning_time = None
+ self._cruising_history = None
+ self._cruising_history_attrs = None
+ self._last_cruising_time = None
+ self._history_map_data: dict[str, MapData] = {}
+ self._previous_cleaning_sequence: dict[int, list[int]] = {}
+ self._drying_time = None
+
+ self.suction_level_list = {v: k for k, v in SUCTION_LEVEL_CODE_TO_NAME.items()}
+ self.water_volume_list = {v: k for k, v in WATER_VOLUME_CODE_TO_NAME.items()}
+ self.mop_pad_humidity_list = {v: k for k, v in MOP_PAD_HUMIDITY_CODE_TO_NAME.items()}
+ self.cleaning_mode_list = {v: k for k, v in CLEANING_MODE_CODE_TO_NAME.items()}
+ self.carpet_sensitivity_list = {v: k for k, v in CARPET_SENSITIVITY_CODE_TO_NAME.items()}
+ self.carpet_cleaning_list = {v: k for k, v in CARPET_CLEANING_CODE_TO_NAME.items()}
+ self.mop_wash_level_list = {v: k for k, v in MOP_WASH_LEVEL_TO_NAME.items()}
+ self.mop_clean_frequency_list = {v: k for k, v in MOP_CLEAN_FREQUENCY_TO_NAME.items()}
+ self.mopping_type_list = {v: k for k, v in MOPPING_TYPE_TO_NAME.items()}
+ self.wider_corner_coverage_list = {v: k for k, v in WIDER_CORNER_COVERAGE_TO_NAME.items()}
+ self.mop_pad_swing_list = {v: k for k, v in MOP_PAD_SWING_TO_NAME.items()}
+ self.mop_extend_frequency_list = {v: k for k, v in MOP_EXTEND_FREQUENCY_TO_NAME.items()}
+ self.second_cleaning_list = {v: k for k, v in SECOND_CLEANING_TO_NAME.items()}
+ self.cleaning_route_list = {v: k for k, v in CLEANING_ROUTE_TO_NAME.items()}
+ self.custom_mopping_route_list = {v: k for k, v in CUSTOM_MOPPING_ROUTE_TO_NAME.items()}
+ self.cleangenius_list = {v: k for k, v in CLEANGENIUS_TO_NAME.items()}
+ self.washing_mode_list = {v: k for k, v in WASHING_MODE_TO_NAME.items()}
+ self.cleangenius_mode_list = {v: k for k, v in CLEANGENIUS_MODE_TO_NAME.items()}
+ self.water_temperature_list = {v: k for k, v in WATER_TEMPERATURE_TO_NAME.items()}
+ self.self_clean_frequency_list = {v: k for k, v in SELF_CLEAN_FREQUENCY_TO_NAME.items()}
+ self.floor_material_list = {v: k for k, v in FLOOR_MATERIAL_CODE_TO_NAME.items()}
+ self.floor_material_direction_list = {v: k for k, v in FLOOR_MATERIAL_DIRECTION_CODE_TO_NAME.items()}
+ self.visibility_list = {v: k for k, v in SEGMENT_VISIBILITY_CODE_TO_NAME.items()}
+ self.voice_assistant_language_list = {v: k for k, v in VOICE_ASSISTANT_LANGUAGE_TO_NAME.items()}
+ self.mop_pressure_list = {v: k for k, v in MOP_PRESSURE_TO_NAME.items()}
+ self.mop_temperature_list = {v: k for k, v in MOP_TEMPERATURE_TO_NAME.items()}
+ self.low_lying_area_frequency_list = {v: k for k, v in LOW_LYING_AREA_FREQUENCY_TO_NAME.items()}
+ self.scraper_frequency_list = {v: k for k, v in SCRAPER_FREQUENCY_TO_NAME.items()}
+ self.auto_lds_coverage_list = {v: k for k, v in AUTO_LDS_COVERAGE_TO_NAME.items()}
+ self.drying_time_list = {f"{i}h": i for i in range(2, 5)}
+ self.auto_empty_mode_list = {}
+ self.segment_cleaning_mode_list = {}
+ self.segment_cleaning_route_list = {}
+ self.cleaning_mode = None
+ self.mop_pad_humidity = 1
+ self.previous_self_clean_area = None
+ self.previous_self_clean_time = 25
+ self.self_clean_area_min = 10
+ self.self_clean_area_max = 35
+ self.self_clean_area_default = 20
+ self.self_clean_time_min = 10
+ self.self_clean_time_max = 50
+ self.self_clean_time_default = None
+ self.self_clean_value = None
+ self.ai_policy_accepted = False
+ self.go_to_zone: GoToZoneSettings = None
+ self.cleanup_completed: bool = False
+ self.cleanup_started: bool = False
- def update_static_properties(self):
- self.lidar_navigation = bool(self._get_property(DreameVacuumProperty.MAP_SAVING) is None)
- self.ai_detection_available = bool(self._get_property(DreameVacuumProperty.AI_DETECTION) is not None)
- self.self_wash_base_available = bool(
- self._get_property(DreameVacuumProperty.SELF_WASH_BASE_STATUS) is not None
- )
- self.auto_empty_base_available = bool(self._get_property(DreameVacuumProperty.DUST_COLLECTION) is not None)
- self.customized_cleaning_available = bool(
- self._get_property(DreameVacuumProperty.CUSTOMIZED_CLEANING) is not None
- )
- self.auto_switch_settings_available = bool(
- self._get_property(DreameVacuumProperty.AUTO_SWITCH_SETTINGS) is not None
- )
- self.mop_pad_lifting_available = bool(
- (self.self_wash_base_available and self.auto_empty_base_available)
- or (self._device.info and "r2216" in self._device.info.model)
- )
- self.robot_shape = (
- 2
- if self.self_wash_base_available and not self.mop_pad_lifting_available
- else 0 if self.lidar_navigation else 1
- )
+ self.stream_status = None
+ self.stream_session = None
+
+ self.faults = []
+ self.dnd_tasks = None
+ self.schedule = []
+ self.off_peak_charging_config = None
+ self.shortcuts = None
def _get_property(self, prop: DreameVacuumProperty) -> Any:
"""Helper function for accessing a property from device"""
return self._device.get_property(prop)
+ @property
+ def _capability(self) -> DreameVacuumDeviceCapability:
+ """Helper property for accessing device capabilities"""
+ return self._device.capability
+
@property
def _map_manager(self) -> DreameMapVacuumMapManager | None:
"""Helper property for accessing map manager from device"""
@@ -2323,18 +7191,30 @@ def _device_connected(self) -> bool:
"""Helper property for accessing device connection status"""
return self._device.device_connected
+ @property
+ def serial_number(self) -> int:
+ """Return serial number of the device."""
+ return self._get_property(DreameVacuumProperty.SERIAL_NUMBER)
+
@property
def battery_level(self) -> int:
"""Return battery level of the device."""
return self._get_property(DreameVacuumProperty.BATTERY_LEVEL)
+ @property
+ def battery_charge_level(self) -> int:
+ """Return max battery charge level of the device."""
+ battery_charge_level = self._get_property(DreameVacuumProperty.BATTERY_CHARGE_LEVEL)
+ return battery_charge_level if battery_charge_level else 100
+
@property
def suction_level(self) -> DreameVacuumSuctionLevel:
"""Return suction level of the device."""
value = self._get_property(DreameVacuumProperty.SUCTION_LEVEL)
if value is not None and value in DreameVacuumSuctionLevel._value2member_map_:
return DreameVacuumSuctionLevel(value)
- _LOGGER.debug("SUCTION_LEVEL not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("SUCTION_LEVEL not supported: %s", value)
return DreameVacuumSuctionLevel.UNKNOWN
@property
@@ -2345,10 +7225,29 @@ def suction_level_name(self) -> str:
@property
def water_volume(self) -> DreameVacuumWaterVolume:
"""Return water volume of the device."""
+ if self._capability.self_wash_base:
+ if self.mop_pad_humidity is None:
+ if self._capability.wetness_level:
+ wetness_level = self.status.wetness_level
+ if wetness_level > 32:
+ if wetness_level > 200:
+ return DreameVacuumMopPadHumidity.WET
+ elif wetness_level < 200:
+ return DreameVacuumMopPadHumidity.SLIGHTLY_DRY
+ else:
+ if wetness_level > (14 if self._capability.mop_clean_frequency else 26):
+ return DreameVacuumMopPadHumidity.WET
+ elif wetness_level < 6:
+ return DreameVacuumMopPadHumidity.SLIGHTLY_DRY
+ return DreameVacuumMopPadHumidity.MOIST
+ return DreameVacuumMopPadHumidity.UNKNOWN
+ return DreameVacuumMopPadHumidity(self.mop_pad_humidity)
+
value = self._get_property(DreameVacuumProperty.WATER_VOLUME)
if value is not None and value in DreameVacuumWaterVolume._value2member_map_:
return DreameVacuumWaterVolume(value)
- _LOGGER.debug("WATER_VOLUME not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("WATER_VOLUME not supported: %s", value)
return DreameVacuumWaterVolume.UNKNOWN
@property
@@ -2356,72 +7255,35 @@ def water_volume_name(self) -> str:
"""Return water volume as string for translation."""
return WATER_VOLUME_CODE_TO_NAME.get(self.water_volume, STATE_UNKNOWN)
- @property
- def mop_pad_humidity(self) -> DreameVacuumMopPadHumidity:
- """Return mop pad humidity of the device."""
- if self.self_wash_base_available:
- values = DreameVacuumDevice.split_group_value(self._get_property(DreameVacuumProperty.CLEANING_MODE))
- if values and len(values) == 3:
- value = values[2]
- if value is not None and value in DreameVacuumMopPadHumidity._value2member_map_:
- return DreameVacuumMopPadHumidity(value)
- _LOGGER.debug("MOP_PAD_HUMIDITY not supported: %s", value)
- return DreameVacuumMopPadHumidity.UNKNOWN
-
@property
def mop_pad_humidity_name(self) -> str:
"""Return mop pad humidity as string for translation."""
- return MOP_PAD_HUMIDITY_CODE_TO_NAME.get(self.mop_pad_humidity, STATE_UNKNOWN)
-
- @property
- def cleaning_mode(self) -> DreameVacuumCleaningMode:
- """Return cleaning mode of the device."""
- value = self._get_property(DreameVacuumProperty.CLEANING_MODE)
- if self.self_wash_base_available:
- values = DreameVacuumDevice.split_group_value(value, self.mop_pad_lifting_available)
- if values and len(values) == 3:
- if not self.mop_pad_lifting_available:
- if not self.water_tank_or_mop_installed:
- return DreameVacuumCleaningMode.SWEEPING
- if values[0] == 1:
- return DreameVacuumCleaningMode.MOPPING
- return DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
- else:
- if values[0] == 2:
- return DreameVacuumCleaningMode.SWEEPING
- if values[0] == 0:
- return DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
- value = values[0]
- elif self.mop_pad_lifting_available:
- if value == 2:
- return DreameVacuumCleaningMode.SWEEPING
- if value == 0:
- return DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
-
- if value is None:
- return (
- DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
- if self.water_tank_or_mop_installed
- else DreameVacuumCleaningMode.SWEEPING
- )
-
- if value in DreameVacuumCleaningMode._value2member_map_:
- return DreameVacuumCleaningMode(value)
- _LOGGER.debug("CLEANING_MODE not supported: %s", value)
- return DreameVacuumCleaningMode.UNKNOWN
+ return MOP_PAD_HUMIDITY_CODE_TO_NAME.get(DreameVacuumMopPadHumidity(self.mop_pad_humidity), STATE_UNKNOWN)
@property
def cleaning_mode_name(self) -> str:
"""Return cleaning mode as string for translation."""
return CLEANING_MODE_CODE_TO_NAME.get(self.cleaning_mode, STATE_UNKNOWN)
+ @property
+ def wetness_level(self) -> int:
+ """Return wetness level of the device."""
+ if self._capability.wetness:
+ level = self._get_property(DreameVacuumProperty.WETNESS_LEVEL)
+ return level if level else 16
+
@property
def status(self) -> DreameVacuumStatus:
"""Return status of the device."""
value = self._get_property(DreameVacuumProperty.STATUS)
if value is not None and value in DreameVacuumStatus._value2member_map_:
+ if self.go_to_zone and value == DreameVacuumStatus.ZONE_CLEANING.value:
+ return DreameVacuumStatus.CRUISING_POINT
+ if value == DreameVacuumStatus.CHARGING.value and not self.charging:
+ return DreameVacuumStatus.IDLE
return DreameVacuumStatus(value)
- _LOGGER.debug("STATUS not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("STATUS not supported: %s", value)
return DreameVacuumStatus.UNKNOWN
@property
@@ -2434,8 +7296,14 @@ def task_status(self) -> DreameVacuumTaskStatus:
"""Return task status of the device."""
value = self._get_property(DreameVacuumProperty.TASK_STATUS)
if value is not None and value in DreameVacuumTaskStatus._value2member_map_:
+ if self.go_to_zone:
+ if value == DreameVacuumTaskStatus.ZONE_CLEANING.value:
+ return DreameVacuumTaskStatus.CRUISING_POINT
+ if value == DreameVacuumTaskStatus.ZONE_CLEANING_PAUSED.value:
+ return DreameVacuumTaskStatus.CRUISING_POINT_PAUSED
return DreameVacuumTaskStatus(value)
- _LOGGER.debug("TASK_STATUS not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("TASK_STATUS not supported: %s", value)
return DreameVacuumTaskStatus.UNKNOWN
@property
@@ -2450,12 +7318,15 @@ def water_tank(self) -> DreameVacuumWaterTank:
if value is not None:
if value == 3:
return DreameVacuumWaterTank.INSTALLED
+ if self.mop_in_station:
+ return DreameVacuumWaterTank.IN_STATION
if value == 2:
return DreameVacuumWaterTank.MOP_INSTALLED
if value in DreameVacuumWaterTank._value2member_map_:
return DreameVacuumWaterTank(value)
- _LOGGER.debug("WATER_TANK not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("WATER_TANK not supported: %s", value)
return DreameVacuumWaterTank.UNKNOWN
@property
@@ -2463,6 +7334,11 @@ def water_tank_name(self) -> str:
"""Return water tank as string for translation."""
return WATER_TANK_CODE_TO_NAME.get(self.water_tank, STATE_UNKNOWN)
+ @property
+ def mop_pad_name(self) -> str:
+ """Return mop pad as string for translation."""
+ return self.water_tank_name
+
@property
def charging_status(self) -> DreameVacuumChargingStatus:
"""Return charging status of the device."""
@@ -2470,10 +7346,11 @@ def charging_status(self) -> DreameVacuumChargingStatus:
if value is not None and value in DreameVacuumChargingStatus._value2member_map_:
value = DreameVacuumChargingStatus(value)
# Charging status complete is not present on older firmwares
- if value is DreameVacuumChargingStatus.CHARGING and self.battery_level == 100:
+ if value is DreameVacuumChargingStatus.CHARGING and self.battery_level == self.battery_charge_level:
return DreameVacuumChargingStatus.CHARGING_COMPLETED
return value
- _LOGGER.debug("CHARGING_STATUS not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("CHARGING_STATUS not supported: %s", value)
return DreameVacuumChargingStatus.UNKNOWN
@property
@@ -2487,7 +7364,8 @@ def auto_empty_status(self) -> DreameVacuumAutoEmptyStatus:
value = self._get_property(DreameVacuumProperty.AUTO_EMPTY_STATUS)
if value is not None and value in DreameVacuumAutoEmptyStatus._value2member_map_:
return DreameVacuumAutoEmptyStatus(value)
- _LOGGER.debug("AUTO_EMPTY_STATUS not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("AUTO_EMPTY_STATUS not supported: %s", value)
return DreameVacuumAutoEmptyStatus.UNKNOWN
@property
@@ -2501,7 +7379,8 @@ def relocation_status(self) -> DreameVacuumRelocationStatus:
value = self._get_property(DreameVacuumProperty.RELOCATION_STATUS)
if value is not None and value in DreameVacuumRelocationStatus._value2member_map_:
return DreameVacuumRelocationStatus(value)
- _LOGGER.debug("RELOCATION_STATUS not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("RELOCATION_STATUS not supported: %s", value)
return DreameVacuumRelocationStatus.UNKNOWN
@property
@@ -2515,7 +7394,8 @@ def self_wash_base_status(self) -> DreameVacuumSelfWashBaseStatus:
value = self._get_property(DreameVacuumProperty.SELF_WASH_BASE_STATUS)
if value is not None and value in DreameVacuumSelfWashBaseStatus._value2member_map_:
return DreameVacuumSelfWashBaseStatus(value)
- _LOGGER.debug("SELF_WASH_BASE_STATUS not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("SELF_WASH_BASE_STATUS not supported: %s", value)
return DreameVacuumSelfWashBaseStatus.UNKNOWN
@property
@@ -2528,7 +7408,8 @@ def dust_collection(self) -> DreameVacuumDustCollection:
value = self._get_property(DreameVacuumProperty.DUST_COLLECTION)
if value is not None and value in DreameVacuumDustCollection._value2member_map_:
return DreameVacuumDustCollection(value)
- _LOGGER.debug("DUST_COLLECTION not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("DUST_COLLECTION not supported: %s", value)
return DreameVacuumDustCollection.UNKNOWN
@property
@@ -2542,7 +7423,8 @@ def carpet_sensitivity(self) -> DreameVacuumCarpetSensitivity:
value = self._get_property(DreameVacuumProperty.CARPET_SENSITIVITY)
if value is not None and value in DreameVacuumCarpetSensitivity._value2member_map_:
return DreameVacuumCarpetSensitivity(value)
- _LOGGER.debug("CARPET_SENSITIVITY not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("CARPET_SENSITIVITY not supported: %s", value)
return DreameVacuumCarpetSensitivity.UNKNOWN
@property
@@ -2550,30 +7432,78 @@ def carpet_sensitivity_name(self) -> str:
"""Return carpet sensitivity as string for translation."""
return CARPET_SENSITIVITY_CODE_TO_NAME.get(self.carpet_sensitivity, STATE_UNKNOWN)
+ @property
+ def carpet_cleaning(self) -> DreameVacuumCarpetCleaning:
+ """Return carpet cleaning of the device."""
+ value = self._get_property(DreameVacuumProperty.CARPET_CLEANING)
+
+ if (
+ not self.carpet_recognition
+ and self._capability.mop_pad_lifting_plus
+ and self._capability.auto_carpet_cleaning
+ ):
+ return DreameVacuumCarpetCleaning.IGNORE
+ elif value == 6 or (value == 3 and self._capability.mop_pad_unmounting and not self.auto_mount_mop):
+ return DreameVacuumCarpetCleaning.ADAPTATION
+
+ if value is not None and value in DreameVacuumCarpetCleaning._value2member_map_:
+ return DreameVacuumCarpetCleaning(value)
+ if value is not None:
+ _LOGGER.debug("CARPET_CLEANING not supported: %s", value)
+ return DreameVacuumCarpetCleaning.UNKNOWN
+
+ @property
+ def carpet_cleaning_name(self) -> str:
+ """Return carpet cleaning as string for translation."""
+ return CARPET_CLEANING_CODE_TO_NAME.get(self.carpet_cleaning, STATE_UNKNOWN)
+
@property
def state(self) -> DreameVacuumState:
"""Return state of the device."""
+ if self.has_error:
+ return DreameVacuumState.ERROR
+
value = self._get_property(DreameVacuumProperty.STATE)
+ if (
+ value is not None
+ and int(value) > 18
+ and not self._capability.new_state
+ and value in DreameVacuumStateOld._value2member_map_
+ ):
+ value = DreameVacuumState[DreameVacuumStateOld(value).name].value
+
if value is not None and value in DreameVacuumState._value2member_map_:
+ if self.go_to_zone and (
+ value == DreameVacuumState.IDLE
+ or value == DreameVacuumState.SWEEPING.value
+ or value == DreameVacuumState.MOPPING.value
+ or value == DreameVacuumState.SWEEPING_AND_MOPPING.value
+ ):
+ if self.paused:
+ return DreameVacuumState.MONITORING_PAUSED
+ return DreameVacuumState.MONITORING
vacuum_state = DreameVacuumState(value)
-
## Determine state as implemented on the app
if vacuum_state is DreameVacuumState.IDLE:
if self.started or self.cleaning_paused or self.fast_mapping_paused:
return DreameVacuumState.PAUSED
elif self.docked:
- ## This is for compatibility with various lovelace vacuum cards
- ## Device will report idle when charging is completed and vacuum card will display return to dock icon even when robot is docked
if self.washing:
return DreameVacuumState.WASHING
+ if self.washing_paused:
+ return DreameVacuumState.WASHING_PAUSED
if self.drying:
return DreameVacuumState.DRYING
if self.charging:
return DreameVacuumState.CHARGING
+ ## This is for compatibility with various lovelace vacuum cards
+ ## Device will report idle when charging is completed and vacuum card will display return to dock icon even when robot is docked
if self.charging_status is DreameVacuumChargingStatus.CHARGING_COMPLETED:
return DreameVacuumState.CHARGING_COMPLETED
return vacuum_state
- _LOGGER.debug("STATE not supported: %s", value)
+
+ if value is not None:
+ _LOGGER.debug("STATE not supported: %s", value)
return DreameVacuumState.UNKNOWN
@property
@@ -2582,30 +7512,14 @@ def state_name(self) -> str:
return STATE_CODE_TO_STATE.get(self.state, STATE_UNKNOWN)
@property
- def self_clean_area(self) -> DreameVacuumSelfCleanArea:
- """Return self-clean area of the device."""
- if self.self_wash_base_available:
- values = DreameVacuumDevice.split_group_value(self._get_property(DreameVacuumProperty.CLEANING_MODE))
- if values and len(values) == 3:
- value = values[1]
- if value is not None and value in DreameVacuumSelfCleanArea._value2member_map_:
- return DreameVacuumSelfCleanArea(value)
- _LOGGER.debug("SELF_CLEAN_AREA not supported: %s", value)
- return DreameVacuumSelfCleanArea.UNKNOWN
-
- @property
- def self_clean_area_name(self) -> str:
- """Return self-clean area as string for translation."""
- return SELF_AREA_CLEAN_TO_NAME.get(self.self_clean_area, STATE_UNKNOWN)
-
- @property
- def mop_wash_level(self) -> DreameVacuumSelfCleanArea:
+ def mop_wash_level(self) -> DreameVacuumMopWashLevel:
"""Return mop wash level of the device."""
- if self.self_wash_base_available:
+ if self._capability.self_wash_base:
value = self._get_property(DreameVacuumProperty.MOP_WASH_LEVEL)
if value is not None and value in DreameVacuumMopWashLevel._value2member_map_:
return DreameVacuumMopWashLevel(value)
- _LOGGER.debug("MOP_WASH_LEVEL not supported: %s", value)
+ if value is not None:
+ _LOGGER.debug("MOP_WASH_LEVEL not supported: %s", value)
return DreameVacuumMopWashLevel.UNKNOWN
@property
@@ -2614,20 +7528,484 @@ def mop_wash_level_name(self) -> str:
return MOP_WASH_LEVEL_TO_NAME.get(self.mop_wash_level, STATE_UNKNOWN)
@property
- def mopping_type_name(self) -> str:
- """Return moping type as string for translation."""
- if self.mopping_type is not None and self.mopping_type in DreameVacuumMoppingType._value2member_map_:
- return MOPPING_TYPE_TO_NAME.get(DreameVacuumMoppingType(self.mopping_type), STATE_UNKNOWN)
- return STATE_UNKNOWN
-
+ def mop_clean_frequency(self) -> DreameVacuumMopCleanFrequency:
+ """Return mop clean frequency of the device."""
+ if self._capability.self_wash_base and self._capability.mop_clean_frequency:
+ value = self.self_clean_value
+ if value == 0:
+ return DreameVacuumMopCleanFrequency.BY_ROOM
+ if value is not None and value in DreameVacuumMopCleanFrequency._value2member_map_:
+ return DreameVacuumMopCleanFrequency(value)
+ if value is not None:
+ _LOGGER.debug("MOP_CLEAN_FREQUENCY not supported: %s", value)
+ return DreameVacuumMopCleanFrequency.UNKNOWN
+
+ @property
+ def mop_clean_frequency_name(self) -> str:
+ """Return mop clean frequency as string for translation."""
+ return MOP_CLEAN_FREQUENCY_TO_NAME.get(self.mop_clean_frequency, STATE_UNKNOWN)
+
+ @property
+ def mopping_type(self) -> DreameVacuumMoppingType:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOPPING_TYPE)
+ if value is not None:
+ if value in DreameVacuumMoppingType._value2member_map_:
+ return DreameVacuumMoppingType(value)
+ _LOGGER.debug("MOPPING_TYPE not supported: %s", value)
+ return DreameVacuumMoppingType.UNKNOWN
+ return None
+
+ @property
+ def mopping_type_name(self) -> str:
+ """Return moping type as string for translation."""
+ if self.mopping_type is not None and self.mopping_type in DreameVacuumMoppingType._value2member_map_:
+ return MOPPING_TYPE_TO_NAME.get(DreameVacuumMoppingType(self.mopping_type), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def stream_status_name(self) -> str:
+ """Return camera stream status as string for translation."""
+ return STREAM_STATUS_TO_NAME.get(self.stream_status, STATE_UNKNOWN)
+
+ @property
+ def wider_corner_coverage(self) -> DreameVacuumWiderCornerCoverage:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumWiderCornerCoverage._value2member_map_:
+ return DreameVacuumWiderCornerCoverage(value)
+ if value is not None:
+ _LOGGER.debug("WIDER_CORNER_COVERAGE not supported: %s", value)
+ return DreameVacuumWiderCornerCoverage.UNKNOWN
+
+ @property
+ def wider_corner_coverage_name(self) -> str:
+ """Return wider corner coverage as string for translation."""
+ wider_corner_coverage = 0 if self.wider_corner_coverage < 0 else self.wider_corner_coverage
+ if (
+ wider_corner_coverage is not None
+ and wider_corner_coverage in DreameVacuumWiderCornerCoverage._value2member_map_
+ ):
+ return WIDER_CORNER_COVERAGE_TO_NAME.get(
+ DreameVacuumWiderCornerCoverage(wider_corner_coverage), STATE_UNKNOWN
+ )
+ return STATE_UNKNOWN
+
+ @property
+ def mop_pad_swing(self) -> DreameVacuumMopPadSwing:
+ if self._capability.mop_pad_swing:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOP_PAD_SWING)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumMopPadSwing._value2member_map_:
+ return DreameVacuumMopPadSwing(value)
+ if value is not None:
+ _LOGGER.debug("MOP_PAD_SWING not supported: %s", value)
+ return DreameVacuumMopPadSwing.UNKNOWN
+
+ @property
+ def mop_pad_swing_name(self) -> str:
+ """Return mop pad swing as string for translation."""
+ mop_pad_swing = 0 if self.mop_pad_swing < 0 else self.mop_pad_swing
+ if mop_pad_swing is not None and mop_pad_swing in DreameVacuumMopPadSwing._value2member_map_:
+ return MOP_PAD_SWING_TO_NAME.get(DreameVacuumMopPadSwing(mop_pad_swing), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def mop_extend_frequency(self) -> DreameVacuumMopExtendFrequency:
+ if self._capability.mop_extend:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOP_EXTEND_FREQUENCY)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumMopExtendFrequency._value2member_map_:
+ return DreameVacuumMopExtendFrequency(value)
+ if value is not None:
+ _LOGGER.debug("MOP_EXTEND_FREQUENCY not supported: %s", value)
+ return DreameVacuumMopExtendFrequency.UNKNOWN
+
+ @property
+ def mop_extend_frequency_name(self) -> str:
+ """Return mop pad swing as string for translation."""
+ mop_extend_frequency = 0 if self.mop_extend_frequency < 0 else self.mop_extend_frequency
+ if (
+ mop_extend_frequency is not None
+ and mop_extend_frequency in DreameVacuumMopExtendFrequency._value2member_map_
+ ):
+ return MOP_EXTEND_FREQUENCY_TO_NAME.get(
+ DreameVacuumMopExtendFrequency(mop_extend_frequency), STATE_UNKNOWN
+ )
+ return STATE_UNKNOWN
+
+ @property
+ def auto_recleaning(self) -> DreameVacuumSecondCleaning:
+ if self._capability.auto_recleaning:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_RECLEANING)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumSecondCleaning._value2member_map_:
+ return DreameVacuumSecondCleaning(value)
+ if value is not None:
+ _LOGGER.debug("AUTO_RECLEANING not supported: %s", value)
+ return DreameVacuumSecondCleaning.UNKNOWN
+
+ @property
+ def auto_recleaning_name(self) -> str:
+ """Return mop pad swing as string for translation."""
+ auto_recleaning = 0 if self.auto_recleaning < 0 else self.auto_recleaning
+ if auto_recleaning is not None and auto_recleaning in DreameVacuumSecondCleaning._value2member_map_:
+ return SECOND_CLEANING_TO_NAME.get(DreameVacuumSecondCleaning(auto_recleaning), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def auto_rewashing(self) -> DreameVacuumSecondCleaning:
+ if self._capability.auto_rewashing:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_REWASHING)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumSecondCleaning._value2member_map_:
+ return DreameVacuumSecondCleaning(value)
+ if value is not None:
+ _LOGGER.debug("AUTO_REWASHING not supported: %s", value)
+ return DreameVacuumSecondCleaning.UNKNOWN
+
+ @property
+ def auto_rewashing_name(self) -> str:
+ """Return mop pad swing as string for translation."""
+ auto_rewashing = 0 if self.auto_rewashing < 0 else self.auto_rewashing
+ if auto_rewashing is not None and auto_rewashing in DreameVacuumSecondCleaning._value2member_map_:
+ return SECOND_CLEANING_TO_NAME.get(DreameVacuumSecondCleaning(auto_rewashing), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def cleaning_route(self) -> DreameVacuumCleaningRoute:
+ if self._capability.cleaning_route:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.CLEANING_ROUTE)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumCleaningRoute._value2member_map_:
+ return DreameVacuumCleaningRoute(value)
+ if value is not None:
+ _LOGGER.debug("CLEANING_ROUTE not supported: %s", value)
+ return DreameVacuumCleaningRoute.UNKNOWN
+
+ @property
+ def cleaning_route_name(self) -> str:
+ """Return cleaning route as string for translation."""
+ cleaning_route = 0 if self.cleaning_route < 0 else self.cleaning_route
+ if cleaning_route is not None and cleaning_route in DreameVacuumCleaningRoute._value2member_map_:
+ return CLEANING_ROUTE_TO_NAME.get(DreameVacuumCleaningRoute(cleaning_route), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def custom_mopping_route(self) -> DreameVacuumCustomMoppingRoute:
+ if self._capability.custom_mopping_route:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.MOPPING_TYPE)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumCustomMoppingRoute._value2member_map_:
+ if not self.custom_mopping_mode:
+ return DreameVacuumCustomMoppingRoute.OFF
+ return DreameVacuumCustomMoppingRoute(value)
+ if value is not None:
+ _LOGGER.debug("CUSTOM_MOPPING_ROUTE not supported: %s", value)
+ return DreameVacuumCustomMoppingRoute.UNKNOWN
+
+ @property
+ def custom_mopping_route_name(self) -> str:
+ """Return mopping route as string for translation."""
+ mopping_route = -2 if self.custom_mopping_route < -2 else self.custom_mopping_route
+ if mopping_route is not None and mopping_route in DreameVacuumCustomMoppingRoute._value2member_map_:
+ return CUSTOM_MOPPING_ROUTE_TO_NAME.get(DreameVacuumCustomMoppingRoute(mopping_route), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def cleangenius(self) -> DreameVacuumCleanGenius:
+ if self._capability.cleangenius:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.CLEANGENIUS)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumCleanGenius._value2member_map_:
+ return DreameVacuumCleanGenius(value)
+ if value is not None:
+ _LOGGER.debug("CLEANGENIUS not supported: %s", value)
+ return DreameVacuumCleanGenius.UNKNOWN
+
+ @property
+ def cleangenius_name(self) -> str:
+ """Return CleanGenius as string for translation."""
+ cleangenius = 0 if not self.cleangenius or self.cleangenius < 0 else self.cleangenius
+ if cleangenius is not None and cleangenius in DreameVacuumCleanGenius._value2member_map_:
+ return CLEANGENIUS_TO_NAME.get(DreameVacuumCleanGenius(cleangenius), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def cleangenius_mode(self) -> DreameVacuumCleanGeniusMode:
+ if self._capability.cleangenius_mode:
+ value = self._device.get_property(DreameVacuumProperty.CLEANGENIUS_MODE)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumCleanGeniusMode._value2member_map_:
+ return DreameVacuumCleanGeniusMode(value)
+ if value is not None:
+ _LOGGER.debug("CLEANGENIUS_MODE not supported: %s", value)
+ return DreameVacuumCleanGeniusMode.UNKNOWN
+
+ @property
+ def cleangenius_mode_name(self) -> str:
+ """Return Smart Clean Mode as string for translation."""
+ cleangenius_mode = 2 if not self.cleangenius_mode or self.cleangenius_mode < 1 else self.cleangenius_mode
+ if cleangenius_mode is not None and cleangenius_mode in DreameVacuumCleanGeniusMode._value2member_map_:
+ return CLEANGENIUS_MODE_TO_NAME.get(DreameVacuumCleanGeniusMode(cleangenius_mode), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def water_temperature(self) -> DreameVacuumWaterTemperature:
+ if self._capability.water_temperature:
+ value = self._device.get_property(DreameVacuumProperty.WATER_TEMPERATURE)
+ if value is not None and value < 0:
+ value = 0
+ if value is not None and value in DreameVacuumWaterTemperature._value2member_map_:
+ return DreameVacuumWaterTemperature(value)
+ if value is not None:
+ _LOGGER.debug("WATER_TEMPERATURE not supported: %s", value)
+ return DreameVacuumWaterTemperature.UNKNOWN
+
+ @property
+ def water_temperature_name(self) -> str:
+ """Return Water Temperature as string for translation."""
+ water_temperature = self.water_temperature
+ if water_temperature is not None and water_temperature in DreameVacuumWaterTemperature._value2member_map_:
+ return WATER_TEMPERATURE_TO_NAME.get(DreameVacuumWaterTemperature(water_temperature), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def washing_mode(self) -> DreameVacuumWashingMode:
+ if self._capability.cleangenius_mode:
+ if self.ultra_clean_mode and self.auto_water_refilling_enabled:
+ return DreameVacuumWashingMode.ULTRA_WASHING
+ value = self.mop_wash_level.value
+ if value is not None and value < 0:
+ value = 1
+ if value is not None and value in DreameVacuumWashingMode._value2member_map_:
+ return DreameVacuumWashingMode(value)
+ if value is not None:
+ _LOGGER.debug("WASHING_MODE not supported: %s", value)
+ return DreameVacuumWashingMode.UNKNOWN
+
+ @property
+ def washing_mode_name(self) -> str:
+ """Return Washing Mode as string for translation."""
+ washing_mode = self.washing_mode
+ if washing_mode is not None and washing_mode in DreameVacuumWashingMode._value2member_map_:
+ return WASHING_MODE_TO_NAME.get(DreameVacuumWashingMode(washing_mode), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def self_clean_frequency(self) -> DreameVacuumSelfCleanFrequency:
+ if self._capability.self_clean_frequency:
+ value = self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY)
+ if not self.self_clean_value and value != DreameVacuumSelfCleanFrequency.INTELLIGENT:
+ return DreameVacuumSelfCleanFrequency.BY_ROOM
+ if value is not None and value < 1:
+ value = 3
+ if value is not None and value in DreameVacuumSelfCleanFrequency._value2member_map_:
+ if value == DreameVacuumSelfCleanFrequency.BY_ROOM.value and (
+ self.current_map and not self.has_saved_map
+ ):
+ return DreameVacuumSelfCleanFrequency.BY_AREA
+ return DreameVacuumSelfCleanFrequency(value)
+ if value is not None:
+ _LOGGER.debug("SELF_CLEAN_FREQUENCY not supported: %s", value)
+ return DreameVacuumSelfCleanFrequency.UNKNOWN
+
+ @property
+ def self_clean_frequency_name(self) -> str:
+ """Return self clean frequency as string for translation."""
+ self_clean_frequency = self.self_clean_frequency
+ if (
+ self_clean_frequency is not None
+ and self_clean_frequency in DreameVacuumSelfCleanFrequency._value2member_map_
+ ):
+ return SELF_CLEAN_FREQUENCY_TO_NAME.get(
+ DreameVacuumSelfCleanFrequency(self_clean_frequency), STATE_UNKNOWN
+ )
+ return STATE_UNKNOWN
+
+ @property
+ def auto_empty_mode(self) -> DreameVacuumAutoEmptyMode | DreameVacuumAutoEmptyModeV2:
+ if self._capability.auto_empty_mode:
+ value = self._get_property(DreameVacuumProperty.AUTO_DUST_COLLECTING)
+ if self._capability.intelligent_auto_empty:
+ if value is not None and value in DreameVacuumAutoEmptyModeV2._value2member_map_:
+ return DreameVacuumAutoEmptyModeV2(value)
+ if value is not None:
+ _LOGGER.debug("AUTO_EMPTY_MODE not supported: %s", value)
+ return DreameVacuumAutoEmptyModeV2.UNKNOWN
+ else:
+ if value is not None and value in DreameVacuumAutoEmptyMode._value2member_map_:
+ return DreameVacuumAutoEmptyMode(value)
+ if value is not None:
+ _LOGGER.debug("AUTO_EMPTY_MODE not supported: %s", value)
+ return DreameVacuumAutoEmptyMode.UNKNOWN
+
+ @property
+ def auto_empty_mode_name(self) -> str:
+ """Return auto empty mode as string for translation."""
+ if self._capability.auto_empty_mode:
+ auto_empty_mode = self._get_property(DreameVacuumProperty.AUTO_DUST_COLLECTING)
+ if auto_empty_mode is not None:
+ if self._capability.intelligent_auto_empty:
+ if auto_empty_mode in DreameVacuumAutoEmptyModeV2._value2member_map_:
+ return AUTO_EMPTY_MODE_V2_TO_NAME.get(
+ DreameVacuumAutoEmptyModeV2(auto_empty_mode), STATE_UNKNOWN
+ )
+ else:
+ if auto_empty_mode is not None and auto_empty_mode in DreameVacuumAutoEmptyMode._value2member_map_:
+ return AUTO_EMPTY_MODE_TO_NAME.get(DreameVacuumAutoEmptyMode(auto_empty_mode), STATE_UNKNOWN)
+ return STATE_UNKNOWN
+
+ @property
+ def low_water_warning(self) -> DreameVacuumLowWaterWarning:
+ """Return low water warning of the device."""
+ value = self._get_property(DreameVacuumProperty.LOW_WATER_WARNING)
+ if value is not None and value in DreameVacuumLowWaterWarning._value2member_map_:
+ return DreameVacuumLowWaterWarning(value)
+ if value is not None:
+ _LOGGER.debug("LOW_WATER_WARNING not supported: %s", value)
+ return DreameVacuumLowWaterWarning.UNKNOWN
+
+ @property
+ def low_water_warning_name(self) -> str:
+ """Return low water warning as string for translation."""
+ return LOW_WATER_WARNING_TO_NAME.get(self.low_water_warning, STATE_UNKNOWN)
+
+ @property
+ def low_water_warning_name_description(self) -> str:
+ """Return low water warning description of the device."""
+ return LOW_WATER_WARNING_CODE_TO_DESCRIPTION.get(self.low_water_warning, [STATE_UNKNOWN, ""])
+
+ @property
+ def voice_assistant_language(self) -> DreameVacuumVoiceAssistantLanguage:
+ """Return voice assistant language of the device."""
+ value = self._get_property(DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE)
+ if value is not None and value in DreameVacuumVoiceAssistantLanguage._value2member_map_:
+ return DreameVacuumVoiceAssistantLanguage(value)
+ if value is not None:
+ _LOGGER.debug("VOICE_ASSISTANT_LANGUAGE not supported: %s", value)
+ return DreameVacuumVoiceAssistantLanguage.DEFAULT
+
+ @property
+ def voice_assistant_language_name(self) -> str:
+ """Return voice assistant language as string for translation."""
+ return VOICE_ASSISTANT_LANGUAGE_TO_NAME.get(self.voice_assistant_language, STATE_UNKNOWN)
+
+ @property
+ def mop_pressure(self) -> DreameVacuumMopPressure:
+ """Return mop pressure of the device."""
+ value = self._get_property(DreameVacuumProperty.MOP_PRESSURE)
+ if value is not None and value in DreameVacuumMopPressure._value2member_map_:
+ return DreameVacuumMopPressure(value)
+ if value is not None:
+ _LOGGER.debug("MOP_PRESSURE not supported: %s", value)
+ return DreameVacuumMopPressure.UNKNOWN
+
+ @property
+ def mop_pressure_name(self) -> str:
+ """Return mop pressure as string for translation."""
+ return MOP_PRESSURE_TO_NAME.get(self.mop_pressure, STATE_UNKNOWN)
+
+ @property
+ def mop_temperature(self) -> DreameVacuumMopTemperature:
+ """Return mop temperature of the device."""
+ value = self._get_property(DreameVacuumProperty.MOP_TEMPERATURE)
+ if value is not None and value in DreameVacuumMopTemperature._value2member_map_:
+ return DreameVacuumMopTemperature(value)
+ if value is not None:
+ _LOGGER.debug("MOP_TEMPERATURE not supported: %s", value)
+ return DreameVacuumMopTemperature.UNKNOWN
+
+ @property
+ def mop_temperature_name(self) -> str:
+ """Return mop temperature as string for translation."""
+ return MOP_TEMPERATURE_TO_NAME.get(self.mop_temperature, STATE_UNKNOWN)
+
+ @property
+ def low_lying_area_frequency(self) -> DreameVacuumLowLyingAreaFrequency:
+ """Return low lying area frequency of the device."""
+ value = self._get_property(DreameVacuumProperty.LOW_LYING_AREA_FREQUENCY)
+ if value is not None and value in DreameVacuumLowLyingAreaFrequency._value2member_map_:
+ return DreameVacuumLowLyingAreaFrequency(value)
+ if value is not None:
+ _LOGGER.debug("LOW_LYING_AREA_FREQUENCY not supported: %s", value)
+ return DreameVacuumLowLyingAreaFrequency.UNKNOWN
+
+ @property
+ def low_lying_area_frequency_name(self) -> str:
+ """Return low lying area frequency as string for translation."""
+ return LOW_LYING_AREA_FREQUENCY_TO_NAME.get(self.low_lying_area_frequency, STATE_UNKNOWN)
+
+ @property
+ def scraper_frequency(self) -> DreameVacuumScraperFrequency:
+ """Return scraper frequency of the device."""
+ value = self._get_property(DreameVacuumProperty.SCRAPER_FREQUENCY)
+ if value is not None and value in DreameVacuumScraperFrequency._value2member_map_:
+ return DreameVacuumScraperFrequency(value)
+ if value is not None:
+ _LOGGER.debug("SCRAPER_FREQUENCY not supported: %s", value)
+ return DreameVacuumScraperFrequency.UNKNOWN
+
+ @property
+ def scraper_frequency_name(self) -> str:
+ """Return scraper frequency as string for translation."""
+ return SCRAPER_FREQUENCY_TO_NAME.get(self.scraper_frequency, STATE_UNKNOWN)
+
+ @property
+ def drainage_status(self) -> DreameVacuumDrainageStatus:
+ """Return drainage status of the device."""
+ value = self._get_property(DreameVacuumProperty.DRAINAGE_STATUS)
+ if value is not None and value in DreameVacuumDrainageStatus._value2member_map_:
+ if self.state == DreameVacuumState.AUTO_WATER_DRAINING or self.state == DreameVacuumState.DRAINING:
+ return DreameVacuumDrainageStatus.DRAINING
+ return DreameVacuumDrainageStatus(value)
+ if value is not None:
+ _LOGGER.debug("DRAINAGE_STATUS not supported: %s", value)
+ return DreameVacuumDrainageStatus.UNKNOWN
+
+ @property
+ def drainage_status_name(self) -> str:
+ """Return drainage status as string for translation."""
+ return DRAINAGE_STATUS_TO_NAME.get(self.drainage_status, STATE_UNKNOWN)
+
+ @property
+ def task_type(self) -> DreameVacuumTaskType:
+ """Return drainage status of the device."""
+ value = self._get_property(DreameVacuumProperty.TASK_TYPE)
+ if value is not None and value in DreameVacuumTaskType._value2member_map_:
+ return DreameVacuumTaskType(value)
+ if value is not None:
+ _LOGGER.debug("TASK_TYPE not supported: %s", value)
+ return DreameVacuumTaskType.UNKNOWN
+
+ @property
+ def task_type_name(self) -> str:
+ """Return drainage status as string for translation."""
+ return TASK_TYPE_TO_NAME.get(self.task_type, STATE_UNKNOWN)
+
@property
def error(self) -> DreameVacuumErrorCode:
"""Return error of the device."""
- value = self._get_property(DreameVacuumProperty.ERROR)
+ value = self.faults[0] if self.faults else self._get_property(DreameVacuumProperty.ERROR)
if value is not None and value in DreameVacuumErrorCode._value2member_map_:
+ if (
+ value == DreameVacuumErrorCode.UNKNOWN_ERROR.value
+ or value == DreameVacuumErrorCode.UNKNOWN_WARNING.value
+ or (value == DreameVacuumErrorCode.BATTERY_LOW.value and self.charging)
+ ):
+ return DreameVacuumErrorCode.NO_ERROR
return DreameVacuumErrorCode(value)
- _LOGGER.debug("ERROR_CODE not supported: %s", value)
- return DreameVacuumErrorCode.UNKNOWN
+ if value is not None:
+ _LOGGER.debug("ERROR_CODE not supported: %s", value)
+ return DreameVacuumErrorCode.NO_ERROR
@property
def error_name(self) -> str:
@@ -2642,57 +8020,87 @@ def error_description(self) -> str:
@property
def error_image(self) -> str:
"""Return error image of the device as base64 string."""
- if not self.has_error:
- return None
- return ERROR_IMAGE.get(ERROR_CODE_TO_IMAGE_INDEX.get(self.error, 19))
+ error = self.error
+ if error is not DreameVacuumErrorCode.NO_ERROR:
+ return (ERROR_IMAGE_GEN5 if self._capability.gen5 else ERROR_IMAGE).get(
+ (ERROR_CODE_GEN5_TO_IMAGE_INDEX if self._capability.gen5 else ERROR_CODE_TO_IMAGE_INDEX).get(
+ error, 0 if error in WARNING_ERROR_CODE else 19
+ )
+ )
+
+ @property
+ def low_water(self) -> bool:
+ """Returns true when water level in the clean water tank is low."""
+ if self._capability.self_wash_base and not self.auto_water_refilling_enabled:
+ warning = self.low_water_warning
+ return warning and warning.value > 1
+ return False
@property
- def robot_status(self) -> int: # TODO: Convert to enum
+ def robot_status(self) -> int:
"""Device status for robot icon rendering."""
- if self.running and not self.returning and not self.fast_mapping:
- return 1
- elif self.self_wash_base_available and (self.washing or self.drying or self.washing_paused):
- if self.has_error or self.has_warning:
- return 6
- return 7
+ value = 0
+ if self.running and not self.returning and not self.fast_mapping and not self.cruising:
+ value = 1
elif self.charging:
- return 2
- elif self.has_error or self.has_warning:
- if self.sleeping:
- return 5
- else:
- return 3
+ value = 2
elif self.sleeping:
- return 4
+ value = 3
+ if self.has_error:
+ value += 10
+ if self.started and (self.sweeping or self.cruising):
+ value += 100
+ return value
+
+ @property
+ def station_status(self) -> int:
+ """Station status for charger icon rendering."""
+ if self._capability.auto_empty_base and self.auto_emptying:
+ return 1
+ if self._capability.self_wash_base:
+ value = 0
+ if self.washing:
+ value = 2
+ if self.washing_paused:
+ value = 3
+ if self.drying:
+ value = 4
+ elif self.dust_bag_drying:
+ value = 6 if self.dust_bag_drying_paused else 5
+ if value and self.hot_washing:
+ value = value + 10
+ return value
return 0
@property
def has_error(self) -> bool:
"""Returns true when an error is present."""
error = self.error
- return bool(error.value > 0 and not self.has_warning and error != DreameVacuumErrorCode.BATTERY_LOW)
+ return bool(error != DreameVacuumErrorCode.NO_ERROR and not self.has_warning)
@property
def has_warning(self) -> bool:
"""Returns true when a warning is present and available for dismiss."""
error = self.error
- return bool(
- error.value > 0
- and (
- error == DreameVacuumErrorCode.REMOVE_MOP
- or error == DreameVacuumErrorCode.MOP_REMOVED_2
- or error == DreameVacuumErrorCode.CLEAN_MOP_PAD
- or error == DreameVacuumErrorCode.BLOCKED
- or error == DreameVacuumErrorCode.WATER_TANK_DRY
- or error == DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE
- or error == DreameVacuumErrorCode.MOP_PAD_STOP_ROTATE_2
- )
- )
+ return bool(error in WARNING_ERROR_CODE)
@property
def dust_collection_available(self) -> bool:
"""Returns true when robot is docked and can start auto emptying."""
- return bool(self._get_property(DreameVacuumProperty.DUST_COLLECTION))
+ return bool(
+ (
+ self._get_property(DreameVacuumProperty.DUST_COLLECTION) == 1
+ or (
+ (self._capability.auto_empty_mode or self._capability.gen5)
+ and self.started
+ and (not self.returning or self.returning_paused)
+ and not self.returning_to_wash
+ )
+ )
+ and (not self.washing or self.washing_paused)
+ and not self.draining
+ and not self.self_repairing
+ )
@property
def self_clean(self) -> bool:
@@ -2700,16 +8108,28 @@ def self_clean(self) -> bool:
@property
def scheduled_clean(self) -> bool:
- return bool(self._get_property(DreameVacuumProperty.SCHEDULED_CLEAN) == 1)
+ if self.started:
+ value = self._get_property(DreameVacuumProperty.SCHEDULED_CLEAN)
+ return bool(value == 1 or value == 2 or value == 4)
+ return False
+
+ @property
+ def auto_mount_mop(self) -> bool:
+ return bool(
+ self._capability.mop_pad_unmounting and self._get_property(DreameVacuumProperty.AUTO_MOUNT_MOP) == 1
+ )
@property
- def auto_mount(self) -> bool:
- return bool(self._get_property(DreameVacuumProperty.AUTO_MOUNT_MOP) == 1)
+ def camera_light_brightness(self) -> int:
+ if self._capability.camera_streaming:
+ brightness = self._get_property(DreameVacuumProperty.CAMERA_LIGHT_BRIGHTNESS)
+ if brightness and str(brightness).isnumeric():
+ return int(brightness)
@property
def dnd_remaining(self) -> bool:
"""Returns remaining seconds to DND period to end."""
- if self.dnd_enabled:
+ if self.dnd:
dnd_start = self.dnd_start
dnd_end = self.dnd_end
if dnd_start and dnd_end:
@@ -2747,8 +8167,20 @@ def dnd_remaining(self) -> bool:
@property
def water_tank_or_mop_installed(self) -> bool:
"""Returns true when water tank or additional mop is installed to the device."""
- water_tank = self.water_tank
- return bool(water_tank is DreameVacuumWaterTank.INSTALLED or water_tank is DreameVacuumWaterTank.MOP_INSTALLED)
+ installed = self._get_property(DreameVacuumProperty.WATER_TANK) != DreameVacuumWaterTank.NOT_INSTALLED.value
+ if self._capability.mop_pad_unmounting:
+ value = self._get_property(DreameVacuumProperty.MOP_PAD_INSTALLED)
+ if value is not None:
+ return bool(value == 0 or installed)
+ return bool(installed or self._capability.embedded_tank)
+
+ @property
+ def mop_pad_installed(self) -> bool:
+ """Returns true when mop is installed on vacuums with mop pad unmounting feature."""
+ if self._capability.mop_pad_unmounting:
+ value = self._get_property(DreameVacuumProperty.MOP_PAD_INSTALLED)
+ return self.water_tank_or_mop_installed if value is None else bool(value == 0)
+ return self.water_tank_or_mop_installed
@property
def located(self) -> bool:
@@ -2757,15 +8189,19 @@ def located(self) -> bool:
return bool(
relocation_status is DreameVacuumRelocationStatus.LOCATED
or relocation_status is DreameVacuumRelocationStatus.UNKNOWN
+ or self.fast_mapping
)
@property
def sweeping(self) -> bool:
"""Returns true when cleaning mode is sweeping therefore cannot set its water volume."""
cleaning_mode = self.cleaning_mode
+ if cleaning_mode is None:
+ return not self.water_tank_or_mop_installed
return bool(
cleaning_mode is not DreameVacuumCleaningMode.MOPPING
and cleaning_mode is not DreameVacuumCleaningMode.SWEEPING_AND_MOPPING
+ and cleaning_mode is not DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING
)
@property
@@ -2773,13 +8209,22 @@ def mopping(self) -> bool:
"""Returns true when cleaning mode is mopping therefore cannot set its suction level."""
return bool(self.cleaning_mode is DreameVacuumCleaningMode.MOPPING)
+ @property
+ def mopping_after_sweeping(self) -> bool:
+ """Returns true when cleaning mode is mopping after sweeping therefore cannot change the cleaning mode when active."""
+ return bool(self.cleaning_mode is DreameVacuumCleaningMode.MOPPING_AFTER_SWEEPING)
+
+ @property
+ def sweeping_and_mopping(self) -> bool:
+ """Returns true when cleaning mode is sweeping and mopping."""
+ return bool(self.cleaning_mode is DreameVacuumCleaningMode.SWEEPING_AND_MOPPING)
+
@property
def zone_cleaning(self) -> bool:
"""Returns true when device is currently performing a zone cleaning task."""
task_status = self.task_status
return bool(
- self._device_connected
- and self.started
+ self.started
and (
task_status is DreameVacuumTaskStatus.ZONE_CLEANING
or task_status is DreameVacuumTaskStatus.ZONE_CLEANING_PAUSED
@@ -2793,8 +8238,7 @@ def spot_cleaning(self) -> bool:
"""Returns true when device is currently performing a spot cleaning task."""
task_status = self.task_status
return bool(
- self._device_connected
- and self.started
+ self.started
and (
task_status is DreameVacuumTaskStatus.SPOT_CLEANING
or task_status is DreameVacuumTaskStatus.SPOT_CLEANING_PAUSED
@@ -2807,8 +8251,7 @@ def segment_cleaning(self) -> bool:
"""Returns true when device is currently performing a custom segment cleaning task."""
task_status = self.task_status
return bool(
- self._device_connected
- and self.started
+ self.started
and (
task_status is DreameVacuumTaskStatus.SEGMENT_CLEANING
or task_status is DreameVacuumTaskStatus.SEGMENT_CLEANING_PAUSED
@@ -2822,8 +8265,7 @@ def auto_cleaning(self) -> bool:
"""Returns true when device is currently performing a complete map cleaning task."""
task_status = self.task_status
return bool(
- self._device_connected
- and self.started
+ self.started
and (
task_status is DreameVacuumTaskStatus.AUTO_CLEANING
or task_status is DreameVacuumTaskStatus.AUTO_CLEANING_PAUSED
@@ -2836,12 +8278,9 @@ def auto_cleaning(self) -> bool:
def fast_mapping(self) -> bool:
"""Returns true when device is creating a new map."""
return bool(
- self._device_connected
- and (
- self.task_status is DreameVacuumTaskStatus.FAST_MAPPING
- or self.status is DreameVacuumStatus.FAST_MAPPING
- or self.fast_mapping_paused
- )
+ self.task_status is DreameVacuumTaskStatus.FAST_MAPPING
+ or self.status is DreameVacuumStatus.FAST_MAPPING
+ or self.fast_mapping_paused
)
@property
@@ -2854,21 +8293,120 @@ def fast_mapping_paused(self) -> bool:
task_status = self.task_status
return bool(
(
- task_status == DreameVacuumTaskStatus.FAST_MAPPING
- or task_status == DreameVacuumTaskStatus.MAP_CLEANING_PAUSED
+ task_status is DreameVacuumTaskStatus.FAST_MAPPING
+ or task_status is DreameVacuumTaskStatus.MAP_CLEANING_PAUSED
+ )
+ and (
+ state == DreameVacuumState.PAUSED.value
+ or state == DreameVacuumState.ERROR.value
+ or state == DreameVacuumState.IDLE.value
)
+ )
+
+ @property
+ def draining(self) -> bool:
+ """Returns true when device has a self-wash base and draining is performing."""
+ return bool(self._capability.drainage and self.drainage_status is DreameVacuumDrainageStatus.DRAINING)
+
+ @property
+ def draining_complete(self) -> bool:
+ """Returns true when device has a self-wash base and draining is performing."""
+ return bool(
+ self._capability.drainage
and (
- state == DreameVacuumState.PAUSED
- or state == DreameVacuumState.ERROR
- or state == DreameVacuumState.IDLE
+ self.drainage_status is DreameVacuumDrainageStatus.DRAINING_FAILED
+ or self.drainage_status is DreameVacuumDrainageStatus.DRAINING_SUCCESS
+ )
+ )
+
+ @property
+ def self_repairing(self) -> bool:
+ """Returns true when device is self repairing/testing or water checking."""
+ status = self.status
+ return bool(
+ status is DreameVacuumStatus.SELF_REPAIR
+ or status is DreameVacuumStatus.WATER_CHECK
+ or self.state is DreameVacuumState.WATER_CHECK
+ )
+
+ @property
+ def station_cleaning(self) -> bool:
+ """Returns true when base station is cleaning."""
+ task_status = self.task_status
+ return bool(
+ task_status is DreameVacuumTaskStatus.STATION_CLEANING
+ or (
+ self._capability.washboard_cleaning_status
+ and self._get_property(DreameVacuumProperty.WASHBOARD_CLEANING_STATUS) == 1
)
)
+ @property
+ def cruising(self) -> bool:
+ """Returns true when device is cruising."""
+ if self._capability.cruising:
+ task_status = self.task_status
+ status = self.status
+ return bool(
+ task_status is DreameVacuumTaskStatus.CRUISING_PATH
+ or task_status is DreameVacuumTaskStatus.CRUISING_POINT
+ or task_status is DreameVacuumTaskStatus.CRUISING_PATH_PAUSED
+ or task_status is DreameVacuumTaskStatus.CRUISING_POINT_PAUSED
+ or status is DreameVacuumStatus.CRUISING_PATH
+ or status is DreameVacuumStatus.CRUISING_POINT
+ )
+ return bool(self.go_to_zone)
+
+ @property
+ def cruising_paused(self) -> bool:
+ """Returns true when cruising paused."""
+ if self._capability.cruising:
+ task_status = self.task_status
+ return bool(
+ task_status is DreameVacuumTaskStatus.CRUISING_PATH_PAUSED
+ or task_status is DreameVacuumTaskStatus.CRUISING_POINT_PAUSED
+ )
+ if self.go_to_zone:
+ status = self.status
+ if self.started and (
+ status is DreameVacuumStatus.PAUSED
+ or status is DreameVacuumStatus.SLEEPING
+ or status is DreameVacuumStatus.IDLE
+ or status is DreameVacuumStatus.STANDBY
+ ):
+ return True
+ return False
+
@property
def carpet_avoidance(self) -> bool:
- """Returns true when carpet avoidance feature is enabled."""
- value = self._get_property(DreameVacuumProperty.CARPET_AVOIDANCE)
- return bool(value == 1)
+ """Returns true when carpet avoidance is enabled."""
+ return bool(
+ self._capability.carpet_recognition
+ and (
+ self.carpet_cleaning is DreameVacuumCarpetCleaning.AVOIDANCE
+ or self.carpet_cleaning is DreameVacuumCarpetCleaning.IGNORE
+ )
+ )
+
+ @property
+ def resume_cleaning(self) -> bool:
+ """Returns true when resume_cleaning is enabled."""
+ return bool(
+ self._get_property(DreameVacuumProperty.RESUME_CLEANING) == (2 if self._capability.auto_charging else 1)
+ )
+
+ @property
+ def carpet_recognition(self) -> bool:
+ """Returns true when carpet recognition is enabled."""
+ return bool(
+ self._capability.carpet_recognition and self._get_property(DreameVacuumProperty.CARPET_RECOGNITION) == 1
+ )
+
+ @property
+ def mop_in_station(self) -> bool:
+ """Returns true when the mop pad is in the station."""
+ value = self._get_property(DreameVacuumProperty.MOP_IN_STATION)
+ return bool(value == 1 or value == 4) and not self.docked
@property
def auto_add_detergent(self) -> bool:
@@ -2884,17 +8422,23 @@ def cleaning_paused(self) -> bool:
@property
def charging(self) -> bool:
"""Returns true when device is currently charging."""
- return bool(self.charging_status is DreameVacuumChargingStatus.CHARGING)
+ return bool(
+ self.charging_status is DreameVacuumChargingStatus.CHARGING
+ and self.battery_level < self.battery_charge_level
+ )
@property
def docked(self) -> bool:
"""Returns true when device is docked."""
return bool(
- self.charging
- or self.charging_status is DreameVacuumChargingStatus.CHARGING_COMPLETED
- or self.washing
- or self.drying
- or self.washing_paused
+ (
+ self.charging_status is DreameVacuumChargingStatus.CHARGING
+ or self.charging_status is DreameVacuumChargingStatus.CHARGING_COMPLETED
+ or self.washing
+ or self.drying
+ or self.washing_paused
+ )
+ and not (self.running and not self.returning and not self.fast_mapping and not self.cruising)
)
@property
@@ -2907,37 +8451,79 @@ def returning_paused(self) -> bool:
"""Returns true when returning to dock is paused."""
task_status = self.task_status
return bool(
- self._device_connected
- and task_status is DreameVacuumTaskStatus.DOCKING_PAUSED
- or task_status is DreameVacuumTaskStatus.AUTO_DOCKING_PAUSED
- or task_status is DreameVacuumTaskStatus.SEGMENT_DOCKING_PAUSED
- or task_status is DreameVacuumTaskStatus.ZONE_DOCKING_PAUSED
+ not self.docked
+ and (
+ task_status is DreameVacuumTaskStatus.DOCKING_PAUSED
+ or task_status is DreameVacuumTaskStatus.AUTO_DOCKING_PAUSED
+ or task_status is DreameVacuumTaskStatus.SEGMENT_DOCKING_PAUSED
+ or task_status is DreameVacuumTaskStatus.ZONE_DOCKING_PAUSED
+ )
)
@property
def returning(self) -> bool:
"""Returns true when returning to dock for charging or washing."""
- return bool(self._device_connected and (self.status is DreameVacuumStatus.BACK_HOME or self.returning_to_wash))
+ return bool((self.status is DreameVacuumStatus.BACK_HOME or self.returning_to_wash) and not self.docked)
@property
def started(self) -> bool:
"""Returns true when device has an active task.
- Used for preventing updates on settings that relates to currently performing task."""
- return bool(self.task_status != DreameVacuumTaskStatus.COMPLETED or self.cleaning_paused)
-
- @property
- def paused(self) -> bool:
- """Returns true when device has an active paused task."""
+ Used for preventing updates on settings that relates to currently performing task.
+ """
status = self.status
return bool(
- self.started
- and (
- status is DreameVacuumStatus.PAUSED
- or status is DreameVacuumStatus.SLEEPING
- or status is DreameVacuumStatus.IDLE
- or status is DreameVacuumStatus.STANDBY
+ (
+ self.task_status is not DreameVacuumTaskStatus.COMPLETED
+ and self.task_status is not DreameVacuumTaskStatus.DOCKING_PAUSED
)
or self.cleaning_paused
+ or status is DreameVacuumStatus.CLEANING
+ or status is DreameVacuumStatus.SEGMENT_CLEANING
+ or status is DreameVacuumStatus.ZONE_CLEANING
+ or status is DreameVacuumStatus.SPOT_CLEANING
+ or status is DreameVacuumStatus.PART_CLEANING
+ or status is DreameVacuumStatus.FAST_MAPPING
+ or status is DreameVacuumStatus.CRUISING_PATH
+ or status is DreameVacuumStatus.CRUISING_POINT
+ or status is DreameVacuumStatus.SHORTCUT
+ )
+
+ @property
+ def paused(self) -> bool:
+ """Returns true when device has an active paused task."""
+ status = self.status
+ task_type = self.task_type
+ return bool(
+ self.cleaning_paused
+ or self.cruising_paused
+ or (
+ self.started
+ and (
+ status is DreameVacuumStatus.PAUSED
+ or status is DreameVacuumStatus.SLEEPING
+ or status is DreameVacuumStatus.IDLE
+ or status is DreameVacuumStatus.STANDBY
+ or status is DreameVacuumStatus.REMOTE_CONTROL
+ or (
+ status is DreameVacuumStatus.ERROR
+ and self.state is DreameVacuumState.ERROR
+ and not self.washing_paused
+ )
+ )
+ )
+ or (
+ self._capability.task_type
+ and (
+ task_type is DreameVacuumTaskType.STANDARD_PAUSED
+ or task_type is DreameVacuumTaskType.CUSTOM_PAUSED
+ or task_type is DreameVacuumTaskType.SHORTCUT_PAUSED
+ or task_type is DreameVacuumTaskType.SCHEDULED_PAUSED
+ or task_type is DreameVacuumTaskType.SMART_PAUSED
+ or task_type is DreameVacuumTaskType.PARTIAL_PAUSED
+ or task_type is DreameVacuumTaskType.SUMMON_PAUSED
+ or task_type is DreameVacuumTaskType.WATER_STAIN_PAUSED
+ )
+ )
)
@property
@@ -2950,24 +8536,40 @@ def running(self) -> bool:
"""Returns true when device is moving."""
status = self.status
return bool(
- not self.docked
+ not (
+ self.charging
+ or self.charging_status is DreameVacuumChargingStatus.CHARGING_COMPLETED
+ or self.washing
+ or self.drying
+ or self.washing_paused
+ )
and (
status is DreameVacuumStatus.CLEANING
or status is DreameVacuumStatus.BACK_HOME
or status is DreameVacuumStatus.PART_CLEANING
or status is DreameVacuumStatus.FOLLOW_WALL
- or status is DreameVacuumStatus.REMOTE_CONTROL
or status is DreameVacuumStatus.SEGMENT_CLEANING
or status is DreameVacuumStatus.ZONE_CLEANING
or status is DreameVacuumStatus.SPOT_CLEANING
or status is DreameVacuumStatus.PART_CLEANING
or status is DreameVacuumStatus.FAST_MAPPING
- or status is DreameVacuumStatus.MONITOR_CRUISE
- or status is DreameVacuumStatus.MONITOR_SPOT
+ or status is DreameVacuumStatus.CRUISING_PATH
+ or status is DreameVacuumStatus.CRUISING_POINT
or status is DreameVacuumStatus.SUMMON_CLEAN
+ or status is DreameVacuumStatus.SHORTCUT
+ or status is DreameVacuumStatus.PERSON_FOLLOW
)
)
+ @property
+ def shortcut_task(self) -> bool:
+ """Returns true when device has an active shortcut task."""
+ if self.started and self.shortcuts:
+ for k, v in self.shortcuts.items():
+ if v.running:
+ return True
+ return False
+
@property
def auto_emptying(self) -> bool:
"""Returns true when device is auto emptying."""
@@ -2981,7 +8583,58 @@ def auto_emptying_not_performed(self) -> bool:
@property
def customized_cleaning(self) -> bool:
"""Returns true when customized cleaning feature is enabled."""
- return bool(self._get_property(DreameVacuumProperty.CUSTOMIZED_CLEANING) and self.has_saved_map)
+ return bool(
+ self._get_property(DreameVacuumProperty.CUSTOMIZED_CLEANING)
+ and self.has_saved_map
+ and not self.cleangenius_cleaning
+ )
+
+ @property
+ def cleangenius_cleaning(self) -> bool:
+ """Returns true when CleanGenius feature is enabled."""
+ return bool(
+ self._capability.cleangenius
+ and self._get_property(DreameVacuumAutoSwitchProperty.CLEANGENIUS)
+ and self.mop_pad_installed
+ and not self.zone_cleaning
+ and not self.spot_cleaning
+ )
+
+ @property
+ def custom_mopping_mode(self) -> bool:
+ """Returns true when custom mopping mode feature is enabled."""
+ return bool(
+ self._capability.mopping_settings
+ and self._get_property(DreameVacuumAutoSwitchProperty.CUSTOM_MOPPING_MODE) != 0
+ )
+
+ @property
+ def max_suction_power(self) -> bool:
+ """Returns true when max suction power feature is enabled."""
+ return bool(
+ self._capability.max_suction_power
+ and self._get_property(DreameVacuumAutoSwitchProperty.MAX_SUCTION_POWER) == 1
+ )
+
+ @property
+ def ultra_clean_mode(self) -> bool:
+ """Returns true when ultra clean mode is enabled."""
+ return bool(
+ self._capability.ultra_clean_mode
+ and self._get_property(DreameVacuumAutoSwitchProperty.ULTRA_CLEAN_MODE) == 1
+ )
+
+ @property
+ def mop_extend(self) -> bool:
+ """Returns true when mop extend feature is enabled."""
+ return bool(self._capability.mop_extend and self._get_property(DreameVacuumAutoSwitchProperty.MOP_EXTEND) == 1)
+
+ @property
+ def smart_mop_washing(self) -> bool:
+ """Returns true when smart mop washing feature is enabled."""
+ return bool(
+ self._capability.smart_mop_washing and self._get_property(DreameVacuumProperty.SMART_MOP_WASHING) == 1
+ )
@property
def multi_map(self) -> bool:
@@ -2993,40 +8646,97 @@ def last_cleaning_time(self) -> datetime | None:
if self._cleaning_history:
return self._last_cleaning_time
+ @property
+ def last_cruising_time(self) -> datetime | None:
+ if self._cruising_history:
+ return self._last_cruising_time
+
@property
def cleaning_history(self) -> dict[str, Any] | None:
"""Returns the cleaning history list as dict."""
if self._cleaning_history:
- list = {}
- for history in self._cleaning_history:
- date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(history.date.timestamp()))
- list[date] = {
- ATTR_CLEANING_TIME: f"{history.cleaning_time} min",
- ATTR_CLEANED_AREA: f"{history.cleaned_area} m²",
- }
- if history.status is not None:
- list[date][ATTR_STATUS] = (
- STATUS_CODE_TO_NAME.get(history.status, STATE_UNKNOWN).replace("_", " ").capitalize()
+ if self._cleaning_history_attrs is None:
+ list = {}
+ for history in self._cleaning_history:
+ date = time.strftime(
+ "%Y-%m-%d %H:%M" if datetime.now().year != history.date.year else "%m-%d %H:%M",
+ time.localtime(history.date.timestamp()),
)
- if history.suction_level is not None:
- list[date][ATTR_SUCTION_LEVEL] = (
- SUCTION_LEVEL_CODE_TO_NAME.get(history.suction_level, STATE_UNKNOWN)
- .replace("_", " ")
- .capitalize()
- )
- if history.completed is not None:
- list[date][ATTR_COMPLETED] = history.completed
- if history.water_tank is not None:
- list[date][ATTR_WATER_TANK] = (
- WATER_TANK_CODE_TO_NAME.get(history.water_tank, STATE_UNKNOWN).replace("_", " ").capitalize()
+ list[date] = {
+ ATTR_TIMESTAMP: history.date.timestamp(),
+ ATTR_CLEANING_TIME: f"{history.cleaning_time} min",
+ ATTR_CLEANED_AREA: f"{history.cleaned_area} m²",
+ }
+ if history.status is not None:
+ list[date][ATTR_STATUS] = (
+ STATUS_CODE_TO_NAME.get(history.status, STATE_UNKNOWN).replace("_", " ").capitalize()
+ )
+ if history.suction_level is not None:
+ list[date][ATTR_SUCTION_LEVEL] = (
+ SUCTION_LEVEL_CODE_TO_NAME.get(history.suction_level, STATE_UNKNOWN)
+ .replace("_", " ")
+ .capitalize()
+ )
+ if history.completed is not None:
+ list[date][ATTR_COMPLETED] = history.completed
+ if history.water_tank_or_mop is not None:
+ list[date][ATTR_MOP_PAD if self._capability.self_wash_base else ATTR_WATER_TANK] = (
+ WATER_TANK_CODE_TO_NAME.get(history.water_tank_or_mop, STATE_UNKNOWN)
+ .replace("_", " ")
+ .capitalize()
+ )
+ if isinstance(history.blocked_segments, dict):
+ list[date][ATTR_BLOCKED_SEGMENTS] = {
+ k: v[0].name.replace("_", " ").capitalize() for k, v in history.blocked_segments.items()
+ }
+ if history.cleanup_method is not None:
+ list[date][ATTR_CLEANUP_METHOD] = history.cleanup_method.name.replace("_", " ").capitalize()
+ if history.task_interrupt_reason is not None:
+ list[date][ATTR_INTERRUPT_REASON] = history.task_interrupt_reason.name.replace(
+ "_", " "
+ ).capitalize()
+ if history.multiple_cleaning_time is not None:
+ list[date][ATTR_MULTIPLE_CLEANING_TIME] = history.multiple_cleaning_time
+ if self._capability.pet_detective or history.pet is not None:
+ list[date][ATTR_PET] = bool(history.pet)
+
+ self._cleaning_history_attrs = list
+ return self._cleaning_history_attrs
+
+ @property
+ def cruising_history(self) -> dict[str, Any] | None:
+ """Returns the cruising history list as dict."""
+ if self._cruising_history:
+ if self._cruising_history_attrs is None:
+ list = {}
+ for history in self._cruising_history:
+ date = time.strftime(
+ "%Y-%m-%d %H:%M" if datetime.now().year != history.date.year else "%m-%d %H:%M",
+ time.localtime(history.date.timestamp()),
)
- return list
+ list[date] = {
+ ATTR_CRUISING_TIME: f"{history.cleaning_time} min",
+ }
+ if history.status is not None:
+ list[date][ATTR_STATUS] = (
+ STATUS_CODE_TO_NAME.get(history.status, STATE_UNKNOWN).replace("_", " ").capitalize()
+ )
+ if history.cruise_type is not None:
+ list[date][ATTR_CRUISING_TYPE] = history.cruise_type
+ if history.map_index is not None:
+ list[date][ATTR_MAP_INDEX] = history.map_index
+ if history.map_name is not None and len(history.map_name) > 1:
+ list[date][ATTR_MAP_NAME] = history.map_name
+ if history.completed is not None:
+ list[date][ATTR_COMPLETED] = history.completed
+ self._cruising_history_attrs = list
+ return self._cruising_history_attrs
@property
def washing(self) -> bool:
"""Returns true the when device is currently performing mop washing."""
return bool(
- self.self_wash_base_available
+ self._capability.self_wash_base
and (
self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.WASHING
or self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.CLEAN_ADD_WATER
@@ -3034,132 +8744,598 @@ def washing(self) -> bool:
)
@property
- def drying(self) -> bool:
- """Returns true the when device is currently performing mop drying."""
- return bool(
- self.self_wash_base_available and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.DRYING
- )
+ def drying(self) -> bool:
+ """Returns true the when device is currently performing mop drying."""
+ return bool(
+ self._capability.self_wash_base and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.DRYING
+ )
+
+ @property
+ def dust_bag_drying(self) -> bool:
+ """Returns true the when device is currently performing dust bag drying."""
+ return bool(
+ (self._capability.dust_bag_drying or self._capability.manual_dust_bag_drying)
+ and (
+ self.dust_bag_drying_status is DreameVacuumDustBagDryingStatus.DRYING
+ or self.dust_bag_drying_status is DreameVacuumDustBagDryingStatus.PAUSED
+ )
+ )
+
+ @property
+ def dust_bag_drying_paused(self) -> bool:
+ """Returns true the when dust bag drying is paused."""
+ return bool(
+ (self._capability.dust_bag_drying or self._capability.manual_dust_bag_drying)
+ and self.dust_bag_drying_status is DreameVacuumDustBagDryingStatus.PAUSED
+ )
+
+ @property
+ def dust_bag_drying_available(self) -> bool:
+ """Returns true the when dust bag drying is available."""
+ return bool(
+ (self._capability.dust_bag_drying or self._capability.manual_dust_bag_drying)
+ and self.task_status is not DreameVacuumTaskStatus.STATION_CLEANING
+ and self.docked
+ and not self.auto_emptying
+ and not self.washing
+ and not self.washing_paused
+ and self.dust_bag_status is not DreameVacuumDustBagStatus.NOT_INSTALLED
+ and self._get_property(DreameVacuumProperty.DUST_BOX_STATUS) != 1
+ )
+
+ @property
+ def washing_paused(self) -> bool:
+ """Returns true when mop washing paused."""
+ return bool(
+ self._capability.self_wash_base and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.PAUSED
+ )
+
+ @property
+ def returning_to_wash(self) -> bool:
+ """Returns true when the device returning to self-wash base to wash or dry its mop."""
+ return bool(
+ self._capability.self_wash_base
+ and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.RETURNING
+ and (self.state is DreameVacuumState.RETURNING or self.state is DreameVacuumState.RETURNING_TO_WASH)
+ )
+
+ @property
+ def returning_to_wash_paused(self) -> bool:
+ """Returns true when the device returning to self-wash base to wash or dry its mop."""
+ return bool(
+ self._capability.self_wash_base
+ and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.RETURNING
+ and self.state is DreameVacuumState.PAUSED
+ )
+
+ @property
+ def washing_available(self) -> bool:
+ """Returns true when device has a self-wash base and washing mop can be performed."""
+ return bool(
+ self._capability.self_wash_base
+ and (self.water_tank_or_mop_installed or self.mop_in_station)
+ and not (
+ self.washing
+ or self.washing_paused
+ or self.returning_to_wash_paused
+ or self.returning_to_wash
+ or self.returning
+ or self.returning_paused
+ or self.cleaning_paused
+ # or self.drying
+ )
+ )
+
+ @property
+ def drying_available(self) -> bool:
+ """Returns true when device has a self-wash base and drying mop can be performed."""
+ return bool(
+ self._capability.self_wash_base
+ and self.water_tank_or_mop_installed
+ and self.docked
+ and not self.washing
+ and not self.washing_paused
+ and not self.started
+ and not self.draining
+ and not self.self_repairing
+ )
+
+ @property
+ def water_tank_emptying_available(self) -> bool:
+ """Returns true when device has a self-wash base and water tank draining be performed."""
+ return bool(
+ self._capability.water_tank_draining
+ and not (
+ self.draining
+ or self.self_repairing
+ or self.washing
+ or self.washing_paused
+ or self.returning_to_wash_paused
+ or self.returning_to_wash
+ or self.started
+ )
+ )
+
+ @property
+ def maximum_maps(self) -> int:
+ return (
+ 1 if not self._capability.lidar_navigation or not self.multi_map else 4 if self._capability.wifi_map else 3
+ )
+
+ @property
+ def mapping_available(self) -> bool:
+ """Returns true when creating a new map is possible."""
+ return bool(
+ not self.started
+ and not self.fast_mapping
+ and (not self._device.capability.map or self.maximum_maps > len(self.map_list))
+ )
+
+ @property
+ def second_cleaning_available(self) -> bool:
+ if self._cleaning_history and self.current_map:
+ history = self._cleaning_history[0]
+ if history.object_name:
+ map_data = self._history_map_data.get(history.object_name)
+ return bool(
+ (map_data is not None and self.current_map.map_id == map_data.map_id)
+ and (
+ bool(history.blocked_segments)
+ or bool(
+ history.cleanup_method.value == 2
+ and not (history.mopping_mode != 2 and not self.mop_pad_installed)
+ and (history.second_mopping == 2 or map_data.cleaned_segments)
+ and map_data.cleaning_map_data is not None
+ and (map_data.cleaning_map_data.has_dirty_area and not self._capability.cleangenius_auto)
+ )
+ )
+ )
+ return False
+
+ @property
+ def main_brush_life(self) -> int:
+ """Returns main brush remaining life in percent."""
+ return self._get_property(DreameVacuumProperty.MAIN_BRUSH_LEFT)
+
+ @property
+ def side_brush_life(self) -> int:
+ """Returns side brush remaining life in percent."""
+ return self._get_property(DreameVacuumProperty.SIDE_BRUSH_LEFT)
+
+ @property
+ def filter_life(self) -> int:
+ """Returns filter remaining life in percent."""
+ return self._get_property(DreameVacuumProperty.FILTER_LEFT)
+
+ @property
+ def sensor_dirty_life(self) -> int:
+ """Returns sensor clean remaining time in percent."""
+ return self._get_property(DreameVacuumProperty.SENSOR_DIRTY_LEFT)
+
+ @property
+ def tank_filter_life(self) -> int:
+ """Returns tank filter remaining life in percent."""
+ return self._get_property(DreameVacuumProperty.TANK_FILTER_LEFT)
+
+ @property
+ def mop_life(self) -> int:
+ """Returns mop remaining life in percent."""
+ return self._get_property(DreameVacuumProperty.MOP_PAD_LEFT)
+
+ @property
+ def silver_ion_life(self) -> int:
+ """Returns silver-ion life in percent."""
+ return self._get_property(DreameVacuumProperty.SILVER_ION_LEFT)
+
+ @property
+ def detergent_life(self) -> int:
+ """Returns detergent life in percent."""
+ return self._get_property(DreameVacuumProperty.DETERGENT_LEFT)
+
+ @property
+ def squeegee_life(self) -> int:
+ """Returns squeegee life in percent."""
+ return self._get_property(DreameVacuumProperty.SQUEEGEE_LEFT)
+
+ @property
+ def onboard_dirty_water_tank_life(self) -> int:
+ """Returns onboard dirty water tank life in percent."""
+ return self._get_property(DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_LEFT)
+
+ @property
+ def dirty_water_channel_dirty_life(self) -> int:
+ """Returns dirty water channel life in percent."""
+ return self._get_property(DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_LEFT)
+
+ @property
+ def deodorizer_life(self) -> int:
+ """Returns deodorizer life in percent."""
+ return self._get_property(DreameVacuumProperty.DEODORIZER_LEFT)
+
+ @property
+ def wheel_dirty_life(self) -> int:
+ """Returns wheel life in percent."""
+ return self._get_property(DreameVacuumProperty.WHEEL_DIRTY_LEFT)
+
+ @property
+ def scale_inhibitor_life(self) -> int:
+ """Returns scale inhibitor life in percent."""
+ return self._get_property(DreameVacuumProperty.SCALE_INHIBITOR_LEFT)
+
+ @property
+ def fluffing_roller_dirty_life(self) -> int:
+ """Returns fluffing roller life in percent."""
+ return self._get_property(DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_LEFT)
+
+ @property
+ def roller_mop_filter_dirty_life(self) -> int:
+ """Returns roller mop filter life in percent."""
+ return self._get_property(DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_LEFT)
+
+ @property
+ def water_outlet_filter_dirty_life(self) -> int:
+ """Returns water outlet filter life in percent."""
+ return self._get_property(DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_LEFT)
+
+ @property
+ def dnd(self) -> bool | None:
+ """Returns DND is enabled."""
+ if self._capability.dnd:
+ return (
+ bool(self._get_property(DreameVacuumProperty.DND))
+ if not self._capability.dnd_task
+ else self.dnd_tasks[0].enabled if self.dnd_tasks and len(self.dnd_tasks) else False
+ )
+
+ @property
+ def dnd_start(self) -> str | None:
+ """Returns DND start time."""
+ if self._capability.dnd:
+ return (
+ self._get_property(DreameVacuumProperty.DND_START)
+ if not self._capability.dnd_task
+ else self.dnd_tasks[0].start if self.dnd_tasks and len(self.dnd_tasks) else "22:00"
+ )
+
+ @property
+ def dnd_end(self) -> str | None:
+ """Returns DND end time."""
+ if self._capability.dnd:
+ return (
+ self._get_property(DreameVacuumProperty.DND_END)
+ if not self._capability.dnd_task
+ else self.dnd_tasks[0].end if self.dnd_tasks and len(self.dnd_tasks) else "08:00"
+ )
+
+ @property
+ def off_peak_charging(self) -> bool | None:
+ """Returns Off-Peak charging is enabled."""
+ if self._capability.off_peak_charging:
+ return bool(
+ self._capability.off_peak_charging
+ and len(self.off_peak_charging_config)
+ and self.off_peak_charging_config.get("enable")
+ )
+
+ @property
+ def off_peak_charging_start(self) -> str | None:
+ """Returns Off-Peak charging start time."""
+ if self._capability.off_peak_charging:
+ return (
+ self.off_peak_charging_config.get("startTime")
+ if self.off_peak_charging_config and len(self.off_peak_charging_config)
+ else "22:00"
+ )
+
+ @property
+ def off_peak_charging_end(self) -> str | None:
+ """Returns Off-Peak charging end time."""
+ if self._capability.off_peak_charging:
+ return (
+ self.off_peak_charging_config.get("endTime")
+ if self.off_peak_charging_config and len(self.off_peak_charging_config)
+ else "08:00"
+ )
+
+ @property
+ def auto_water_refilling_enabled(self) -> bool:
+ """Returns true when auto water refilling is enabled."""
+ return bool(self._get_property(DreameVacuumProperty.AUTO_WATER_REFILLING) == 1)
+
+ @property
+ def water_tank_draining_available(self) -> bool:
+ """Returns true when water tank draining is possible."""
+ return bool(
+ self._capability.drainage
+ and self.auto_water_refilling_enabled
+ and not self.self_repairing
+ and not self.draining
+ # and self.docked
+ and not self.drying
+ and not self.washing
+ and not self.washing_paused
+ and not self.started
+ )
+
+ @property
+ def floor_direction_cleaning_available(self) -> bool:
+ """Returns true when water tank draining is possible."""
+ return bool(
+ self._capability.floor_direction_cleaning
+ and not self.started
+ and not self.has_temporary_map
+ and not self.fast_mapping
+ and self.segments
+ and len([k for k, v in self.segments.items() if v.floor_material_direction is not None])
+ )
+
+ @property
+ def ai_obstacle_detection(self) -> bool:
+ return self._device.get_ai_property(DreameVacuumAIProperty.AI_OBSTACLE_DETECTION)
+
+ @property
+ def ai_obstacle_image_upload(self) -> bool:
+ return self._device.get_ai_property(DreameVacuumAIProperty.AI_OBSTACLE_IMAGE_UPLOAD)
+
+ @property
+ def ai_pet_detection(self) -> bool:
+ return self._device.get_ai_property(DreameVacuumAIProperty.AI_PET_DETECTION)
+
+ @property
+ def ai_furniture_detection(self) -> bool:
+ return self._device.get_ai_property(DreameVacuumAIProperty.AI_FURNITURE_DETECTION)
+
+ @property
+ def ai_fluid_detection(self) -> bool:
+ return self._device.get_ai_property(DreameVacuumAIProperty.AI_FLUID_DETECTION)
+
+ @property
+ def ai_obstacle_picture(self) -> bool:
+ return self._device.get_ai_property(DreameVacuumAIProperty.AI_OBSTACLE_PICTURE)
+
+ @property
+ def fill_light(self) -> bool:
+ return self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.FILL_LIGHT)
+
+ @property
+ def hot_washing(self) -> bool:
+ if self._capability.water_temperature:
+ return self.hot_water_status.value == 1
+ return (
+ self._capability.hot_washing
+ and self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.HOT_WASHING) == 1
+ )
+
+ @property
+ def auto_drying(self) -> bool:
+ if self._device.capability.self_wash_base:
+ if not self._device.capability.auto_switch_settings:
+ return bool(self._get_property(DreameVacuumProperty.INTELLIGENT_RECOGNITION))
+ return bool(self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.AUTO_DRYING) == 1)
+ return False
+
+ @property
+ def smart_drying(self) -> bool:
+ return bool(
+ self._device.capability.smart_drying
+ and self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.SMART_DRYING) == 1
+ )
+
+ @property
+ def silent_drying(self) -> bool:
+ return bool(
+ self._device.capability.silent_drying
+ and self._device.get_property(DreameVacuumProperty.SILENT_DRYING) == 1
+ )
+
+ @property
+ def stain_avoidance(self) -> bool:
+ return bool(self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.STAIN_AVOIDANCE) == 2)
+
+ @property
+ def pet_focused_cleaning(self) -> bool:
+ return self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.PET_FOCUSED_CLEANING)
+
+ @property
+ def auto_change_mop(self) -> bool:
+ return (
+ self._capability.auto_change_mop and self._device.get_property(DreameVacuumProperty.AUTO_CHANGE_MOP) == 1
+ )
+
+ @property
+ def self_clean_by_time(self) -> bool:
+ return (
+ self.self_clean_value
+ and self._capability.self_clean_frequency
+ and self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY)
+ == DreameVacuumSelfCleanFrequency.BY_TIME.value
+ )
+
+ @property
+ def self_clean_intelligent(self) -> bool:
+ return (
+ self._capability.self_clean_frequency
+ and self._device.get_auto_switch_property(DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY)
+ == DreameVacuumSelfCleanFrequency.INTELLIGENT.value
+ )
+
+ @property
+ def map_backup_status(self) -> int | None:
+ value = self._get_property(DreameVacuumProperty.MAP_BACKUP_STATUS)
+ if value == 1:
+ return 2
+ return value
+
+ @property
+ def map_backup_status_name(self) -> str:
+ """Return map backup status as string for translation."""
+ return MAP_BACKUP_STATUS_TO_NAME.get(self.map_backup_status, STATE_UNKNOWN)
+
+ @property
+ def map_recovery_status(self) -> int | None:
+ value = self._get_property(DreameVacuumProperty.MAP_RECOVERY_STATUS)
+ if value == 1:
+ return 2
+ return value
+
+ @property
+ def map_recovery_status_name(self) -> str:
+ """Return map recovery status as string for translation."""
+ return MAP_RECOVERY_STATUS_TO_NAME.get(self.map_recovery_status, STATE_UNKNOWN)
@property
- def washing_paused(self) -> bool:
- """Returns true when mop washing paused."""
- return bool(
- self.self_wash_base_available and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.PAUSED
- )
+ def clean_water_tank_status(self) -> DreameVacuumCleanWaterTankStatus:
+ """Return clean water tank status of the device."""
+ value = self._get_property(DreameVacuumProperty.CLEAN_WATER_TANK_STATUS)
+ if value is not None and value in DreameVacuumCleanWaterTankStatus._value2member_map_:
+ if value == DreameVacuumCleanWaterTankStatus.CHECKING.value:
+ value = DreameVacuumCleanWaterTankStatus.INSTALLED.value
+ return DreameVacuumCleanWaterTankStatus(value)
+ if value is not None:
+ _LOGGER.debug("CLEAN_WATER_TANK_STATUS not supported: %s", value)
+ return DreameVacuumCleanWaterTankStatus.UNKNOWN
@property
- def returning_to_wash(self) -> bool:
- """Returns true when the device returning to self-wash base to wash or dry its mop."""
- return bool(
- self.self_wash_base_available
- and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.RETURNING
- and (self.state == DreameVacuumState.RETURNING or self.state == DreameVacuumState.RETURNING_WASHING)
- )
+ def clean_water_tank_status_name(self) -> str:
+ """Return clean water tank status as string for translation."""
+ return CLEAN_WATER_TANK_STATUS_TO_NAME.get(self.clean_water_tank_status, STATE_UNKNOWN)
@property
- def returning_to_wash_paused(self) -> bool:
- """Returns true when the device returning to self-wash base to wash or dry its mop."""
- return bool(
- self.self_wash_base_available
- and self.self_wash_base_status is DreameVacuumSelfWashBaseStatus.RETURNING
- and self.state == DreameVacuumState.PAUSED
- )
+ def dirty_water_tank_status(self) -> DreameVacuumDirtyWaterTankStatus:
+ """Return dirty water tank status of the device."""
+ value = self._get_property(DreameVacuumProperty.DIRTY_WATER_TANK_STATUS)
+ if value is not None and value in DreameVacuumDirtyWaterTankStatus._value2member_map_:
+ return DreameVacuumDirtyWaterTankStatus(value)
+ if value is not None:
+ _LOGGER.debug("DIRTY_WATER_TANK_STATUS not supported: %s", value)
+ return DreameVacuumDirtyWaterTankStatus.UNKNOWN
@property
- def washing_available(self) -> bool:
- """Returns true when device has a self-wash base and washing mop can be performed."""
- return bool(
- self.self_wash_base_available
- and self.water_tank_or_mop_installed
- and not (
- self.washing
- or self.washing_paused
- or self.returning_to_wash_paused
- or self.returning_to_wash
- or self.returning
- or self.returning_paused
- or self.cleaning_paused
- )
- )
+ def dirty_water_tank_status_name(self) -> str:
+ """Return dirty water tank status as string for translation."""
+ return DIRTY_WATER_TANK_STATUS_TO_NAME.get(self.dirty_water_tank_status, STATE_UNKNOWN)
@property
- def drying_available(self) -> bool:
- """Returns true when device has a self-wash base and drying mop can be performed."""
- return bool(
- self.self_wash_base_available
- and self.water_tank_or_mop_installed
- and self.docked
- and not (self.washing or self.washing_paused)
- )
+ def dust_bag_status(self) -> DreameVacuumDustBagStatus:
+ """Return dust bag status of the device."""
+ value = self._get_property(DreameVacuumProperty.DUST_BAG_STATUS)
+ if value is not None and value in DreameVacuumDustBagStatus._value2member_map_:
+ return DreameVacuumDustBagStatus(value)
+ if value is not None:
+ _LOGGER.debug("DUST_BAG_STATUS not supported: %s", value)
+ return DreameVacuumDustBagStatus.UNKNOWN
@property
- def mapping_available(self) -> bool:
- """Returns true when creating a new map is possible."""
- return bool(
- not self.started
- and not self.fast_mapping
- and (not self.map_available or ((3 if self.multi_map else 1) > len(self.map_list)))
- )
+ def dust_bag_status_name(self) -> str:
+ """Return dust bag status as string for translation."""
+ return DUST_BAG_STATUS_TO_NAME.get(self.dust_bag_status, STATE_UNKNOWN)
@property
- def main_brush_life(self) -> int:
- """Returns main brush remaining life in percent."""
- return self._get_property(DreameVacuumProperty.MAIN_BRUSH_LEFT)
+ def auto_lds_coverage(self) -> DreameVacuumAutoLDSCoverage:
+ if self._capability.auto_lds_lifting:
+ value = self._device.get_property(DreameVacuumProperty.AUTO_LDS_COVERAGE)
+ if value is not None and value in DreameVacuumAutoLDSCoverage._value2member_map_:
+ return DreameVacuumAutoLDSCoverage(value)
+ if value is not None:
+ _LOGGER.debug("AUTO_LDS_COVERAGE not supported: %s", value)
+ return DreameVacuumAutoLDSCoverage.UNKNOWN
@property
- def side_brush_life(self) -> int:
- """Returns side brush remaining life in percent."""
- return self._get_property(DreameVacuumProperty.SIDE_BRUSH_LEFT)
+ def auto_lds_coverage_name(self) -> str:
+ """Return Auto LDS coverage as string for translation."""
+ auto_lds_coverage = self.auto_lds_coverage
+ if auto_lds_coverage in DreameVacuumAutoLDSCoverage._value2member_map_:
+ return AUTO_LDS_COVERAGE_TO_NAME.get(DreameVacuumAutoLDSCoverage(auto_lds_coverage), STATE_UNKNOWN)
+ return STATE_UNKNOWN
@property
- def filter_life(self) -> int:
- """Returns filter remaining life in percent."""
- return self._get_property(DreameVacuumProperty.FILTER_LEFT)
+ def detergent_status(self) -> DreameVacuumDetergentStatus:
+ """Return detergent status of the device."""
+ value = self._get_property(DreameVacuumProperty.DETERGENT_STATUS)
+ if value is not None and value in DreameVacuumDetergentStatus._value2member_map_:
+ return DreameVacuumDetergentStatus(value)
+ if value is not None:
+ _LOGGER.debug("DETERGENT_STATUS not supported: %s", value)
+ return DreameVacuumDetergentStatus.UNKNOWN
@property
- def sensor_dirty_life(self) -> int:
- """Returns sensor clean remaining life in percent."""
- return self._get_property(DreameVacuumProperty.SENSOR_DIRTY_LEFT)
+ def detergent_status_name(self) -> str:
+ """Return detergent status as string for translation."""
+ return DETERGENT_STATUS_TO_NAME.get(self.detergent_status, STATE_UNKNOWN)
@property
- def secondary_filter_life(self) -> int:
- """Returns secondary filter remaining life in percent."""
- return self._get_property(DreameVacuumProperty.SECONDARY_FILTER_LEFT)
+ def hot_water_status(self) -> DreameVacuumHotWaterStatus:
+ """Return hot water status of the device."""
+ value = self._get_property(DreameVacuumProperty.HOT_WATER_STATUS)
+ if value is not None and value in DreameVacuumHotWaterStatus._value2member_map_:
+ return DreameVacuumHotWaterStatus(value)
+ if value is not None:
+ _LOGGER.debug("HOT_WATER_STATUS not supported: %s", value)
+ return DreameVacuumHotWaterStatus.UNKNOWN
@property
- def mop_life(self) -> int:
- """Returns mop remaining life in percent."""
- return self._get_property(DreameVacuumProperty.MOP_PAD_LEFT)
+ def hot_water_status_name(self) -> str:
+ """Return hot water status as string for translation."""
+ return HOT_WATER_STATUS_TO_NAME.get(self.hot_water_status, STATE_UNKNOWN)
@property
- def silver_ion_life(self) -> int:
- """Returns silver-ion life in percent."""
- return self._get_property(DreameVacuumProperty.SILVER_ION_LEFT)
+ def station_drainage_status(self) -> DreameVacuumStationDrainageStatus:
+ """Return station drainage status of the device."""
+ value = self._get_property(DreameVacuumProperty.STATION_DRAINAGE_STATUS)
+ if value is not None and value in DreameVacuumStationDrainageStatus._value2member_map_:
+ return DreameVacuumStationDrainageStatus(value)
+ if value is not None:
+ _LOGGER.debug("STATION_DRAINAGE_STATUS not supported: %s", value)
+ return DreameVacuumStationDrainageStatus.UNKNOWN
@property
- def detergent_life(self) -> int:
- """Returns detergent life in percent."""
- return self._get_property(DreameVacuumProperty.DETERGENT_LEFT)
+ def station_drainage_status_name(self) -> str:
+ """Return station drainage status as string for translation."""
+ return STATION_DRAINAGE_STATUS_TO_NAME.get(self.station_drainage_status, STATE_UNKNOWN)
@property
- def dnd_enabled(self) -> bool:
- """Returns DND is enabled."""
- return bool(self._get_property(DreameVacuumProperty.DND))
+ def dust_bag_drying_status(self) -> DreameVacuumDustBagDryingStatus:
+ """Return dust bag drying status of the device."""
+ value = self._get_property(DreameVacuumProperty.DUST_BAG_DRYING_STATUS)
+ if value is not None and value in DreameVacuumDustBagDryingStatus._value2member_map_:
+ return DreameVacuumDustBagDryingStatus(value)
+ if value is not None:
+ _LOGGER.debug("DUST_BAG_DRYING_STATUS_STATUS not supported: %s", value)
+ return DreameVacuumDustBagDryingStatus.UNKNOWN
@property
- def dnd_start(self) -> str:
- """Returns DND start time."""
- return self._get_property(DreameVacuumProperty.DND_START)
+ def dust_bag_drying_status_name(self) -> str:
+ """Return dust bag drying status as string for translation."""
+ return DUST_BAG_DRYING_STATUS_TO_NAME.get(self.dust_bag_drying_status, STATE_UNKNOWN)
@property
- def dnd_end(self) -> str:
- """Returns DND end time."""
- return self._get_property(DreameVacuumProperty.DND_END)
+ def drying_left_time(self) -> int:
+ """Return drying left time calculated from progress."""
+ progress = self._get_property(DreameVacuumProperty.DRYING_PROGRESS)
+ if progress:
+ return int(
+ (1 - (progress / 100))
+ * (
+ int(self._capability.silent_drying_time)
+ if self.silent_drying
+ else (
+ self._drying_time
+ if self._drying_time
+ else self._get_property(DreameVacuumProperty.DRYING_TIME)
+ )
+ )
+ * 60
+ )
+ return 0
@property
def custom_order(self) -> bool:
"""Returns true when custom cleaning sequence is set."""
- segments = self.segments
+ if self._capability.cleaning_sequence_v2:
+ return True
+ if self.cleangenius_cleaning and not self._capability.cleangenius_mode:
+ return False
+ segments = self.current_segments
if segments:
for v in segments.values():
if v.order:
@@ -3167,9 +9343,9 @@ def custom_order(self) -> bool:
return False
@property
- def cleaning_sequence(self) -> list[int] | None:
- """Returns custom cleaning sequence list."""
- segments = self.segments
+ def segment_order(self) -> list[int] | None:
+ """Returns cleaning order list."""
+ segments = self.current_segments
if segments:
return (
list(
@@ -3183,15 +9359,10 @@ def cleaning_sequence(self) -> list[int] | None:
)
return [] if self.custom_order else None
- @property
- def map_available(self) -> bool:
- """Returns true when mapping feature is available."""
- return bool(self._map_manager is not None)
-
@property
def has_saved_map(self) -> bool:
"""Returns true when device has saved map and knowns its location on saved map."""
- if not self.map_available:
+ if self._map_manager is None:
return True
current_map = self.current_map
@@ -3206,7 +9377,7 @@ def has_saved_map(self) -> bool:
@property
def has_temporary_map(self) -> bool:
"""Returns true when device cannot store the newly created map and waits prompt for restoring or discarding it."""
- if not self.map_available:
+ if self._map_manager is None:
return False
current_map = self.current_map
@@ -3215,7 +9386,7 @@ def has_temporary_map(self) -> bool:
@property
def has_new_map(self) -> bool:
"""Returns true when fast mapping from empty map."""
- if not self.map_available:
+ if self._map_manager is None:
return False
current_map = self.current_map
@@ -3229,19 +9400,19 @@ def has_new_map(self) -> bool:
@property
def selected_map(self) -> MapData | None:
"""Return the selected map data"""
- if self.map_available and not self.has_temporary_map and not self.has_new_map:
+ if self._map_manager and not self.has_temporary_map and not self.has_new_map:
return self._map_manager.selected_map
@property
def current_map(self) -> MapData | None:
"""Return the current map data"""
- if self.map_available:
+ if self._map_manager:
return self._map_manager.get_map()
@property
def map_list(self) -> list[int] | None:
"""Return the saved map id list if multi floor map is enabled"""
- if self.map_available:
+ if self._map_manager:
if self.multi_map:
return self._map_manager.map_list
@@ -3253,7 +9424,7 @@ def map_list(self) -> list[int] | None:
@property
def map_data_list(self) -> dict[int, MapData] | None:
"""Return the saved map data list if multi floor map is enabled"""
- if self.map_available:
+ if self._map_manager:
if self.multi_map:
return self._map_manager.map_data_list
selected_map = self.selected_map
@@ -3262,9 +9433,17 @@ def map_data_list(self) -> dict[int, MapData] | None:
return {}
@property
- def segments(self) -> dict[int, Segment] | None:
+ def current_segments(self) -> dict[int, Segment] | None:
"""Return the segments of current map"""
current_map = self.current_map
+ if current_map and current_map.segments and not current_map.empty_map:
+ return {k: v for k, v in current_map.segments.items() if v.visibility != False}
+ return {}
+
+ @property
+ def segments(self) -> dict[int, Segment] | None:
+ """Return the segments of selected map"""
+ current_map = self.selected_map
if current_map and current_map.segments and not current_map.empty_map:
return current_map.segments
return {}
@@ -3272,11 +9451,16 @@ def segments(self) -> dict[int, Segment] | None:
@property
def current_room(self) -> Segment | None:
"""Return the segment that device is currently on"""
- if self.lidar_navigation:
+ if self._capability.lidar_navigation:
current_map = self.current_map
if current_map and current_map.segments and current_map.robot_segment and not current_map.empty_map:
return current_map.segments[current_map.robot_segment]
+ @property
+ def previous_cleaning_sequence(self):
+ if self.current_map and self.current_map.map_id in self._previous_cleaning_sequence:
+ return self._previous_cleaning_sequence[self.current_map.map_id]
+
@property
def active_segments(self) -> list[int] | None:
map_data = self.current_map
@@ -3297,13 +9481,19 @@ def active_segments(self) -> list[int] | None:
@property
def job(self) -> dict[str, Any] | None:
- attributes = {ATTR_CLEANING_MODE: self.cleaning_mode.name, ATTR_STATUS: self.status.name}
- attributes[ATTR_WATER_TANK if not self.self_wash_base_available else ATTR_MOP_PAD] = (
+ details = {
+ ATTR_STATUS: self.status.name,
+ }
+ if self._device._protocol.cloud:
+ details[ATTR_DID] = self._device._protocol.cloud.device_id
+ if self._capability.custom_cleaning_mode:
+ details[ATTR_CLEANING_MODE] = self.cleaning_mode.name
+ details[ATTR_WATER_TANK if not self._capability.self_wash_base else ATTR_MOP_PAD] = (
self.water_tank_or_mop_installed
)
- if self._device.cleanup_completed:
- attributes.update(
+ if self.cleanup_completed:
+ details.update(
{
ATTR_CLEANED_AREA: self._get_property(DreameVacuumProperty.CLEANED_AREA),
ATTR_CLEANING_TIME: self._get_property(DreameVacuumProperty.CLEANING_TIME),
@@ -3311,181 +9501,833 @@ def job(self) -> dict[str, Any] | None:
}
)
else:
- attributes[ATTR_COMPLETED] = False
+ details[ATTR_COMPLETED] = False
map_data = self.current_map
if map_data:
- if map_data.active_segments is not None:
- attributes[ATTR_ACTIVE_SEGMENTS] = map_data.active_segments
+ if map_data.active_segments:
+ details[ATTR_ACTIVE_SEGMENTS] = map_data.active_segments
elif map_data.active_areas is not None:
- attributes[ATTR_ACTIVE_AREAS] = map_data.active_areas
+ if self.go_to_zone:
+ details[ATTR_ACTIVE_CRUISE_POINTS] = {
+ 1: Coordinate(self.go_to_zone.x, self.go_to_zone.y, False, 0)
+ }
+ else:
+ details[ATTR_ACTIVE_AREAS] = map_data.active_areas
elif map_data.active_points is not None:
- attributes[ATTR_ACTIVE_POINTS] = map_data.active_points
- return attributes
+ details[ATTR_ACTIVE_POINTS] = map_data.active_points
+ elif map_data.predefined_points is not None:
+ details[ATTR_PREDEFINED_POINTS] = map_data.predefined_points
+ elif map_data.active_cruise_points is not None:
+ details[ATTR_ACTIVE_CRUISE_POINTS] = map_data.active_cruise_points
+ return details
@property
def attributes(self) -> dict[str, Any] | None:
"""Return the attributes of the device."""
properties = [
- DreameVacuumProperty.CLEANING_MODE,
- DreameVacuumProperty.TIGHT_MOPPING,
- DreameVacuumProperty.ERROR,
- DreameVacuumProperty.CLEANING_TIME,
- DreameVacuumProperty.CLEANED_AREA,
- DreameVacuumProperty.VOICE_PACKET_ID,
- DreameVacuumProperty.TIMEZONE,
- DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT,
- DreameVacuumProperty.MAIN_BRUSH_LEFT,
- DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT,
- DreameVacuumProperty.SIDE_BRUSH_LEFT,
- DreameVacuumProperty.FILTER_LEFT,
- DreameVacuumProperty.FILTER_TIME_LEFT,
- DreameVacuumProperty.SENSOR_DIRTY_LEFT,
- DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT,
- DreameVacuumProperty.SECONDARY_FILTER_LEFT,
- DreameVacuumProperty.SECONDARY_FILTER_TIME_LEFT,
- DreameVacuumProperty.MOP_PAD_LEFT,
- DreameVacuumProperty.MOP_PAD_TIME_LEFT,
- DreameVacuumProperty.SILVER_ION_LEFT,
- DreameVacuumProperty.SILVER_ION_TIME_LEFT,
- DreameVacuumProperty.DETERGENT_LEFT,
- DreameVacuumProperty.DETERGENT_TIME_LEFT,
- DreameVacuumProperty.TOTAL_CLEANED_AREA,
- DreameVacuumProperty.TOTAL_CLEANING_TIME,
- DreameVacuumProperty.CLEANING_COUNT,
- DreameVacuumProperty.DND_START,
- DreameVacuumProperty.DND_END,
- DreameVacuumProperty.CUSTOMIZED_CLEANING,
- DreameVacuumProperty.SERIAL_NUMBER,
+ (DreameVacuumProperty.STATUS, False),
+ (DreameVacuumProperty.CLEANING_MODE, False),
+ (DreameVacuumProperty.SUCTION_LEVEL, False),
+ (DreameVacuumProperty.TIGHT_MOPPING, True),
+ (DreameVacuumProperty.ERROR, False),
+ (DreameVacuumProperty.LOW_WATER_WARNING, False),
+ (DreameVacuumProperty.CLEANING_TIME, False),
+ (DreameVacuumProperty.CLEANED_AREA, False),
+ (DreameVacuumProperty.VOICE_PACKET_ID, False),
+ (DreameVacuumProperty.TIMEZONE, False),
+ (DreameVacuumProperty.MAIN_BRUSH_TIME_LEFT, False),
+ (DreameVacuumProperty.MAIN_BRUSH_LEFT, False),
+ (DreameVacuumProperty.SIDE_BRUSH_TIME_LEFT, False),
+ (DreameVacuumProperty.SIDE_BRUSH_LEFT, False),
+ (DreameVacuumProperty.FILTER_LEFT, False),
+ (DreameVacuumProperty.FILTER_TIME_LEFT, False),
+ (DreameVacuumProperty.TANK_FILTER_LEFT, False),
+ (DreameVacuumProperty.TANK_FILTER_TIME_LEFT, False),
+ (DreameVacuumProperty.SILVER_ION_LEFT, False),
+ (DreameVacuumProperty.SILVER_ION_TIME_LEFT, False),
+ (DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_LEFT, False),
+ (DreameVacuumProperty.DIRTY_WATER_CHANNEL_DIRTY_TIME_LEFT, False),
+ (DreameVacuumProperty.TOTAL_CLEANED_AREA, False),
+ (DreameVacuumProperty.TOTAL_CLEANING_TIME, False),
+ (DreameVacuumProperty.CLEANING_COUNT, False),
+ (DreameVacuumProperty.CUSTOMIZED_CLEANING, True),
+ (DreameVacuumProperty.NATION_MATCHED, False),
+ (DreameVacuumProperty.TOTAL_RUNTIME, False),
+ (DreameVacuumProperty.TOTAL_CRUISE_TIME, False),
+ (DreameVacuumProperty.CLEANING_PROGRESS, False),
+ (DreameVacuumProperty.INTELLIGENT_RECOGNITION, True),
+ (DreameVacuumProperty.MULTI_FLOOR_MAP, True),
+ (DreameVacuumProperty.SCHEDULED_CLEAN, False),
+ (DreameVacuumProperty.VOICE_ASSISTANT, True),
+ (DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE, False),
+ (DreameVacuumProperty.AUTO_DUST_COLLECTING, False),
+ (DreameVacuumProperty.AUTO_EMPTY_STATUS, False),
+ (DreameVacuumProperty.SELF_CLEAN, True),
+ (DreameVacuumProperty.OBSTACLE_AVOIDANCE, True),
+ (DreameVacuumProperty.VOLUME, False),
+ (DreameVacuumProperty.CHILD_LOCK, True),
+ (DreameVacuumProperty.RESUME_CLEANING, True),
+ (DreameVacuumProperty.MAP_SAVING, True),
+ (DreameVacuumProperty.CARPET_BOOST, True),
+ (DreameVacuumProperty.SCHEDULE, False),
+ (DreameVacuumProperty.MAP_RECOVERY_STATUS, False),
+ (DreameVacuumProperty.AUTO_WATER_REFILLING, True),
+ (DreameVacuumProperty.BATTERY_CHARGE_LEVEL, False),
+ (DreameVacuumProperty.RING_LIGHT_ALWAYS_ON, True),
]
+ if self._capability.deodorizer:
+ properties.append((DreameVacuumProperty.DEODORIZER_LEFT, False))
+ properties.append((DreameVacuumProperty.DEODORIZER_TIME_LEFT, False))
+
+ if self._capability.wheel:
+ properties.append((DreameVacuumProperty.WHEEL_DIRTY_LEFT, False))
+ properties.append((DreameVacuumProperty.WHEEL_DIRTY_TIME_LEFT, False))
+
+ if self._capability.onboard_dirty_water_tank:
+ properties.append((DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_LEFT, False))
+ properties.append((DreameVacuumProperty.ONBOARD_DIRTY_WATER_TANK_TIME_LEFT, False))
+
+ if self._capability.scale_inhibitor:
+ properties.append((DreameVacuumProperty.SCALE_INHIBITOR_LEFT, False))
+ properties.append((DreameVacuumProperty.SCALE_INHIBITOR_TIME_LEFT, False))
+
+ if self._capability.fluffing_roller:
+ properties.append((DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_LEFT, False))
+ properties.append((DreameVacuumProperty.FLUFFING_ROLLER_DIRTY_TIME_LEFT, False))
+
+ if self._capability.roller_mop_filter:
+ properties.append((DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_LEFT, False))
+ properties.append((DreameVacuumProperty.ROLLER_MOP_FILTER_DIRTY_TIME_LEFT, False))
+
+ if self._capability.water_outlet_filter:
+ properties.append((DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_LEFT, False))
+ properties.append((DreameVacuumProperty.WATER_OUTLET_FILTER_DIRTY_TIME_LEFT, False))
+
+ if self._capability.squeegee:
+ properties.append((DreameVacuumProperty.SQUEEGEE_LEFT, False))
+ properties.append((DreameVacuumProperty.SQUEEGEE_TIME_LEFT, False))
+
+ if not self._capability.disable_mop_consumable:
+ properties.append((DreameVacuumProperty.MOP_PAD_LEFT, False))
+ properties.append((DreameVacuumProperty.MOP_PAD_TIME_LEFT, False))
+
+ if self._capability.detergent:
+ properties.append((DreameVacuumProperty.DETERGENT_LEFT, False))
+ properties.append((DreameVacuumProperty.DETERGENT_TIME_LEFT, False))
+
+ if self._capability.backup_map:
+ properties.append((DreameVacuumProperty.MAP_BACKUP_STATUS, False))
+
+ if not self._capability.disable_sensor_cleaning:
+ properties.extend(
+ [
+ (DreameVacuumProperty.SENSOR_DIRTY_LEFT, False),
+ (DreameVacuumProperty.SENSOR_DIRTY_TIME_LEFT, False),
+ ]
+ )
+
+ if not self._capability.dnd_task:
+ properties.extend(
+ [
+ (DreameVacuumProperty.DND_START, False),
+ (DreameVacuumProperty.DND_END, False),
+ ]
+ )
+
+ if self._capability.carpet_recognition:
+ properties.append((DreameVacuumProperty.CARPET_RECOGNITION, False))
+ else:
+ properties.append((DreameVacuumProperty.CARPET_SENSITIVITY, False))
+
+ if (
+ self._capability.mop_pad_unmounting
+ or self._capability.auto_carpet_cleaning
+ or self._capability.mop_pad_lifting_plus
+ ):
+ properties.append((DreameVacuumProperty.CARPET_CLEANING, False))
+
+ if not self._capability.auto_empty_mode:
+ properties.append((DreameVacuumProperty.AUTO_EMPTY_FREQUENCY, False))
+
+ if self._capability.mop_pad_unmounting:
+ properties.append((DreameVacuumProperty.AUTO_MOUNT_MOP, True))
+
+ if self._capability.auto_add_detergent:
+ properties.append((DreameVacuumProperty.AUTO_ADD_DETERGENT, False))
+
+ if self._capability.clean_carpets_first:
+ properties.append((DreameVacuumProperty.CLEAN_CARPETS_FIRST, True))
+
+ if self._capability.auto_empty_base:
+ properties.append((DreameVacuumProperty.DUST_BAG_STATUS, False))
+
+ if self._capability.self_wash_base:
+ properties.append((DreameVacuumProperty.DRYING_TIME, False))
+ properties.append((DreameVacuumProperty.DRYING_PROGRESS, False))
+ properties.append((DreameVacuumProperty.DETERGENT_STATUS, False))
+
+ if self._capability.drainage:
+ properties.append((DreameVacuumProperty.STATION_DRAINAGE_STATUS, False))
+
+ if self._capability.hot_washing:
+ properties.append((DreameVacuumProperty.HOT_WATER_STATUS, False))
+
attributes = {}
- if not self.self_wash_base_available:
- attributes[ATTR_WATER_TANK] = self.water_tank_or_mop_installed
- properties.append(DreameVacuumProperty.WATER_VOLUME)
+
+ customized = (
+ not self.zone_cleaning
+ and not self.spot_cleaning
+ and (self.cleangenius_cleaning or (self.customized_cleaning and self.has_saved_map))
+ )
+ if not self._capability.self_wash_base:
+ if not self._capability.embedded_tank:
+ attributes[ATTR_WATER_TANK] = self.water_tank_or_mop_installed
+ properties.append((DreameVacuumProperty.WATER_VOLUME, False))
else:
attributes[ATTR_MOP_PAD] = self.water_tank_or_mop_installed
- if self.started and (self.customized_cleaning and not (self.zone_cleaning or self.spot_cleaning)):
- attributes[ATTR_MOP_PAD_HUMIDITY] = STATE_UNAVAILABLE.capitalize()
- attributes[f"{ATTR_MOP_PAD_HUMIDITY}_list"] = []
+ attributes[ATTR_MOP_PAD_HUMIDITY] = self.mop_pad_humidity_name.replace("_", " ").capitalize()
+ attributes[f"{ATTR_MOP_PAD_HUMIDITY}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.mop_pad_humidity_list.keys()]
+ if PROPERTY_AVAILABILITY["mop_pad_humidity"](self._device) or customized
+ else []
+ )
+ properties.extend(
+ [
+ (DreameVacuumProperty.CLEAN_WATER_TANK_STATUS, False),
+ (DreameVacuumProperty.DIRTY_WATER_TANK_STATUS, False),
+ ]
+ )
+
+ if self._capability.mop_clean_frequency:
+ attributes[ATTR_MOP_CLEAN_FREQUENCY] = self.self_clean_value
+ else:
+ if self.self_clean_value is not None:
+ attributes[ATTR_SELF_CLEAN_TIME if self.self_clean_by_time else ATTR_SELF_CLEAN_AREA] = (
+ self.self_clean_value
+ )
+ attributes[ATTR_SELF_CLEAN_AREA_MIN] = self.self_clean_area_min
+ attributes[ATTR_SELF_CLEAN_AREA_MAX] = self.self_clean_area_max
+ attributes[ATTR_PREVIOUS_SELF_CLEAN_AREA] = self.previous_self_clean_area
+ if self._capability.self_clean_frequency:
+ attributes[ATTR_SELF_CLEAN_TIME_MIN] = self.self_clean_time_min
+ attributes[ATTR_SELF_CLEAN_TIME_MAX] = self.self_clean_time_max
+ attributes[ATTR_PREVIOUS_SELF_CLEAN_TIME] = self.previous_self_clean_time
+
+ if not self._capability.smart_mop_washing:
+ if self._capability.ultra_clean_mode:
+ properties.append((DreameVacuumAutoSwitchProperty.ULTRA_CLEAN_MODE, True))
+
+ properties.append((DreameVacuumProperty.MOP_WASH_LEVEL, False))
else:
- attributes[ATTR_MOP_PAD_HUMIDITY] = self.mop_pad_humidity_name.replace("_", " ").capitalize()
- attributes[f"{ATTR_MOP_PAD_HUMIDITY}_list"] = [
- v.replace("_", " ").capitalize() for v in self.mop_pad_humidity_list.keys()
+ properties.append((DreameVacuumProperty.SMART_MOP_WASHING, True))
+
+ attributes[ATTR_WASHING_MODE] = self.washing_mode_name.replace("_", " ").capitalize()
+ attributes[f"{ATTR_WASHING_MODE}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.washing_mode_list.keys()]
+ if PROPERTY_AVAILABILITY["washing_mode"](self._device)
+ else []
+ )
+
+ if self._capability.mopping_with_detergent:
+ properties.append((DreameVacuumProperty.MOPPING_WITH_DETERGENT, True))
+
+ if self._capability.auto_switch_settings:
+ properties.extend(
+ [
+ (DreameVacuumAutoSwitchProperty.MOPPING_MODE, False),
+ (DreameVacuumAutoSwitchProperty.AUTO_DRYING, True),
+ (DreameVacuumAutoSwitchProperty.COLLISION_AVOIDANCE, True),
+ (DreameVacuumAutoSwitchProperty.FILL_LIGHT, True),
+ (DreameVacuumAutoSwitchProperty.STREAMING_VOICE_PROMPT, True),
+ ]
+ )
+
+ if self._capability.camera_streaming:
+ properties.extend(
+ [
+ (DreameVacuumAIProperty.AI_OBSTACLE_DETECTION, True),
+ (DreameVacuumAIProperty.AI_PET_DETECTION, True),
+ (DreameVacuumAIProperty.AI_OBSTACLE_PICTURE, True),
+ (DreameVacuumAIProperty.AI_OBSTACLE_IMAGE_UPLOAD, True),
+ (DreameVacuumAIProperty.PET_FOCUSED_DETECTION, True),
+ ]
+ )
+
+ if self._capability.large_particles_boost:
+ properties.append((DreameVacuumAIProperty.LARGE_PARTICLES_BOOST, True))
+
+ if self._capability.self_wash_base and self._capability.hot_washing and not self._capability.smart_mop_washing:
+ properties.append((DreameVacuumAutoSwitchProperty.HOT_WASHING, True))
+
+ if self._capability.max_suction_power:
+ properties.append((DreameVacuumAutoSwitchProperty.MAX_SUCTION_POWER, True))
+
+ if self._capability.uv_sterilization:
+ properties.append((DreameVacuumAutoSwitchProperty.UV_STERILIZATION, True))
+
+ if self._capability.custom_cleaning_mode:
+ properties.append((DreameVacuumAutoSwitchProperty.CUSTOM_MOPPING_MODE, False))
+
+ if self._capability.cleaning_route:
+ properties.append((DreameVacuumAutoSwitchProperty.CLEANING_ROUTE, False))
+
+ if self._capability.cleangenius:
+ properties.append((DreameVacuumAutoSwitchProperty.CLEANGENIUS, False))
+
+ if self._capability.cleangenius_mode:
+ properties.append((DreameVacuumProperty.CLEANGENIUS_MODE, False))
+
+ if self._capability.water_temperature:
+ properties.append((DreameVacuumProperty.WATER_TEMPERATURE, False))
+
+ if self._capability.silent_drying:
+ properties.append((DreameVacuumProperty.SILENT_DRYING, True))
+
+ if self._capability.hair_compression:
+ properties.append((DreameVacuumProperty.HAIR_COMPRESSION, True))
+
+ if self._capability.side_brush_carpet_rotate:
+ properties.append((DreameVacuumProperty.SIDE_BRUSH_CARPET_ROTATE, True))
+
+ if self._capability.lift_chassis_on_carpet:
+ properties.append((DreameVacuumProperty.LIFT_CHASSIS_ON_CARPET, True))
+
+ if self._capability.roller_cover:
+ properties.append((DreameVacuumProperty.CLOSE_ROLLER_COVER_ON_CARPET, True))
+
+ if self._capability.auto_lds_lifting:
+ properties.append((DreameVacuumProperty.LDS_STATE, True))
+ properties.append((DreameVacuumProperty.AUTO_LDS_COVERAGE, False))
+
+ if self._capability.mop_pressure:
+ properties.append((DreameVacuumProperty.MOP_PRESSURE, False))
+
+ if self._capability.mop_temperature:
+ properties.append((DreameVacuumProperty.MOP_TEMPERATURE, False))
+
+ if self._capability.obstacle_crossing:
+ properties.append((DreameVacuumProperty.OBSTACLE_CROSSING, False))
+
+ if self._capability.dust_bag_drying or self._capability.manual_dust_bag_drying:
+ properties.append((DreameVacuumProperty.DUST_BAG_DRYING_STATUS, False))
+ properties.append((DreameVacuumProperty.DUST_BAG_DRYING_LEFT, False))
+
+ if self._device.capability.dnd_functions:
+ properties.extend(
+ [
+ (DreameVacuumProperty.DND_DISABLE_RESUME_CLEANING, True),
+ (DreameVacuumProperty.DND_DISABLE_AUTO_EMPTY, True),
+ (DreameVacuumProperty.DND_REDUCE_VOLUME, True),
]
+ )
+
+ if (
+ self._capability.self_wash_base
+ and not self._capability.custom_mopping_route
+ and not self._capability.cleaning_route
+ ):
+ properties.append((DreameVacuumAutoSwitchProperty.MOPPING_TYPE, False))
+
+ if self._capability.self_wash_base and self._capability.self_clean_frequency:
+ properties.append((DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY, False))
+
+ if self._capability.floor_direction_cleaning:
+ properties.append((DreameVacuumAutoSwitchProperty.FLOOR_DIRECTION_CLEANING, True))
+
+ if self._capability.intensive_carpet_cleaning:
+ properties.append((DreameVacuumAutoSwitchProperty.INTENSIVE_CARPET_CLEANING, True))
+
+ if self._capability.mop_extend:
+ properties.append((DreameVacuumAutoSwitchProperty.MOP_EXTEND, True))
+ properties.append((DreameVacuumAutoSwitchProperty.MOP_EXTEND_FREQUENCY, False))
+ elif self._capability.mop_pad_swing:
+ properties.append((DreameVacuumAutoSwitchProperty.MOP_PAD_SWING, False))
+
+ if self._capability.mop_pad_swing_plus:
+ properties.append((DreameVacuumAutoSwitchProperty.GAP_CLEANING_EXTENSION, True))
+ properties.append((DreameVacuumAutoSwitchProperty.MOPPING_UNDER_FURNITURES, True))
+
+ if self._capability.auto_recleaning:
+ properties.append((DreameVacuumAutoSwitchProperty.AUTO_RECLEANING, False))
+
+ if self._capability.auto_rewashing:
+ properties.append((DreameVacuumAutoSwitchProperty.AUTO_REWASHING, False))
+
+ if not self._capability.mop_pad_swing and not self._capability.mop_clean_frequency:
+ properties.append((DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE, False))
+
+ if self._capability.self_wash_base:
+ properties.append((DreameVacuumProperty.SELF_CLEAN, True))
+
+ if self._capability.dust_bag_drying:
+ properties.append((DreameVacuumProperty.DUST_BAG_DRYING, True))
+
+ if self._capability.active_suspension:
+ properties.append((DreameVacuumProperty.ACTIVE_SUSPENSION_CROSSING, True))
+
+ if self._capability.auto_change_mop:
+ properties.append((DreameVacuumProperty.AUTO_CHANGE_MOP, True))
+
+ if self._capability.dynamic_obstacle_cleaning:
+ properties.append((DreameVacuumProperty.DYNAMIC_OBSTACLE_CLEANING, True))
+
+ if self._capability.pressurized_cleaning:
+ properties.append((DreameVacuumProperty.PRESSURIZED_CLEANING, True))
+
+ if self._capability.low_lying_area_frequency:
+ properties.append((DreameVacuumProperty.LOW_LYING_AREA_FREQUENCY, False))
+
+ if self._capability.scraper_frequency:
+ properties.append((DreameVacuumProperty.SCRAPER_FREQUENCY, False))
+
+ if self._capability.battery_charge_level:
+ properties.append((DreameVacuumProperty.BATTERY_CHARGE_LEVEL, False))
+
+ if self._capability.auto_empty_area:
+ properties.append((DreameVacuumProperty.AUTO_EMPTY_AREA, False))
for prop in properties:
- value = self._get_property(prop)
+ property = prop[0]
+ value = self._get_property(property)
if value is not None:
- prop_name = PROPERTY_TO_NAME.get(prop)
+ prop_name = PROPERTY_TO_NAME.get(property.name)
if prop_name:
prop_name = prop_name[0]
else:
- prop_name = prop.name.lower()
+ prop_name = property.name.lower()
- if prop is DreameVacuumProperty.ERROR:
+ if prop[1] == True:
+ value = bool(value > 0)
+ elif property is DreameVacuumProperty.ERROR:
value = self.error_name.replace("_", " ").capitalize()
- elif prop is DreameVacuumProperty.WATER_VOLUME:
- if self.started and (self.customized_cleaning and not (self.zone_cleaning or self.spot_cleaning)):
- value = STATE_UNAVAILABLE.capitalize()
- attributes[f"{prop_name}_list"] = []
- else:
- value = self.water_volume_name.capitalize()
- attributes[f"{prop_name}_list"] = [v.capitalize() for v in self.water_volume_list.keys()]
- elif prop is DreameVacuumProperty.CLEANING_MODE:
+ elif property is DreameVacuumProperty.LOW_WATER_WARNING:
+ value = self.low_water_warning_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.STATUS:
+ value = self.status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.AUTO_EMPTY_STATUS:
+ value = self.auto_empty_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.MAP_RECOVERY_STATUS:
+ value = self.map_recovery_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.MAP_BACKUP_STATUS:
+ value = self.map_backup_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.CLEAN_WATER_TANK_STATUS:
+ value = self.clean_water_tank_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.DIRTY_WATER_TANK_STATUS:
+ value = self.dirty_water_tank_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.DUST_BAG_STATUS:
+ value = self.dust_bag_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.DETERGENT_STATUS:
+ value = self.detergent_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.STATION_DRAINAGE_STATUS:
+ value = self.station_drainage_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.HOT_WATER_STATUS:
+ value = self.hot_water_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.DUST_BAG_DRYING_STATUS:
+ value = self.dust_bag_drying_status_name.replace("_", " ").capitalize()
+ elif property is DreameVacuumProperty.WATER_VOLUME:
+ value = self.water_volume_name.capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.capitalize() for v in self.water_volume_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device) or customized
+ else []
+ )
+ elif property is DreameVacuumProperty.SUCTION_LEVEL:
+ value = self.suction_level_name.capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.capitalize() for v in self.suction_level_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device) or customized
+ else []
+ )
+ elif property is DreameVacuumProperty.CLEANING_MODE:
value = self.cleaning_mode_name.replace("_", " ").capitalize()
- elif prop is DreameVacuumProperty.CUSTOMIZED_CLEANING:
- value = self.customized_cleaning and not self.zone_cleaning and not self.spot_cleaning
- elif prop is DreameVacuumProperty.TIGHT_MOPPING:
- value = "on" if value == 1 else "off"
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.cleaning_mode_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device) or customized
+ else []
+ )
+ elif property is DreameVacuumProperty.MOP_WASH_LEVEL:
+ value = self.mop_wash_level_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.mop_wash_level_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.VOICE_ASSISTANT_LANGUAGE:
+ if not self._capability.voice_assistant:
+ continue
+ value = self.voice_assistant_language_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = [
+ v.replace("_", " ").capitalize() for v in self.voice_assistant_language_list.keys()
+ ]
+ elif property is DreameVacuumProperty.CLEANGENIUS_MODE:
+ value = self.cleangenius_mode_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.cleangenius_mode_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.WATER_TEMPERATURE:
+ value = self.water_temperature_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.water_temperature_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.CLEANING_ROUTE:
+ value = self.cleaning_route_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.cleaning_route_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device) or customized
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.CLEANGENIUS:
+ value = self.cleangenius_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.cleangenius_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.MOPPING_TYPE:
+ value = self.mopping_type_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.mopping_type_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.WIDER_CORNER_COVERAGE:
+ value = self.wider_corner_coverage_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.wider_corner_coverage_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.CARPET_CLEANING:
+ value = self.carpet_cleaning_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.carpet_cleaning_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.CARPET_SENSITIVITY:
+ value = self.carpet_sensitivity_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.carpet_sensitivity_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.MOP_PAD_SWING:
+ value = self.mop_pad_swing_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.mop_pad_swing_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.MOP_EXTEND_FREQUENCY:
+ value = self.mop_extend_frequency_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.mop_extend_frequency_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.AUTO_REWASHING:
+ value = self.auto_rewashing_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.second_cleaning_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumAutoSwitchProperty.AUTO_RECLEANING:
+ value = self.auto_recleaning_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.second_cleaning_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.MOP_PRESSURE:
+ if not self._capability.mop_pressure:
+ continue
+ value = self.mop_pressure_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = [
+ v.replace("_", " ").capitalize() for v in self.mop_pressure_list.keys()
+ ]
+ elif property is DreameVacuumProperty.MOP_TEMPERATURE:
+ if not self._capability.mop_temperature:
+ continue
+ value = self.mop_temperature_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = [
+ v.replace("_", " ").capitalize() for v in self.mop_temperature_list.keys()
+ ]
+ elif property is DreameVacuumProperty.LOW_LYING_AREA_FREQUENCY:
+ if not self._capability.low_lying_area_frequency:
+ continue
+ value = self.low_lying_area_frequency_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = [
+ v.replace("_", " ").capitalize() for v in self.low_lying_area_frequency_list.keys()
+ ]
+ elif property is DreameVacuumProperty.SCRAPER_FREQUENCY:
+ if not self._capability.scraper_frequency:
+ continue
+ value = self.scraper_frequency_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = [
+ v.replace("_", " ").capitalize() for v in self.scraper_frequency_list.keys()
+ ]
+ elif property is DreameVacuumProperty.AUTO_LDS_COVERAGE:
+ value = self.auto_lds_coverage_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.auto_lds_coverage_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.CUSTOMIZED_CLEANING:
+ value = bool(value and not self.zone_cleaning and not self.spot_cleaning and self.has_saved_map)
+ elif property is DreameVacuumProperty.SCHEDULED_CLEAN:
+ value = bool(value == 1 or value == 2 or value == 4)
+ elif property is DreameVacuumProperty.AUTO_DUST_COLLECTING:
+ if self._capability.auto_empty_mode:
+ attributes[ATTR_AUTO_EMPTY_MODE] = self.auto_empty_mode_name.replace("_", " ").capitalize()
+ attributes[f"{ATTR_AUTO_EMPTY_MODE}_list"] = [
+ v.replace("_", " ").capitalize() for v in self.auto_empty_mode_list.keys()
+ ]
+ value = bool(value > 0)
+ elif property is DreameVacuumAutoSwitchProperty.SELF_CLEAN_FREQUENCY:
+ value = self.self_clean_frequency_name.replace("_", " ").capitalize()
+ attributes[f"{prop_name}_list"] = (
+ [v.replace("_", " ").capitalize() for v in self.self_clean_frequency_list.keys()]
+ if PROPERTY_AVAILABILITY[property.name](self._device)
+ else []
+ )
+ elif property is DreameVacuumProperty.DRYING_TIME and not self._capability.mop_clean_frequency:
+ attributes[f"{prop_name}_list"] = list(self.drying_time_list.values())
+ elif property is DreameVacuumProperty.SCHEDULE:
+ value = self.schedule
attributes[prop_name] = value
- attributes[ATTR_CLEANING_SEQUENCE] = self.cleaning_sequence
- attributes[ATTR_CHARGING] = self.docked
+ if self._capability.dnd_task:
+ attributes[ATTR_DND] = self.dnd_tasks if self.dnd_tasks else []
+ else:
+ attributes[ATTR_DND] = self.dnd
+
+ if self._capability.off_peak_charging:
+ attributes[ATTR_OFF_PEAK_CHARGING] = self.off_peak_charging
+ attributes[ATTR_OFF_PEAK_CHARGING_START] = self.off_peak_charging_start
+ attributes[ATTR_OFF_PEAK_CHARGING_END] = self.off_peak_charging_end
+
+ if self._capability.shortcuts:
+ attributes[ATTR_SHORTCUTS] = (
+ {str(k): v.as_dict() for k, v in self.shortcuts.items() if v is not None}
+ if self.shortcuts is not None
+ else {}
+ )
+
+ attributes[ATTR_BATTERY] = self.battery_level
+ attributes[ATTR_CLEANING_SEQUENCE] = self.segment_order
+ attributes[ATTR_CHARGING] = self.charging
+ attributes[ATTR_DOCKED] = self.docked
+ attributes[ATTR_LOCATED] = self.located
attributes[ATTR_STARTED] = self.started
attributes[ATTR_PAUSED] = self.paused
attributes[ATTR_RUNNING] = self.running
attributes[ATTR_RETURNING_PAUSED] = self.returning_paused
attributes[ATTR_RETURNING] = self.returning
- attributes[ATTR_MAPPING] = self.fast_mapping
+ attributes[ATTR_SEGMENT_CLEANING] = self.segment_cleaning
+ attributes[ATTR_ZONE_CLEANING] = self.zone_cleaning
+ attributes[ATTR_SPOT_CLEANING] = self.spot_cleaning
+ attributes[ATTR_CRUSING] = self.cruising
+ attributes[ATTR_VACUUM_STATE] = self.state_name.lower()
+ attributes[ATTR_HAS_SAVED_MAP] = self._map_manager is not None and self.has_saved_map
+ attributes[ATTR_HAS_TEMPORARY_MAP] = self.has_temporary_map
+
+ if self._capability.lidar_navigation:
+ attributes[ATTR_MAPPING] = self.fast_mapping
+ attributes[ATTR_MAPPING_AVAILABLE] = self.mapping_available
+ if self._capability.auto_empty_base:
+ attributes[ATTR_DUST_COLLECTION_AVAILABLE] = self.dust_collection_available
+
+ if self._capability.self_wash_base:
+ attributes[ATTR_WASHING] = self.washing
+ attributes[ATTR_WASHING_PAUSED] = self.washing
+ attributes[ATTR_DRYING] = self.drying
+ if not self.auto_water_refilling_enabled:
+ attributes[ATTR_LOW_WATER] = bool(self.low_water_warning)
+ else:
+ attributes[ATTR_DRAINING] = self.draining
+ attributes[ATTR_WASHING_AVAILABLE] = bool(
+ (self.washing_available or self.washing or self.returning_to_wash_paused or self.washing_paused)
+ and not self.draining
+ and not self.self_repairing
+ )
+ attributes[ATTR_DRYING_AVAILABLE] = self.drying_available
+ attributes[ATTR_DRAINING_AVAILABLE] = (
+ self.water_tank_draining_available or self.water_tank_emptying_available
+ )
+ if self._capability.dust_bag_drying or self._capability.manual_dust_bag_drying:
+ attributes[ATTR_DRYING_LEFT] = self.drying_left_time
+
+ if self._capability.dust_bag_drying or self._capability.manual_dust_bag_drying:
+ attributes[ATTR_DUST_BAG_DRYING_AVAILABLE] = self.dust_bag_drying_available
+
+ if self._capability.cleangenius:
+ attributes[ATTR_CLEANGENIUS] = bool(
+ self.cleangenius_cleaning and not self.zone_cleaning and not self.spot_cleaning
+ )
+
+ if self._capability.wetness_level:
+ attributes[ATTR_WETNESS_LEVEL] = self.wetness_level
if self.map_list:
attributes[ATTR_ACTIVE_SEGMENTS] = self.active_segments
- if self.lidar_navigation:
- attributes[ATTR_CURRENT_SEGMENT] = self.current_room.segment_id if self.current_room else 0
+ if self._capability.lidar_navigation:
+ attributes[ATTR_CURRENT_SEGMENT] = self.current_room.id if self.current_room else 0
attributes[ATTR_SELECTED_MAP] = self.selected_map.map_name if self.selected_map else None
+ attributes[ATTR_SELECTED_MAP_ID] = self.selected_map.map_id if self.selected_map else None
+ attributes[ATTR_SELECTED_MAP_INDEX] = self.current_map.map_index if self.current_map else None
attributes[ATTR_ROOMS] = {}
- for k, v in self.map_data_list.items():
+ attributes[ATTR_MAPS] = []
+ for v in self.map_data_list.values():
attributes[ATTR_ROOMS][v.map_name] = [
- {ATTR_ID: j, ATTR_NAME: s.name, ATTR_ICON: s.icon} for (j, s) in sorted(v.segments.items())
+ {ATTR_ID: j, ATTR_NAME: s.name, ATTR_ICON: s.icon, ATTR_TYPE: s.type}
+ for (j, s) in sorted(v.segments.items())
+ if s.visibility != False
]
+ attributes[ATTR_MAPS].append(
+ {
+ ATTR_ID: v.map_id,
+ ATTR_DATE: (
+ datetime.fromtimestamp(int(v.last_updated))
+ if v.last_updated
+ else datetime.fromtimestamp(v.timestamp_ms) if v.timestamp_ms else datetime.now()
+ ),
+ ATTR_INDEX: v.map_index,
+ ATTR_NAME: v.map_name,
+ ATTR_CUSTOM_NAME: v.custom_name,
+ ATTR_RECOVERY_MAP: (
+ [
+ f"{time.strftime('%x %X', time.localtime(item.date.timestamp()))}: Map{index + 1} ({item.map_type.name.title()})"
+ for index, item in enumerate(v.recovery_map_list)
+ ]
+ if v.recovery_map_list
+ else None
+ ),
+ }
+ )
+
+ if self._capability.carpet_recognition:
+ attributes[ATTR_CARPET_AVOIDANCE] = self.carpet_avoidance
+
+ if self._capability.floor_direction_cleaning:
+ attributes[ATTR_FLOOR_DIRECTION_CLEANING_AVAILABLE] = self.floor_direction_cleaning_available
+ if self._capability.shortcuts:
+ attributes[ATTR_SHORTCUT_TASK] = self.shortcut_task
+ attributes[ATTR_FIRMWARE_VERSION] = str(self._device.info.version)
+ attributes[ATTR_AP] = self._device.info.ap
+ attributes[ATTR_CAPABILITIES] = self._capability.list
return attributes
+ def consumable_life_warning_description(self, consumable_property) -> str:
+ description = CONSUMABLE_TO_LIFE_WARNING_DESCRIPTION.get(consumable_property)
+ if description:
+ value = self._get_property(consumable_property)
+ if value is not None and value >= 0 and value <= 5:
+ if value != 0 and len(description) > 1:
+ return description[1]
+ return description[0]
+
+ def segment_order_list(self, segment) -> list[int] | None:
+ order = []
+ if self.current_segments:
+ order = [
+ v.order
+ for k, v in sorted(
+ self.current_segments.items(),
+ key=lambda s: s[1].order if s[1].order != None else 0,
+ )
+ if v.order
+ ]
+ if not segment.order and len(order):
+ order = order + [max(order) + 1]
+ return list(map(str, order))
+
class DreameVacuumDeviceInfo:
"""Container of device information."""
def __init__(self, data):
self.data = data
+ self.version = 0
+ firmware_version = self.firmware_version
+ if firmware_version is not None:
+ firmware_version = firmware_version.split("_")
+ if len(firmware_version) == 2:
+ self.version = int(firmware_version[1])
def __repr__(self):
return "%s v%s (%s) @ %s - token: %s" % (
- self.data["model"],
- self.data["fw_ver"],
- self.data["mac"],
- self.network_interface["localIp"],
- self.data["token"],
+ self.model,
+ self.version,
+ self.mac,
+ self.network_interface["localIp"] if self.network_interface else "",
)
@property
def network_interface(self) -> str:
"""Information about network configuration."""
- return self.data["netif"]
+ if "netif" in self.data:
+ return self.data["netif"]
+ return None
@property
- def accesspoint(self) -> str:
- """Information about connected WLAN access point."""
- return self.data["ap"]
+ def ap(self) -> str:
+ """Information about wifi configuration."""
+ if "ap" in self.data:
+ ap = self.data["ap"]
+ return {
+ "ssid": ap.get("ssid", ap.get("siid")),
+ "bssid": ap.get("bssid"),
+ "rssi": ap.get("rssi"),
+ "ip": self.ip_address,
+ }
+ return None
@property
def model(self) -> Optional[str]:
"""Model string if available."""
- if self.data["model"] is not None:
+ if "model" in self.data:
return self.data["model"]
return None
@property
def firmware_version(self) -> Optional[str]:
"""Firmware version if available."""
- if self.data["fw_ver"] is not None:
+ if "fw_ver" in self.data and self.data["fw_ver"] is not None:
return self.data["fw_ver"]
- return None
-
- @property
- def version(self) -> Optional[int]:
- """Firmware version number if firmware version available."""
- firmware_version = self.firmware_version
- if firmware_version is not None:
- firmware_version = firmware_version.split("_")
- if len(firmware_version) == 2:
- return int(firmware_version[1])
+ if "ver" in self.data and self.data["ver"] is not None:
+ return self.data["ver"]
return None
@property
def hardware_version(self) -> Optional[str]:
"""Hardware version if available."""
- if self.data["hw_ver"] is not None:
+ if "hw_ver" in self.data:
return self.data["hw_ver"]
- return None
+ return "Linux"
@property
def mac_address(self) -> Optional[str]:
"""MAC address if available."""
- if self.data["mac"] is not None:
+ if "mac" in self.data:
return self.data["mac"]
return None
+ @property
+ def ip_address(self) -> Optional[str]:
+ """IP address if available."""
+ if self.network_interface:
+ return self.network_interface.get("localIp")
+ return None
+
@property
def manufacturer(self) -> str:
"""Manufacturer name."""
diff --git a/custom_components/dreame_vacuum/dreame/map.py b/custom_components/dreame_vacuum/dreame/map.py
index f57f25cc..73f62182 100644
--- a/custom_components/dreame_vacuum/dreame/map.py
+++ b/custom_components/dreame_vacuum/dreame/map.py
@@ -4,17 +4,28 @@
import time
import base64
import json
-import re
import zlib
+import re
import logging
import traceback
import copy
import numpy as np
import hashlib
+import textwrap
from py_mini_racer import MiniRacer
from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.asymmetric import rsa, padding as asym_padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-from PIL import Image, ImageDraw, ImageOps, ImageFont, ImageEnhance, PngImagePlugin, ImageFilter
+from cryptography.hazmat.primitives import padding, serialization, hashes
+from PIL import (
+ Image,
+ ImageDraw,
+ ImageOps,
+ ImageFont,
+ ImageEnhance,
+ PngImagePlugin,
+ ImageFilter,
+)
from typing import Any
from time import sleep
from io import BytesIO
@@ -30,10 +41,16 @@
DreameVacuumProperty,
DreameVacuumAction,
DreameVacuumActionMapping,
+ DreameVacuumDeviceCapability,
+ RobotType,
+ CleansetType,
ObstacleType,
+ Obstacle,
+ FurnitureType,
+ Furniture,
PathType,
Point,
- Obstacle,
+ Coordinate,
MapDataPartial,
MapData,
MapFrameType,
@@ -41,13 +58,29 @@
Path,
Area,
Wall,
+ Carpet,
+ Polygon,
Segment,
+ StartupMethod,
+ CleanupMethod,
+ TaskEndType,
+ RecoveryMapType,
+ ObstacleIgnoreStatus,
+ SegmentSkipReason,
MapImageDimensions,
MapRendererLayer,
MapRendererColorScheme,
MapRendererConfig,
+ MapRendererData,
+ MapRendererResources,
+ RecoveryMapInfo,
+ DreameVacuumFloorMaterial,
+ DreameVacuumFloorMaterialDirection,
MAP_COLOR_SCHEME_LIST,
- MAP_ICON_SET_LIST,
+ SEGMENT_TYPE_CODE_TO_NAME,
+ FURNITURE_TYPE_TO_DIMENSIONS,
+ FURNITURE_V2_TYPE_TO_DIMENSIONS,
+ FURNITURE_V2_TYPE_MIJIA_TO_DIMENSIONS,
ALine,
CLine,
Paths,
@@ -64,16 +97,8 @@
MAP_PARAMETER_MAPSTR,
MAP_PARAMETER_CURR_ID,
MAP_PARAMETER_VACUUM,
- MAP_PARAMETER_ID,
- MAP_PARAMETER_INFO,
- MAP_PARAMETER_FIRST,
- MAP_PARAMETER_OBJNAME,
- MAP_PARAMETER_RESULT,
- MAP_PARAMETER_URL,
MAP_PARAMETER_EXPIRES_TIME,
- MAP_PARAMETER_THB,
- MAP_PARAMETER_OBJECT_NAME,
- MAP_PARAMETER_MD5,
+ MAP_PARAMETER_URL,
MAP_REQUEST_PARAMETER_MAP_ID,
MAP_REQUEST_PARAMETER_FRAME_ID,
MAP_REQUEST_PARAMETER_FRAME_TYPE,
@@ -82,39 +107,40 @@
MAP_REQUEST_PARAMETER_TYPE,
MAP_REQUEST_PARAMETER_INDEX,
MAP_REQUEST_PARAMETER_ROOM_ID,
- MAP_DATA_PARAMETER_CLASS,
- MAP_DATA_PARAMETER_SIZE,
- MAP_DATA_PARAMETER_X,
- MAP_DATA_PARAMETER_Y,
- MAP_DATA_PARAMETER_PIXEL_SIZE,
- MAP_DATA_PARAMETER_LAYERS,
- MAP_DATA_PARAMETER_ENTITIES,
- MAP_DATA_PARAMETER_META_DATA,
- MAP_DATA_PARAMETER_VERSION,
- MAP_DATA_PARAMETER_ROTATION,
- MAP_DATA_PARAMETER_TYPE,
- MAP_DATA_PARAMETER_POINTS,
- MAP_DATA_PARAMETER_PIXELS,
- MAP_DATA_PARAMETER_SEGMENT_ID,
- MAP_DATA_PARAMETER_ACTIVE,
- MAP_DATA_PARAMETER_NAME,
- MAP_DATA_PARAMETER_DIMENSIONS,
- MAP_DATA_PARAMETER_MIN,
- MAP_DATA_PARAMETER_MAX,
- MAP_DATA_PARAMETER_MID,
- MAP_DATA_PARAMETER_AVG,
- MAP_DATA_PARAMETER_PIXEL_COUNT,
- MAP_DATA_PARAMETER_COMPRESSED_PIXELS,
- MAP_DATA_PARAMETER_ROBOT_POSITION,
- MAP_DATA_PARAMETER_CHARGER_POSITION,
- MAP_DATA_PARAMETER_NO_MOP_AREA,
- MAP_DATA_PARAMETER_NO_GO_AREA,
- MAP_DATA_PARAMETER_ACTIVE_ZONE,
- MAP_DATA_PARAMETER_VIRTUAL_WALL,
- MAP_DATA_PARAMETER_PATH,
- MAP_DATA_PARAMETER_FLOOR,
- MAP_DATA_PARAMETER_WALL,
- MAP_DATA_PARAMETER_SEGMENT,
+ MAP_DATA_JSON_CLASS,
+ MAP_DATA_JSON_PARAMETER_CLASS,
+ MAP_DATA_JSON_PARAMETER_SIZE,
+ MAP_DATA_JSON_PARAMETER_X,
+ MAP_DATA_JSON_PARAMETER_Y,
+ MAP_DATA_JSON_PARAMETER_PIXEL_SIZE,
+ MAP_DATA_JSON_PARAMETER_LAYERS,
+ MAP_DATA_JSON_PARAMETER_ENTITIES,
+ MAP_DATA_JSON_PARAMETER_META_DATA,
+ MAP_DATA_JSON_PARAMETER_VERSION,
+ MAP_DATA_JSON_PARAMETER_ROTATION,
+ MAP_DATA_JSON_PARAMETER_TYPE,
+ MAP_DATA_JSON_PARAMETER_POINTS,
+ MAP_DATA_JSON_PARAMETER_PIXELS,
+ MAP_DATA_JSON_PARAMETER_SEGMENT_ID,
+ MAP_DATA_JSON_PARAMETER_ACTIVE,
+ MAP_DATA_JSON_PARAMETER_NAME,
+ MAP_DATA_JSON_PARAMETER_DIMENSIONS,
+ MAP_DATA_JSON_PARAMETER_MIN,
+ MAP_DATA_JSON_PARAMETER_MAX,
+ MAP_DATA_JSON_PARAMETER_MID,
+ MAP_DATA_JSON_PARAMETER_AVG,
+ MAP_DATA_JSON_PARAMETER_PIXEL_COUNT,
+ MAP_DATA_JSON_PARAMETER_COMPRESSED_PIXELS,
+ MAP_DATA_JSON_PARAMETER_ROBOT_POSITION,
+ MAP_DATA_JSON_PARAMETER_CHARGER_POSITION,
+ MAP_DATA_JSON_PARAMETER_NO_MOP_AREA,
+ MAP_DATA_JSON_PARAMETER_NO_GO_AREA,
+ MAP_DATA_JSON_PARAMETER_ACTIVE_ZONE,
+ MAP_DATA_JSON_PARAMETER_VIRTUAL_WALL,
+ MAP_DATA_JSON_PARAMETER_PATH,
+ MAP_DATA_JSON_PARAMETER_FLOOR,
+ MAP_DATA_JSON_PARAMETER_WALL,
+ MAP_DATA_JSON_PARAMETER_SEGMENT,
)
_LOGGER = logging.getLogger(__name__)
@@ -126,6 +152,7 @@ def __init__(self, _protocol: DreameVacuumProtocol) -> None:
self._map_list_md5: str = None
self._recovery_map_list_object_name: str = None
self._update_callback = None
+ self._change_callback = None
self._error_callback = None
self._update_timer: Timer = None
self._update_running: bool = False
@@ -133,6 +160,7 @@ def __init__(self, _protocol: DreameVacuumProtocol) -> None:
self._device_running: bool = False
self._device_docked: bool = False
self._available: bool = False
+ self._disconnected: bool = False
self._ready: bool = False
self._connected: bool = True
self._vslam_map: bool = False
@@ -151,8 +179,8 @@ def _init_data(self) -> None:
self._file_urls: dict[str, str] = {}
self._saved_map_data: dict[int, MapData] = {}
self._map_list: list[int] = []
- self._recovery_map_data: dict[int, MapData] = {}
self._need_map_request: bool = False
+ self._need_new_map: bool = False
self._need_map_list_request: bool = None
self._need_recovery_map_list_request: bool = None
self._map_data_queue: dict[int, MapData] = {}
@@ -171,8 +199,13 @@ def _init_data(self) -> None:
self._map_request_count: int = 0
self._new_map_request_time: int = None
self._aes_iv: str = None
+ self._aes_key: str = None
+ self._capability: DreameVacuumDeviceCapability = None
def _request_map_from_cloud(self) -> bool:
+ if self._protocol.cloud.dreame_cloud:
+ return True
+
if self._current_timestamp_ms is not None:
start_time = self._current_timestamp_ms
request_start_time = int(math.floor(start_time / 1000.0))
@@ -205,80 +238,43 @@ def _request_map_from_cloud(self) -> bool:
self._map_data_changed()
if map_data_result is None:
- _LOGGER.warn("Getting map_data from cloud failed")
+ _LOGGER.warning("Getting map_data from cloud failed")
map_data_result = []
object_name_result = self._protocol.cloud.get_device_property(
DIID(DreameVacuumProperty.OBJECT_NAME), 1, self._latest_object_name_time
)
if object_name_result is None:
- _LOGGER.warn("Getting object_name from cloud failed")
- object_name_result = []
-
- next_frame_id = 1
+ _LOGGER.warning("Getting object_name from cloud failed")
+ partial_map_data = None
if len(map_data_result):
+ partial_map_data = []
self._latest_map_data_time = map_data_result[0][MAP_PARAMETER_TIME] + 1
- if len(object_name_result):
- self._latest_object_name_time = object_name_result[0][MAP_PARAMETER_TIME] + 1
-
- for data in map_data_result:
- value = json.loads(data[MAP_PARAMETER_VALUE])
- pmap = value[0]
- timestamp = None
- if data.get(MAP_PARAMETER_TIME):
- timestamp = data[MAP_PARAMETER_TIME] * 1000
-
- partial_map = self._decode_map_partial(pmap, timestamp)
-
- if partial_map:
- if partial_map.frame_type == MapFrameType.I.value:
- self._add_map_data(partial_map)
- else:
- self._queue_partial_map(partial_map)
-
- if self._current_frame_id:
- next_frame_id = self._current_frame_id + 1
+ for data in map_data_result:
+ partial_map_data.append(
+ self._decode_map_partial(
+ json.loads(data[MAP_PARAMETER_VALUE if MAP_PARAMETER_VALUE in data else "val"])[0],
+ data[MAP_PARAMETER_TIME] * 1000 if data.get(MAP_PARAMETER_TIME) else None,
+ )
+ )
- partial_map = self._unqueue_partial_map(self._latest_map_id, next_frame_id)
- if partial_map:
- self._add_map_data(partial_map)
- else:
- if len(object_name_result) == 0:
- self._delete_invalid_partial_maps()
- tmpLen = self._partial_map_queue_size()
- if tmpLen > 8:
- self.request_new_map()
- elif tmpLen > 4:
- self._request_missing_p_map()
- elif tmpLen > 0 and len(map_data_result) > 0:
- self._request_next_p_map(self._latest_map_id, next_frame_id)
+ object_name = None
+ object_name_timestamp = None
+ if object_name_result:
+ data = object_name_result[0]
+ if MAP_PARAMETER_TIME in data:
+ timestamp = data[MAP_PARAMETER_TIME]
+ self._latest_object_name_time = timestamp + 1
- if len(object_name_result) == 1:
- object_name = json.loads(object_name_result[0][MAP_PARAMETER_VALUE])
- if object_name:
- _LOGGER.info("New object name received: %s", object_name[0])
- timestamp = None
- if object_name_result[0].get(MAP_PARAMETER_TIME):
- timestamp = object_name_result[0][MAP_PARAMETER_TIME] * 1000
- response, key = self._get_object_file_data(object_name[0], timestamp)
- if response:
- partial_map = self._decode_map_partial(response.decode(), timestamp, key)
- if partial_map:
- if self._map_data is None or partial_map.frame_type == MapFrameType.I.value:
- return self._add_map_data(partial_map)
-
- self._queue_partial_map(partial_map)
- next_partial_map = self._unqueue_next_partial_map()
- if next_partial_map:
- self._add_map_data(next_partial_map)
- else:
- self._delete_invalid_partial_maps()
- if self._partial_map_queue_size() > 8:
- self.request_new_map()
+ if len(object_name_result) == 1:
+ object_name = json.loads(data[MAP_PARAMETER_VALUE if MAP_PARAMETER_VALUE in data else "val"])[0]
+ if timestamp:
+ object_name_timestamp = timestamp * 1000
- return len(map_data_result) or len(object_name_result)
+ self._add_cloud_map_data(partial_map_data, object_name, object_name_timestamp)
+ return len(map_data_result) or object_name is not None
def _request_map(self, parameters: dict[str, Any] = None) -> dict[str, Any] | None:
if parameters is None:
@@ -302,7 +298,7 @@ def _request_map(self, parameters: dict[str, Any] = None) -> dict[str, Any] | No
return None
def _request_i_map(self, start_time: int = None) -> bool:
- if not self._request_i_map_available:
+ if not self._request_i_map_available and not self._protocol.dreame_cloud:
return self.request_new_map()
parameters = {
@@ -315,7 +311,7 @@ def _request_i_map(self, start_time: int = None) -> bool:
parameters[MAP_PARAMETER_TIME] = start_time
result = self._request_map(parameters)
- if result and result[MAP_PARAMETER_CODE] == 0:
+ if result and MAP_PARAMETER_CODE in result and result[MAP_PARAMETER_CODE] == 0:
out = result[MAP_PARAMETER_OUT]
_LOGGER.info("Response from device %s", out)
has_map = False
@@ -352,9 +348,11 @@ def _request_i_map(self, start_time: int = None) -> bool:
if object_name:
self._add_map_data_file(object_name, self._last_robot_time)
+ return True
if raw_map_data:
self._add_raw_map_data(raw_map_data, self._last_robot_time)
- return True
+ return True
+ return False
self._request_map_from_cloud()
return False
@@ -381,6 +379,7 @@ def _request_missing_p_map(self) -> bool:
self._last_p_request_frame_id = frame_id
self._last_p_request_time = time.time()
+ _LOGGER.info("Request missing P map: %s", frame_id)
result = self._request_map(
{
MAP_REQUEST_PARAMETER_MAP_ID: map_id,
@@ -396,7 +395,7 @@ def _request_next_p_map(self, map_id: int, frame_id: int) -> bool:
return
self._request_queue[key] = True
-
+ _LOGGER.info("Request next P map: %s", frame_id)
result = self._request_map(
{
MAP_REQUEST_PARAMETER_MAP_ID: map_id,
@@ -407,7 +406,6 @@ def _request_next_p_map(self, map_id: int, frame_id: int) -> bool:
)
if result and result[MAP_PARAMETER_CODE] == 0:
del self._request_queue[key]
-
object_name = None
raw_map_data = None
timestamp = None
@@ -440,17 +438,31 @@ def _request_t_map(self) -> None:
if result and result[MAP_PARAMETER_CODE] == 0:
self.request_map_list()
+ def _request_w_map(self) -> None:
+ try:
+ _LOGGER.info("Request wifi map from device")
+ mapping = DreameVacuumActionMapping[DreameVacuumAction.WIFI_MAP]
+ return self._protocol.action(mapping["siid"], mapping["aiid"], None, 0)
+ except Exception as ex:
+ _LOGGER.warning("Send request map failed: %s", ex)
+ return None
+
def _request_current_map(self, map_request_time: int = None) -> bool:
- if self._request_i_map_available:
+ if self._request_i_map_available or self._protocol.dreame_cloud:
return self._request_i_map(map_request_time)
return self._request_map_from_cloud()
- def _map_data_changed(self) -> None:
- if self._ready and self._update_callback:
+ def _map_data_updated(self) -> None:
+ if self._update_callback:
_LOGGER.debug("Update callback")
self._update_callback()
+ def _map_data_changed(self, saved_map=False) -> None:
+ if self._change_callback:
+ _LOGGER.debug("Change callback")
+ self._change_callback(saved_map)
+
def _update_task(self) -> None:
if self._update_timer is not None:
self._update_timer.cancel()
@@ -550,10 +562,18 @@ def _get_interim_file_data(self, object_name: str = "", timestamp=None) -> str |
if self._protocol.cloud.logged_in:
if object_name is None or object_name == "":
_LOGGER.info("Get object name from cloud")
- object_name_result = self._protocol.cloud.get_device_property(DIID(DreameVacuumProperty.OBJECT_NAME))
- if object_name_result:
- object_name_result = json.loads(object_name_result[0][MAP_PARAMETER_VALUE])
- object_name = object_name_result[0]
+ if self._protocol.cloud.dreame_cloud:
+ object_name_result = self._protocol.cloud.get_properties(DIID(DreameVacuumProperty.OBJECT_NAME))
+ if object_name_result:
+ object_name_result = object_name_result[0][MAP_PARAMETER_VALUE]
+ object_name = object_name_result[0]
+ else:
+ object_name_result = self._protocol.cloud.get_device_property(
+ DIID(DreameVacuumProperty.OBJECT_NAME)
+ )
+ if object_name_result:
+ object_name_result = json.loads(object_name_result[0][MAP_PARAMETER_VALUE])
+ object_name = object_name_result[0]
if object_name is None or object_name == "":
object_name = self._protocol.cloud.object_name
@@ -605,6 +625,56 @@ def _decode_map_partial(self, raw_map, timestamp=None, key=None) -> MapDataParti
return partial_map
+ def _add_cloud_map_data(self, partial_map_data, object_name, object_name_timestamp):
+ if partial_map_data:
+ for partial_map in partial_map_data:
+ if partial_map.frame_type == MapFrameType.I.value:
+ self._add_map_data(partial_map)
+ else:
+ self._queue_partial_map(partial_map)
+
+ next_frame_id = 1
+ if self._current_frame_id:
+ next_frame_id = self._current_frame_id + 1
+
+ if (
+ not self._add_map_data(self._unqueue_partial_map(self._latest_map_id, next_frame_id))
+ and object_name is None
+ ):
+ self._delete_invalid_partial_maps()
+ tmpLen = self._partial_map_queue_size()
+ if tmpLen > 8:
+ if self._protocol.dreame_cloud:
+ self._request_map()
+ else:
+ self.request_new_map()
+ elif tmpLen > 4:
+ self._request_missing_p_map()
+ elif tmpLen > 0 and partial_map_data:
+ self._request_next_p_map(self._latest_map_id, next_frame_id)
+
+ if object_name is not None:
+ self._need_new_map = False
+ _LOGGER.info("New object name received: %s", object_name)
+ response, key = self._get_object_file_data(object_name, object_name_timestamp)
+ if response:
+ partial_map = self._decode_map_partial(response.decode(), object_name_timestamp, key)
+ if partial_map:
+ if self._map_data is None or partial_map.frame_type == MapFrameType.I.value:
+ return self._add_map_data(partial_map)
+
+ self._queue_partial_map(partial_map)
+ next_partial_map = self._unqueue_next_partial_map()
+ if next_partial_map:
+ self._add_map_data(next_partial_map)
+ else:
+ self._delete_invalid_partial_maps()
+ if self._partial_map_queue_size() > 8:
+ if self._protocol.dreame_cloud:
+ self._request_map()
+ else:
+ self.request_new_map()
+
def _add_map_data_file(self, object_name: str, timestamp) -> None:
response, key = self._get_object_file_data(object_name, timestamp)
if response is not None:
@@ -614,271 +684,321 @@ def _add_raw_map_data(self, raw_map: str, timestamp=None, key=None) -> bool:
return self._add_map_data(self._decode_map_partial(raw_map, timestamp, key))
def _add_map_data(self, partial_map: MapDataPartial) -> None:
- if partial_map is not None:
+ if partial_map is None:
+ return False
+
+ if (
+ partial_map.timestamp_ms is not None
+ and self._current_timestamp_ms is not None
+ and self._current_frame_id
+ and self._current_timestamp_ms > partial_map.timestamp_ms
+ ):
+ _LOGGER.info(
+ "Skip frame %s, timestamp %s:%s < %s:%s",
+ partial_map.frame_type,
+ partial_map.frame_id,
+ partial_map.timestamp_ms,
+ self._current_frame_id,
+ self._current_timestamp_ms,
+ )
+ return True
+
+ if self._current_map_id is not None and self._current_map_id != self._latest_map_id:
+ _LOGGER.info(
+ "Map ID Changed: %s -> %s",
+ self._current_map_id,
+ self._latest_map_id,
+ )
+
+ self._current_frame_id = None
+ self._current_map_id = None
+ self._updated_frame_id = None
+ # self.request_next_map_list()
+
+ if partial_map.map_id != self._latest_map_id:
+ _LOGGER.info(
+ "Skip frame, map_id %s != %s",
+ partial_map.map_id,
+ self._latest_map_id,
+ )
+ # self._add_next_map_data()
+ return True
+
+ if (
+ self._current_frame_id is not None
+ and self._current_frame_id is not None
+ and partial_map.frame_id < self._current_frame_id
+ ):
if (
- partial_map.timestamp_ms is not None
- and self._current_timestamp_ms is not None
- and self._current_timestamp_ms is not None
- and self._current_frame_id
- and self._current_timestamp_ms > partial_map.timestamp_ms
+ partial_map.frame_type != MapFrameType.I.value
+ or partial_map.timestamp_ms <= self._current_timestamp_ms
):
- _LOGGER.debug(
- "Skip frame %s, timestamp %s:%s < %s:%s",
- partial_map.frame_type,
- partial_map.frame_id,
- partial_map.timestamp_ms,
- self._current_frame_id,
- self._current_timestamp_ms,
- )
- return
-
- if self._current_map_id is not None and self._current_map_id != self._latest_map_id:
_LOGGER.info(
- "Map ID Changed: %s -> %s",
+ "Skip frame, frame id %s:%s < %s:%s",
+ partial_map.map_id,
+ partial_map.frame_id,
self._current_map_id,
- self._latest_map_id,
+ self._current_frame_id,
)
+ # self._add_next_map_data()
+ return True
+ if partial_map.frame_type == MapFrameType.P.value:
+ if self._current_frame_id is not None and self._map_data is not None and self._map_data.restored_map:
+ _LOGGER.debug("Current map data removed")
+ self._map_data = None
self._current_frame_id = None
self._current_map_id = None
- self._updated_frame_id = None
- # self.request_next_map_list()
- if partial_map.map_id != self._latest_map_id:
- _LOGGER.info(
- "Skip frame, map_id %s != %s",
- partial_map.map_id,
- self._latest_map_id,
- )
- # self._add_next_map_data()
- return
+ if self._current_frame_id is None or self._map_data is None:
+ self._queue_partial_map(partial_map)
- if (
- self._current_frame_id is not None
- and self._current_frame_id is not None
- and partial_map.frame_id < self._current_frame_id
- ):
- if (
- partial_map.frame_type != MapFrameType.I.value
- or partial_map.timestamp_ms <= self._current_timestamp_ms
- ):
- _LOGGER.info(
- "Skip frame, frame id %s:%s < %s:%s",
- partial_map.map_id,
- partial_map.frame_id,
- self._current_map_id,
- self._current_frame_id,
- )
- # self._add_next_map_data()
- return
+ if self._map_request_time is None:
+ self._request_i_map()
+ return True
- if partial_map.frame_type == MapFrameType.P.value:
- if self._current_frame_id is not None and self._map_data is not None and self._map_data.restored_map:
- _LOGGER.debug("Current map data removed")
- self._map_data = None
- self._current_frame_id = None
- self._current_map_id = None
+ if partial_map.frame_id != self._current_frame_id + 1:
+ if partial_map.frame_id <= self._current_frame_id:
+ self._add_next_map_data()
+ return True
- if self._current_frame_id is None or self._map_data is None:
- self._queue_partial_map(partial_map)
+ self._queue_partial_map(partial_map)
+ self._delete_invalid_partial_maps()
- if self._map_request_time is None:
- self._request_i_map()
- return
+ tmpLen = self._partial_map_queue_size()
+ if tmpLen > 0:
+ if self._protocol.dreame_cloud:
+ if tmpLen > 8:
+ self._request_map()
+ elif tmpLen > 4:
+ self._request_missing_p_map()
+ else:
+ next_frame_id = 1
+ if self._current_frame_id:
+ next_frame_id = self._current_frame_id + 1
+ self._request_next_p_map(self._latest_map_id, next_frame_id)
+ else:
+ self._request_next_p_map(partial_map.map_id, self._current_frame_id + 1)
+ else:
+ self._add_next_map_data()
+ return True
- if partial_map.frame_id != self._current_frame_id + 1:
- if partial_map.frame_id <= self._current_frame_id:
- self._add_next_map_data()
- return
+ current_robot_position = (
+ copy.deepcopy(self._map_data.robot_position) if self._map_data.robot_position else None
+ )
- self._queue_partial_map(partial_map)
- self._delete_invalid_partial_maps()
+ map_data = DreameVacuumMapDecoder.decode_p_map_data_from_partial(
+ partial_map,
+ self._map_data,
+ self._vslam_map,
+ )
+ if map_data:
+ if map_data.carpet_pixels and self._map_data.dimensions != map_data.dimensions:
+ map_data.carpet_pixels = DreameVacuumMapDecoder.get_carpets(map_data, self.selected_map)
- if self._partial_map_queue_size() > 0:
- self._request_next_p_map(partial_map.map_id, self._current_frame_id + 1)
- else:
- self._add_next_map_data()
- return
+ DreameVacuumMapDecoder.set_carpet_cleanset(map_data, map_data.carpet_cleanset, self._capability)
- current_robot_position = (
- copy.deepcopy(self._map_data.robot_position) if self._map_data.robot_position else None
- )
+ self._map_data = map_data
+ self._map_data.last_updated = time.time()
+ self._updated_frame_id = None
+ self._current_frame_id = map_data.frame_id
+ self._current_map_id = map_data.map_id
+ self._current_timestamp_ms = map_data.timestamp_ms
- map_data = DreameVacuumMapDecoder.decode_p_map_data_from_partial(
- partial_map,
- self._map_data,
- self._vslam_map,
- )
- if map_data:
+ _LOGGER.info("Decode P map %d %d", map_data.map_id, map_data.frame_id)
+
+ if not self._device_running or current_robot_position != map_data.robot_position:
+ self._map_data_changed()
+
+ elif partial_map.frame_type == MapFrameType.I.value:
+ self._need_map_request = False
+ self._delete_invalid_partial_maps()
+
+ (
+ map_data,
+ saved_map_data,
+ ) = DreameVacuumMapDecoder.decode_map_data_from_partial(partial_map, self._vslam_map)
+ if map_data is None:
+ self._add_next_map_data()
+ return True
+
+ if map_data.empty_map:
+ if self._map_data is None or not self._map_data.empty_map:
+ self._init_data()
self._map_data = map_data
- self._map_data.last_updated = time.time()
- self._updated_frame_id = None
self._current_frame_id = map_data.frame_id
self._current_map_id = map_data.map_id
self._current_timestamp_ms = map_data.timestamp_ms
- _LOGGER.info("Decode P map %d %d", map_data.map_id, map_data.frame_id)
-
- if not self._device_running or current_robot_position != map_data.robot_position:
- self._map_data_changed()
-
- elif partial_map.frame_type == MapFrameType.I.value:
- self._need_map_request = False
- self._delete_invalid_partial_maps()
-
- (
- map_data,
+ self._map_data_changed()
+ self._add_next_map_data()
+ return True
+
+ if saved_map_data is not None and saved_map_data.saved_map:
+ if not saved_map_data.carpet_cleanset:
+ saved_map_data.carpet_cleanset = map_data.carpet_cleanset
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ saved_map_data, saved_map_data.carpet_cleanset, self._capability
+ )
+ DreameVacuumMapDecoder.set_floor_material(saved_map_data, self._capability)
+ DreameVacuumMapDecoder.set_segment_cleanset(
saved_map_data,
- ) = DreameVacuumMapDecoder.decode_map_data_from_partial(partial_map, self._vslam_map)
- if map_data is None:
- self._add_next_map_data()
- return
-
- if map_data.empty_map:
- if self._map_data is None or not self._map_data.empty_map:
- self._init_data()
- self._map_data = map_data
- self._current_frame_id = map_data.frame_id
- self._current_map_id = map_data.map_id
- self._current_timestamp_ms = map_data.timestamp_ms
-
- self._map_data_changed()
- self._add_next_map_data()
- return
-
- if saved_map_data is not None and saved_map_data.saved_map:
- if saved_map_data.map_id in self._saved_map_data:
- map_data.temporary_map = False
- self._selected_map_id = saved_map_data.map_id
- saved_map_data.map_name = self._saved_map_data[saved_map_data.map_id].map_name
- saved_map_data.custom_name = self._saved_map_data[saved_map_data.map_id].custom_name
- saved_map_data.rotation = self._saved_map_data[saved_map_data.map_id].rotation
- saved_map_data.map_index = self._saved_map_data[saved_map_data.map_id].map_index
+ map_data.cleanset,
+ self._capability,
+ )
- saved_map_data.timestamp_ms = map_data.timestamp_ms
- if (
- saved_map_data != self._saved_map_data[saved_map_data.map_id]
- or saved_map_data.segments != self._saved_map_data[saved_map_data.map_id].segments
- ):
- saved_map_data.last_updated = time.time()
- self._saved_map_data[saved_map_data.map_id] = saved_map_data
+ if saved_map_data.map_id in self._saved_map_data:
+ map_data.temporary_map = False
+ self._selected_map_id = saved_map_data.map_id
+ saved_map_data.map_name = self._saved_map_data[saved_map_data.map_id].map_name
+ saved_map_data.custom_name = self._saved_map_data[saved_map_data.map_id].custom_name
+ saved_map_data.rotation = self._saved_map_data[saved_map_data.map_id].rotation
+ saved_map_data.map_index = self._saved_map_data[saved_map_data.map_id].map_index
+ saved_map_data.recovery_map_list = self._saved_map_data[saved_map_data.map_id].recovery_map_list
- _LOGGER.debug(
- "Decode saved map %s: %s",
- saved_map_data.map_id,
- saved_map_data.map_name,
- )
- elif not map_data.temporary_map:
- if not self._map_list:
- saved_map_data.last_updated = time.time()
- self._saved_map_data[saved_map_data.map_id] = saved_map_data
+ saved_map_data.timestamp_ms = map_data.timestamp_ms
+ if (
+ saved_map_data != self._saved_map_data[saved_map_data.map_id]
+ or saved_map_data.segments != self._saved_map_data[saved_map_data.map_id].segments
+ ):
+ saved_map_data.last_updated = time.time()
+ if saved_map_data.wifi_map_data:
+ saved_map_data.wifi_map_data.last_updated = saved_map_data.last_updated
+ self._saved_map_data[saved_map_data.map_id] = saved_map_data
+ if not self._protocol.dreame_cloud:
+ self.request_next_map_list()
- _LOGGER.info("Add saved map from new map %s", saved_map_data.map_id)
- self._refresh_map_list()
- if self._map_data:
- self._map_data_changed()
+ _LOGGER.debug(
+ "Decode saved map %s: %s",
+ saved_map_data.map_id,
+ saved_map_data.map_name,
+ )
+ elif not map_data.temporary_map:
+ if not self._map_list:
+ saved_map_data.last_updated = time.time()
+ if saved_map_data.wifi_map_data:
+ saved_map_data.wifi_map_data.last_updated = saved_map_data.last_updated
+ self._saved_map_data[saved_map_data.map_id] = saved_map_data
+
+ _LOGGER.info("Add saved map from new map %s", saved_map_data.map_id)
+ self._refresh_map_list()
+ if self._map_data:
+ self._map_data_changed()
+ if not self._protocol.dreame_cloud:
if self._device_running:
self.request_next_map_list()
else:
self.request_map_list()
- if not map_data.saved_map:
- if self._vslam_map:
- if map_data.saved_map_status == 1 and saved_map_data and self._device_docked:
- map_data.segments = copy.deepcopy(saved_map_data.segments)
- map_data.data = copy.deepcopy(saved_map_data.data)
- map_data.pixel_type = copy.deepcopy(saved_map_data.pixel_type)
- map_data.dimensions = copy.deepcopy(saved_map_data.dimensions)
- map_data.charger_position = copy.deepcopy(saved_map_data.charger_position)
- map_data.no_go_areas = saved_map_data.no_go_areas
- map_data.no_mopping_areas = saved_map_data.no_mopping_areas
- map_data.walls = saved_map_data.walls
- map_data.robot_position = None
- map_data.docked = True
- # map_data.restored_map = True
- map_data.path = None
- map_data.need_optimization = False
- map_data.saved_map_status = 2
- elif (
- map_data.robot_position is None
- and map_data.restored_map
- and not self._device_docked
- and self._map_data
- and not map_data.docked
- ):
- map_data.robot_position = self._map_data.robot_position
+ DreameVacuumMapDecoder.set_floor_material(map_data, self._capability)
+ DreameVacuumMapDecoder.set_segment_cleanset(map_data, map_data.cleanset, self._capability)
+ DreameVacuumMapDecoder.set_carpet_cleanset(map_data, map_data.carpet_cleanset, self._capability)
- changed = (
- self._current_frame_id is None
- or self._map_data is None
- or map_data != self._map_data
- or map_data.segments != self._map_data.segments
- )
+ if not map_data.saved_map:
+ if map_data.saved_map_id and map_data.saved_map_id in self._saved_map_data:
+ map_data.map_index = self._saved_map_data[map_data.saved_map_id].map_index
+ if self._vslam_map:
+ if map_data.saved_map_status == 1 and saved_map_data and self._device_docked:
+ map_data.segments = copy.deepcopy(saved_map_data.segments)
+ map_data.data = copy.deepcopy(saved_map_data.data)
+ map_data.pixel_type = copy.deepcopy(saved_map_data.pixel_type)
+ map_data.dimensions = copy.deepcopy(saved_map_data.dimensions)
+ map_data.charger_position = copy.deepcopy(saved_map_data.charger_position)
+ map_data.no_go_areas = saved_map_data.no_go_areas
+ map_data.no_mopping_areas = saved_map_data.no_mopping_areas
+ map_data.virtual_walls = saved_map_data.virtual_walls
+ map_data.robot_position = None
+ map_data.docked = True
+ # map_data.restored_map = True
+ map_data.path = None
+ map_data.need_optimization = False
+ map_data.saved_map_status = 2
+ elif (
+ map_data.robot_position is None
+ and map_data.restored_map
+ and not self._device_docked
+ and self._map_data
+ and not map_data.docked
+ ):
+ map_data.robot_position = self._map_data.robot_position
+
+ changed = (
+ self._current_frame_id is None
+ or self._map_data is None
+ or map_data != self._map_data
+ or map_data.rotation != self._map_data.rotation
+ or map_data.segments != self._map_data.segments
+ )
+
+ if (
+ changed
+ or self._current_frame_id != map_data.frame_id
+ or self._current_timestamp_ms != map_data.timestamp_ms
+ ):
if (
- changed
- or self._current_frame_id != map_data.frame_id
- or self._current_timestamp_ms != map_data.timestamp_ms
+ self._current_frame_id is not None
+ and self._map_data is not None
+ and self._updated_frame_id is not None
):
- if (
- self._current_frame_id is not None
- and self._map_data is not None
- and self._updated_frame_id is not None
- ):
- if map_data.frame_id <= self._updated_frame_id:
- if not self._map_data.empty_map and (
- self._map_data.saved_map_status == 2
- or (self._vslam_map and self._map_data.saved_map_status == 1)
- ):
- map_data.active_segments = self._map_data.active_segments
- map_data.active_areas = self._map_data.active_areas
- map_data.active_points = self._map_data.active_points
- map_data.path = self._map_data.path
- map_data.segments = self._map_data.segments
- map_data.cleanset = self._map_data.cleanset
- changed = map_data != self._map_data
- else:
- changed = False
- map_data.empty_map = True
+ if map_data.frame_id <= self._updated_frame_id + 1:
+ if not self._map_data.empty_map and (
+ self._map_data.saved_map_status == 2
+ or (self._vslam_map and self._map_data.saved_map_status == 1)
+ ):
+ map_data.active_segments = self._map_data.active_segments
+ map_data.active_areas = self._map_data.active_areas
+ map_data.active_points = self._map_data.active_points
+ map_data.active_cruise_points = self._map_data.active_cruise_points
+ map_data.path = self._map_data.path
+ map_data.segments = self._map_data.segments
+ map_data.floor_material = self._map_data.floor_material
+ map_data.hidden_segments = self._map_data.hidden_segments
+ map_data.cleanset = self._map_data.cleanset
+ map_data.carpet_cleanset = self._map_data.carpet_cleanset
+ map_data.cleaning_sequence = self._map_data.cleaning_sequence
+ map_data.mop_type = self._map_data.mop_type
+ changed = map_data != self._map_data
else:
- self._updated_frame_id = None
-
- if (
- self._map_data
- and not changed
- and map_data.need_optimization
- and not self._map_data.need_optimization
- ):
- map_data.need_optimization = False
- map_data.optimized_pixel_type = copy.deepcopy(self._map_data.optimized_pixel_type)
- map_data.optimized_dimensions = copy.deepcopy(self._map_data.optimized_dimensions)
- map_data.optimized_charger_position = copy.deepcopy(
- self._map_data.optimized_charger_position
- )
+ changed = False
+ map_data.empty_map = True
+ else:
+ self._updated_frame_id = None
- self._map_data = map_data
- self._current_frame_id = map_data.frame_id
- self._current_map_id = map_data.map_id
- self._current_timestamp_ms = map_data.timestamp_ms
+ if (
+ self._map_data
+ and not changed
+ and map_data.need_optimization
+ and not self._map_data.need_optimization
+ ):
+ map_data.need_optimization = False
+ map_data.optimized_pixel_type = copy.deepcopy(self._map_data.optimized_pixel_type)
+ map_data.optimized_dimensions = copy.deepcopy(self._map_data.optimized_dimensions)
+ map_data.optimized_charger_position = copy.deepcopy(self._map_data.optimized_charger_position)
- if changed:
- _LOGGER.info("Decode I map %d %d", map_data.map_id, map_data.frame_id)
+ self._map_data = map_data
+ self._current_frame_id = map_data.frame_id
+ self._current_map_id = map_data.map_id
+ self._current_timestamp_ms = map_data.timestamp_ms
- self._map_data.last_updated = time.time()
- self._map_data_changed()
- else:
- _LOGGER.info(
- "Decode map %d %d not changed",
- map_data.map_id,
- map_data.frame_id,
- )
+ if changed:
+ _LOGGER.info("Decode I map %d %d", map_data.map_id, map_data.frame_id)
+ self._map_data.last_updated = time.time()
+ self._map_data_changed()
+ else:
+ _LOGGER.info(
+ "Decode map %d %d not changed",
+ map_data.map_id,
+ map_data.frame_id,
+ )
- if self._current_frame_id is None and self._map_data is not None:
- self._map_data = None
- self._map_data_changed()
+ if self._current_frame_id is None and self._map_data is not None:
+ self._map_data = None
+ self._map_data_changed()
- self._add_next_map_data()
+ self._add_next_map_data()
+ return True
def _add_next_map_data(self) -> None:
next_partial_map = self._unqueue_next_partial_map()
@@ -899,6 +1019,60 @@ def _refresh_map_list(self) -> None:
index = index + 1
self._map_list = new_map_list
+ def _refresh_recovery_map_list(self) -> None:
+ index = 1
+ for map_id, saved_map_data in sorted(self._saved_map_data.items()):
+ if saved_map_data.recovery_map_list:
+ for recovery_map_data in saved_map_data.recovery_map_list:
+ map_type = recovery_map_data.map_type.name.replace("_", " ").title()
+ if saved_map_data.custom_name is None:
+ recovery_map_data.map_name = f"Recovery Map {str(index)} ({map_type})"
+ else:
+ recovery_map_data.map_name = (
+ f"{saved_map_data.custom_name} Recovery Map {str(index)} ({map_type})"
+ )
+ recovery_map_data.map_index = index
+ index = index + 1
+
+ def handle_properties(self, properties):
+ if not self._ready:
+ return
+
+ has_map = False
+ object_name = None
+ raw_map_data = None
+
+ for prop in properties:
+ value = prop[MAP_PARAMETER_VALUE]
+ if value != "":
+ piid = prop["piid"]
+ if piid == PIID(DreameVacuumProperty.OBJECT_NAME):
+ has_map = True
+ object_name = value
+ elif piid == PIID(DreameVacuumProperty.MAP_DATA):
+ has_map = True
+ raw_map_data = value
+ elif piid == PIID(DreameVacuumProperty.OLD_MAP_DATA):
+ if not has_map:
+ values = value.split(",")
+ if values[0] == "0":
+ raw_map_data = values[1]
+ else:
+ object_name = values[1]
+ if len(values) == 3:
+ object_name = f"{object_name},{values[2]}"
+
+ if has_map:
+ self._map_request_time = None
+
+ if object_name or raw_map_data:
+ partial_map_data = None
+ timestamp = int(time.time() * 1000)
+
+ if raw_map_data:
+ partial_map_data = [self._decode_map_partial(raw_map_data, timestamp)]
+ self._add_cloud_map_data(partial_map_data, object_name, timestamp)
+
def get_map(self, map_index: int = 0) -> MapData | None:
if map_index:
if map_index <= len(self._map_list):
@@ -906,70 +1080,324 @@ def get_map(self, map_index: int = 0) -> MapData | None:
return None
return self._map_data
- def listen(self, callback) -> None:
- self._update_callback = callback
-
- def listen_error(self, callback) -> None:
- self._error_callback = callback
-
- def schedule_update(self, wait: float = None) -> None:
- if not wait:
- wait = self._update_interval
- if self._update_timer is not None:
- self._update_timer.cancel()
- del self._update_timer
- self._update_timer = None
- if wait >= 0:
- self._update_timer = Timer(wait, self._update_task)
- self._update_timer.start()
-
- def update(self) -> None:
- if self._update_running:
- return
-
- self._update_running = True
+ def get_aes_key(self):
+ if self._aes_key is None:
+ private_key = rsa.generate_private_key(public_exponent=65537, key_size=1024)
+ response = self._protocol.action(
+ 14,
+ 1,
+ [
+ {
+ "piid": 5,
+ "value": base64.b64encode(
+ private_key.public_key().public_bytes(
+ encoding=serialization.Encoding.DER,
+ format=serialization.PublicFormat.SubjectPublicKeyInfo,
+ )
+ ).decode(),
+ }
+ ],
+ )
- _LOGGER.debug("Map update: %s", self._update_interval)
- try:
- if (self._map_list_object_name and self._need_map_list_request is None) or (
- self._need_map_list_request and not self._device_running
+ if not (
+ response is None or "out" not in response or not response["out"] or "value" not in response["out"][0]
):
- self.request_map_list()
-
- # Not supported Yet
- # if self._recovery_map_list_object_name and self._need_recovery_map_list_request is None or (self._need_recovery_map_list_request and not self._device_running):
- # self.request_recovery_map_list()
-
- if self._map_request_time is not None or self._need_map_request:
- self._updated_frame_id = None
+ response = response["out"][0]["value"].replace("-", "+").replace("_", "/")
+ while len(response) % 4 != 0:
+ response += "="
+
+ self._aes_key = base64.b64decode(
+ base64.b64encode(
+ serialization.load_der_private_key(
+ private_key.private_bytes(
+ encoding=serialization.Encoding.DER,
+ format=serialization.PrivateFormat.PKCS8,
+ encryption_algorithm=serialization.NoEncryption(),
+ ),
+ password=None,
+ ).decrypt(
+ base64.b64decode(response),
+ asym_padding.OAEP(
+ mgf=asym_padding.MGF1(algorithm=hashes.SHA1()),
+ algorithm=hashes.SHA1(),
+ label=None,
+ ),
+ )
+ ).decode()
+ ).decode("utf-8")
+ return self._aes_key
+
+ def get_obstacle_image(self, map_data, index):
+ index = str(index)
+ if map_data and map_data.obstacles and index in map_data.obstacles:
+ obstacle = map_data.obstacles[index]
+ if (
+ obstacle.file_name
+ and len(obstacle.file_name) > 1
+ and (obstacle.picture_status is None or obstacle.picture_status.value == 2)
+ ):
+ try:
+ if self._protocol.dreame_cloud and self._capability.local_storage:
+ _LOGGER.info(
+ "Obstacle image local file name: %s",
+ obstacle.file_name,
+ )
+ file = self._protocol.cloud.get_device_file(obstacle.file_name, "obstacle")
+ if file:
+ key = self.get_aes_key()
+ if not key:
+ _LOGGER.warning("Failed to get obstacle aes key! (%s)", obstacle.file_name)
+ return None, None
+
+ cipher = Cipher(
+ algorithms.AES(hashlib.md5(key.encode("utf-8")).hexdigest().encode("utf-8")),
+ modes.CBC(base64.b64decode(self._capability.resources_aes_iv)),
+ )
+ decryptor = cipher.decryptor()
+ unpadder = padding.PKCS7(128).unpadder()
+ return (
+ (unpadder.update(decryptor.update(file) + decryptor.finalize()) + unpadder.finalize()),
+ obstacle,
+ )
+ elif obstacle.key and len(obstacle.key) > 1:
+ object_name = (
+ f"{obstacle.file_name}-{obstacle.object_id}"
+ if self._protocol.dreame_cloud and obstacle.object_id
+ else obstacle.file_name
+ )
+ _LOGGER.info(
+ "Obstacle image object name: %s",
+ object_name,
+ )
+ response = self._get_file_url(object_name, False)
+ if response:
+ response = self._protocol.cloud.get_file(response)
+ if response:
+ response = base64.b64encode(response).decode("utf-8")
+
+ cipher = Cipher(
+ algorithms.AES(
+ bytearray.fromhex(hashlib.md5((obstacle.key).encode("utf-8")).hexdigest())
+ ),
+ modes.ECB(),
+ backend=default_backend(),
+ )
+ decryptor = cipher.decryptor()
+ unpadder = padding.PKCS7(128).unpadder()
+ return (
+ (
+ unpadder.update(
+ decryptor.update(base64.b64decode(response[response.find(",") + 1 :]))
+ + decryptor.finalize()
+ )
+ + unpadder.finalize()
+ ),
+ obstacle,
+ )
+ except:
+ _LOGGER.warning(
+ "Obstacle (%s) image decryption failed: %s",
+ index,
+ traceback.format_exc(),
+ )
+ return (None, None)
+
+ def get_history_map(self, object_name, key=None):
+ if object_name and len(object_name):
+ try:
+ _LOGGER.info(
+ "History map object name: %s",
+ object_name,
+ )
+ response = self._get_file_url(object_name, self._protocol.cloud.dreame_cloud)
+ if response:
+ response = self._protocol.cloud.get_file(response)
+ if response:
+ map_data, saved_map_data = DreameVacuumMapDecoder.decode_map(
+ response.decode(), self._vslam_map, None, self._aes_iv, key
+ )
+ if map_data:
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self._capability,
+ )
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ map_data, map_data.carpet_cleanset, self._capability
+ )
+ DreameVacuumMapDecoder.set_floor_material(map_data, self._capability)
+
+ map_data.history_map = True
+ if map_data.need_optimization:
+ map_data = self.optimizer.optimize(map_data, saved_map_data)
+ map_data.need_optimization = False
+ return map_data
+ except Exception as ex:
+ _LOGGER.warning(
+ "History map decoding failed: %s",
+ traceback.format_exc(),
+ )
+
+ def get_recovery_map(self, map_id, index):
+ if map_id in self._map_list:
+ recovery_map_list = self._saved_map_data[map_id].recovery_map_list
+ index = int(index) - 1
+ if recovery_map_list and len(recovery_map_list) > index:
+ if recovery_map_list[index].map_data is None:
+ if (
+ recovery_map_list[index].raw_map is None
+ and recovery_map_list[index].map_object_name is not None
+ ):
+ try:
+ response = self._get_interim_file_data(recovery_map_list[index].map_object_name)
+ if response:
+ recovery_map_list[index].raw_map = response.decode()
+ except Exception as ex:
+ _LOGGER.warning("Get Recovery Map Object failed: %s", ex)
+ return
+
+ if recovery_map_list[index].raw_map:
+ recovery_map_list[index].map_data = DreameVacuumMapDecoder.decode_saved_map(
+ recovery_map_list[index].raw_map,
+ self._vslam_map,
+ self._saved_map_data[map_id].rotation,
+ self._aes_iv,
+ )
+ recovery_map_list[index].map_data.last_updated = recovery_map_list[index].date.timestamp()
+ recovery_map_list[index].map_data.recovery_map_type = recovery_map_list[index].map_type
+ recovery_map_list[index].map_data.recovery_map = True
+ return recovery_map_list[index].map_data
+
+ def get_recovery_map_file(self, map_id, index):
+ if map_id in self._map_list:
+ recovery_map_list = self._saved_map_data[map_id].recovery_map_list
+ index = int(index) - 1
+ if recovery_map_list and len(recovery_map_list) > index:
+ object_name = recovery_map_list[index].object_name
+ if object_name and object_name != "":
+ _LOGGER.info(
+ "Recovery map object name: %s",
+ object_name,
+ )
+ map_url = self._get_file_url(
+ object_name,
+ not (object_name.endswith("mb.tbz2") and not self._protocol.dreame_cloud),
+ )
+ _LOGGER.info("Recovery map file url: %s = %s", object_name, map_url)
+ if map_url:
+ return (
+ self._protocol.cloud.get_file(map_url),
+ map_url,
+ object_name,
+ )
+ return None, None, None
+
+ def listen(self, change_callback, update_callback) -> None:
+ self._change_callback = change_callback
+ self._update_callback = update_callback
+
+ def listen_error(self, callback) -> None:
+ self._error_callback = callback
+
+ def disconnect(self) -> None:
+ """Disconnect from map and cancel timers"""
+ self._disconnected = True
+ self.schedule_update(-1)
+ self._update_callback = None
+ self._change_callback = None
+ self._error_callback = None
+
+ def schedule_update(self, wait: float = None) -> None:
+ if wait == None:
+ wait = self._update_interval
+ if self._update_timer is not None:
+ self._update_timer.cancel()
+ del self._update_timer
+ self._update_timer = None
+ if wait >= 0 and not self._disconnected:
+ self._update_timer = Timer(wait, self._update_task)
+ self._update_timer.start()
+
+ def update(self) -> None:
+ if self._update_running:
+ return
+
+ self._update_running = True
+
+ _LOGGER.debug("Map update: %s", self._update_interval)
+ try:
+ if (self._map_list_object_name and self._need_map_list_request is None) or (
+ self._need_map_list_request and not self._device_running
+ ):
+ self.request_map_list()
+
+ if self._recovery_map_list_object_name and self._need_recovery_map_list_request:
+ self.request_recovery_map_list()
+
+ if self._need_new_map:
+ self.request_new_map()
+ self._need_new_map = False
+ elif self._map_request_time is not None or self._need_map_request:
+ self._updated_frame_id = None
self._map_request_count = self._map_request_count + 1
- if self._map_request_count >= 16:
+ if self._map_request_count >= 6:
self._map_request_time = None
self._need_map_request = False
- else:
- self._request_current_map(self._map_request_time)
- elif self._map_data is None or (
- self._device_running
- and (time.time() - (self._current_timestamp_ms / 1000.0) > 15 or self._map_data.empty_map)
- ):
- self._updated_frame_id = None
- if self._map_data and not self._map_data.empty_map:
- _LOGGER.info(
- "Need map request: %.2f",
- time.time() - (self._current_timestamp_ms / 1000.0),
+ elif (
+ not self._request_current_map(self._map_request_time)
+ and self._protocol.dreame_cloud
+ and self._map_request_count == 2
+ and self._map_data is None
+ ):
+ object_name_result = self._protocol.cloud.get_properties(DIID(DreameVacuumProperty.OBJECT_NAME))
+ if object_name_result and MAP_PARAMETER_VALUE in object_name_result[0]:
+ self._add_cloud_map_data(
+ None, object_name_result[0][MAP_PARAMETER_VALUE], object_name_result[0].get("updateDate")
+ )
+ elif not self._protocol.dreame_cloud:
+ if self._map_data is None or (
+ self._device_running
+ and (time.time() - (self._current_timestamp_ms / 1000.0) > 15 or self._map_data.empty_map)
+ ):
+ self._updated_frame_id = None
+ if self._map_data and not self._map_data.empty_map:
+ _LOGGER.info(
+ "Need map request: %.2f",
+ time.time() - (self._current_timestamp_ms / 1000.0),
+ )
+ if self._protocol.cloud.logged_in:
+ self._request_current_map()
+ elif not self._request_map_from_cloud() and self._device_running:
+ _LOGGER.debug("No new map data received, retrying")
+ sleep(1)
+ if not self._request_map_from_cloud():
+ self.schedule_update(1)
+ _LOGGER.debug("No new map data received on second try")
+ elif self._protocol.cloud.connected:
+ if not self._connected:
+ self._connected = True
+ self._map_data_changed()
+
+ if self._map_data is None or (
+ self._device_running
+ and (
+ (self._map_data.last_updated and time.time() - (self._map_data.last_updated) > 60)
+ or self._map_data.empty_map
)
- # if self._map_data and not self._map_data.empty_map and time.time() - (self._current_timestamp_ms / 1000.0) > 30:
- # self.request_new_map()
- # else:
- if self._protocol.cloud.logged_in:
- self._request_current_map()
- elif not self._request_map_from_cloud() and self._device_running:
- _LOGGER.info("No new map data received, retrying")
- sleep(0.5)
- if not self._request_map_from_cloud():
- _LOGGER.info("No new map data received on second try")
-
- if not self._available:
+ ):
+ if self._map_data and not self._map_data.empty_map:
+ _LOGGER.info(
+ "Need map request: %.2f",
+ time.time() - (self._map_data.last_updated),
+ )
+ self._request_map()
+ else:
+ self._request_current_map()
+ elif self._connected:
+ self._connected = False
+ self._map_data_changed()
+
+ if not self._available and self._connected:
self._available = True
self._map_data_changed()
except Exception as ex:
@@ -982,12 +1410,12 @@ def update(self) -> None:
self._ready = True
self._update_running = False
- def set_aes_iv(self, aes_iv: str) -> None:
- if aes_iv:
- self._aes_iv = aes_iv
-
- def set_vslam_map(self) -> None:
- self._vslam_map = True
+ def set_capability(self, capability) -> None:
+ if capability:
+ self._capability = capability
+ if not capability.lidar_navigation:
+ self._vslam_map = True
+ self._aes_iv = capability.key
def set_update_interval(self, update_interval: float) -> None:
if self._update_interval != update_interval:
@@ -995,10 +1423,14 @@ def set_update_interval(self, update_interval: float) -> None:
self.schedule_update()
def set_device_running(self, running: bool, docked: bool) -> None:
- if self._device_running != running or self._device_docked != docked:
+ if self._device_running != running:
self._device_running = running
- if self._device_docked != docked:
- if self._vslam_map and docked and self._map_data and self._map_data.saved_map_status == 1:
+
+ if self._device_docked != docked:
+ if docked:
+ if not self._vslam_map:
+ self._request_map()
+ elif self._map_data and self._map_data.saved_map_status == 1:
saved_map_data = self.selected_map
self._map_data.segments = copy.deepcopy(saved_map_data.segments)
self._map_data.data = copy.deepcopy(saved_map_data.data)
@@ -1007,7 +1439,7 @@ def set_device_running(self, running: bool, docked: bool) -> None:
self._map_data.charger_position = copy.deepcopy(saved_map_data.charger_position)
self._map_data.no_go_areas = saved_map_data.no_go_areas
self._map_data.no_mopping_areas = saved_map_data.no_mopping_areas
- self._map_data.walls = saved_map_data.walls
+ self._map_data.virtual_walls = saved_map_data.virtual_walls
self._map_data.robot_position = self._map_data.charger_position
self._map_data.docked = True
# self._map_data.restored_map = True
@@ -1015,10 +1447,11 @@ def set_device_running(self, running: bool, docked: bool) -> None:
self._map_data.need_optimization = False
self._map_data.saved_map_status = 2
self._map_data.last_updated = time.time()
+ self._map_data.optimized_pixel_type = None
+ self._map_data.optimized_charger_position = None
self._map_data_changed()
- self._device_docked = docked
-
+ self._device_docked = docked
self.schedule_update(2)
def set_device_docked(self, device_docked: bool) -> None:
@@ -1027,7 +1460,11 @@ def set_device_docked(self, device_docked: bool) -> None:
self._device_docked = device_docked
def request_new_map(self) -> None:
- if self._new_map_request_time and time.time() - self._new_map_request_time < 10:
+ if (
+ self._new_map_request_time
+ and time.time() - self._new_map_request_time < 10
+ and not self._protocol.dreame_cloud
+ ):
if time.time() - self._new_map_request_time > 3:
self._new_map_request_time = time.time()
self._request_map_from_cloud()
@@ -1038,39 +1475,39 @@ def request_new_map(self) -> None:
return self._request_i_map()
else:
result = self._request_map()
- if result and result[MAP_PARAMETER_CODE] == 0:
+ if result and result[MAP_PARAMETER_CODE] == 0 and not self._protocol.dreame_cloud:
self._request_map_from_cloud()
- def request_next_map(self) -> None:
+ def request_next_map(self, request_new=False) -> None:
self._map_request_count = 0
self._need_map_request = True
+ if request_new:
+ self._need_new_map = True
self.schedule_update(2)
def request_next_map_list(self) -> None:
self._need_map_list_request = True
- def set_map_list_object_name(self, map_list: dict[int, str]) -> bool:
- if map_list and map_list != "":
- md5 = map_list.get(MAP_PARAMETER_MD5)
- object_name = map_list.get(MAP_PARAMETER_OBJECT_NAME)
- if map_list and object_name and object_name != "":
- if self._map_list_object_name != object_name or self._map_list_md5 != md5:
- self._map_list_object_name = object_name
- if not self._device_running and self._map_list_md5 is not None:
- self.request_next_map_list()
- self.schedule_update(2)
- self._map_list_md5 = md5
- return True
+ def request_next_recovery_map_list(self) -> None:
+ self._need_recovery_map_list_request = True
+
+ def set_map_list_object_name(self, object_name: str, md5: str = None) -> bool:
+ if object_name and object_name != "":
+ if self._map_list_object_name != object_name or self._map_list_md5 != md5:
+ self._map_list_object_name = object_name
+ if not self._device_running and self._map_list_md5 is not None:
+ self.request_next_map_list()
+ self.schedule_update(3)
+ self._map_list_md5 = md5
+ return True
return False
- def set_recovery_map_list_object_name(self, map_list: dict[int, str]) -> bool:
- if map_list and map_list != "":
- object_name = map_list.get(MAP_PARAMETER_OBJECT_NAME)
- if map_list and object_name and object_name != "":
- if self._recovery_map_list_object_name != object_name:
- self._recovery_map_list_object_name = object_name
- self._need_recovery_map_list_request = True
- return True
+ def set_recovery_map_list_object_name(self, object_name: str) -> bool:
+ if object_name and object_name != "":
+ if self._recovery_map_list_object_name != object_name:
+ self._recovery_map_list_object_name = object_name
+ self._need_recovery_map_list_request = True
+ return True
return False
def request_map_list(self) -> None:
@@ -1079,17 +1516,15 @@ def request_map_list(self) -> None:
try:
response = self._get_interim_file_data(self._map_list_object_name)
except Exception as ex:
- _LOGGER.warn("Get Map List failed: %s", ex)
+ _LOGGER.warning("Get Map List failed: %s", ex)
return
if response:
self._need_map_list_request = False
- raw_map = response.decode()
-
try:
- map_info = json.loads(raw_map)
+ map_info = json.loads(response.decode())
except:
- _LOGGER.warn("Get Map List json parse failed")
+ _LOGGER.warning("Get Map List json parse failed")
return
saved_map_list = map_info[MAP_PARAMETER_MAPSTR]
@@ -1098,15 +1533,33 @@ def request_map_list(self) -> None:
map_list = {}
if saved_map_list:
for v in saved_map_list:
+ raw_map = None
if v.get(MAP_PARAMETER_MAP):
- saved_map_data = DreameVacuumMapDecoder.decode_saved_map(
- v[MAP_PARAMETER_MAP],
- self._vslam_map,
- int(v[MAP_PARAMETER_ANGLE]) if v.get(MAP_PARAMETER_ANGLE) else 0,
- self._aes_iv,
- )
+ raw_map = v[MAP_PARAMETER_MAP]
+ elif map_info.get("server") == 1 and "rismobj" in v:
+ try:
+ response = self._get_interim_file_data(v["rismobj"])
+ if response:
+ raw_map = response.decode()
+ except Exception as ex:
+ _LOGGER.warning("Get Saved Map Object failed: %s", ex)
+ return
+
+ if raw_map:
+ try:
+ saved_map_data = DreameVacuumMapDecoder.decode_saved_map(
+ raw_map,
+ self._vslam_map,
+ int(v[MAP_PARAMETER_ANGLE]) if v.get(MAP_PARAMETER_ANGLE) else 0,
+ self._aes_iv,
+ )
+ except Exception as ex:
+ _LOGGER.error("Parse saved map failed: %s", traceback.format_exc())
+ return
+
if saved_map_data is not None:
name = v.get(MAP_PARAMETER_NAME)
+ saved_map_data.object_name = v.get("mapobj")
if name:
saved_map_data.custom_name = name
saved_map_data.map_name = name
@@ -1116,31 +1569,53 @@ def request_map_list(self) -> None:
if map_id in self._saved_map_data:
if self._selected_map_id == map_id and self._map_data:
saved_map_data.cleanset = self._map_data.cleanset
+ saved_map_data.carpet_cleanset = self._map_data.carpet_cleanset
else:
saved_map_data.cleanset = self._saved_map_data[map_id].cleanset
+ saved_map_data.carpet_cleanset = self._saved_map_data[map_id].carpet_cleanset
+
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ saved_map_data,
+ saved_map_data.cleanset,
+ self._capability,
+ )
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ saved_map_data, saved_map_data.carpet_cleanset, self._capability
+ )
+ DreameVacuumMapDecoder.set_floor_material(saved_map_data, self._capability)
+
+ if saved_map_data.saved_furnitures is not None:
+ saved_map_data.furnitures = saved_map_data.saved_furnitures
if self._saved_map_data[map_id] != saved_map_data:
_LOGGER.info("Saved map changed: %s", map_id)
changed = True
saved_map_data.last_updated = now
+ if saved_map_data.wifi_map_data:
+ saved_map_data.wifi_map_data.last_updated = saved_map_data.last_updated
+ saved_map_data.recovery_map_list = self._saved_map_data[map_id].recovery_map_list
if self._map_data is None or self._selected_map_id != map_id:
self._saved_map_data[map_id] = saved_map_data
else:
self._saved_map_data[map_id].custom_name = saved_map_data.custom_name
self._saved_map_data[map_id].rotation = saved_map_data.rotation
+ else:
+ _LOGGER.info("Saved map not changed: %s", map_id)
else:
saved_map_data.last_updated = now
+ if saved_map_data.wifi_map_data:
+ saved_map_data.wifi_map_data.last_updated = saved_map_data.last_updated
self._saved_map_data[map_id] = saved_map_data
_LOGGER.info("Add saved map: %s", map_id)
changed = True
+ selected_map_id = map_info[MAP_PARAMETER_CURR_ID]
current_map_list = self._saved_map_data.copy()
for map_id in current_map_list.keys():
- if map_id not in map_list:
+ if map_id not in map_list and map_id != selected_map_id:
del self._saved_map_data[map_id]
changed = True
- selected_map_id = map_info[MAP_PARAMETER_CURR_ID]
if selected_map_id in self._saved_map_data and self._selected_map_id != selected_map_id:
self._selected_map_id = selected_map_id
changed = True
@@ -1148,39 +1623,75 @@ def request_map_list(self) -> None:
if changed == True:
self._refresh_map_list()
if self._map_data:
- self._map_data_changed()
+ self._map_data_changed(True)
+ self.request_next_recovery_map_list()
def request_recovery_map_list(self) -> None:
if self._recovery_map_list_object_name:
- now = time.time()
- response = self._get_interim_file_data(self._recovery_map_list_object_name)
+ if self._vslam_map:
+ self._need_recovery_map_list_request = False
+ return
+ _LOGGER.info("Get Recovery Map List: %s", self._recovery_map_list_object_name)
+ response = self._get_file_url(self._recovery_map_list_object_name)
if response:
self._need_recovery_map_list_request = False
- raw_map = response.decode()
- recovery_map_list = json.loads(raw_map)
- for recovery_map in recovery_map_list:
- map_id = recovery_map[MAP_PARAMETER_ID]
- if map_id in self._map_list:
- map_info_list = recovery_map[MAP_PARAMETER_INFO]
- for map_info in map_info_list:
- first = map_info[MAP_PARAMETER_FIRST]
- map_time = map_info[MAP_PARAMETER_TIME]
- object_name = map_info[MAP_PARAMETER_OBJNAME]
- if object_name.endswith("mb.tbz2"):
- response = self._protocol.cloud.get_file_url(object_name)
- else:
- response = self._protocol.cloud.get_interim_file_url(object_name)
+ response = self._protocol.cloud.get_file(response)
+ if response:
+ try:
+ recovery_map_list = json.loads(response.decode())
+ except:
+ _LOGGER.warning("Get Recovery Map List json parse failed")
+ return
- if response and response.get(MAP_PARAMETER_RESULT):
- _LOGGER.info("Get recovery map file url result: %s", response)
- map_url = response[MAP_PARAMETER_RESULT][MAP_PARAMETER_URL]
- recovery_map_data = DreameVacuumMapDecoder.decode_saved_map(
- map_info[MAP_PARAMETER_THB],
- self._vslam_map,
- self._saved_map_data[map_id].rotation,
- self._aes_iv,
+ changed = False
+ for recovery_map in recovery_map_list:
+ map_id = recovery_map["id"]
+ if map_id in self._map_list:
+ recovery_map_list = []
+ map_info_list = recovery_map["info"]
+ for map_info in map_info_list:
+ recovery_map_list.append(
+ RecoveryMapInfo(
+ map_id,
+ map_info.get("time"),
+ map_info.get("thb"),
+ map_info.get("rismobj"),
+ map_info.get("objname"),
+ map_info.get("first", -1),
+ )
)
- # TODO: store recovery map
+ if len(recovery_map_list) > 2:
+ recovery_map_list.sort(
+ key=cmp_to_key(
+ lambda a, b: (
+ int(a.map_type) - int(b.map_type)
+ if a.map_type is RecoveryMapType.EDITED
+ and b.map_type is RecoveryMapType.BACKUP
+ else 1 if a.date > b.date else -1
+ )
+ )
+ )
+
+ if (
+ not self._saved_map_data[map_id].recovery_map_list
+ or len(self._saved_map_data[map_id].recovery_map_list) != len(recovery_map_list)
+ or not all(
+ self._saved_map_data[map_id].recovery_map_list[i].__dict__
+ == recovery_map_list[i].__dict__
+ for i in range(len(self._saved_map_data[map_id].recovery_map_list))
+ )
+ ):
+ self._saved_map_data[map_id].last_updated = time.time()
+ self._saved_map_data[map_id].recovery_map_list = recovery_map_list
+ _LOGGER.info("Saved recovery map list changed: %s", map_id)
+ changed = True
+
+ if changed:
+ self._refresh_recovery_map_list()
+ if self._connected:
+ self._map_data_changed(True)
+ else:
+ _LOGGER.info("Saved recovery map list not changed: %s", map_id)
@property
def _request_i_map_available(self) -> bool:
@@ -1196,6 +1707,10 @@ def _request_i_map_available(self) -> bool:
)
)
+ @property
+ def ready(self) -> bool:
+ return self._ready
+
@property
def map_list(self) -> list[int] | None:
return self._saved_map_data.keys()
@@ -1213,6 +1728,24 @@ def selected_map(self) -> MapData | None:
if self._map_list and len(self._map_list) == 1 and self._map_list[0] in self._saved_map_data:
return self._saved_map_data[self._map_list[0]]
+ @property
+ def cleaning_sequence(self) -> list | None:
+ map_data = self._map_data
+ return (
+ [
+ (k)
+ for k, v in sorted(
+ map_data.segments.items(),
+ key=lambda s: (
+ s[1].order if s[1].order != None else (64 if self._capability.cleaning_sequence_v2 else 0)
+ ),
+ )
+ if (v.order or self._capability.cleaning_sequence_v2) and v.visibility != False
+ ]
+ if map_data and map_data.segments
+ else []
+ )
+
class DreameMapVacuumMapEditor:
"""Every map change must be handled on memory before actually requesting it to the device because it takes too much time to get the updated map from the cloud.
@@ -1220,23 +1753,29 @@ class DreameMapVacuumMapEditor:
Original app has a similar class to handle the same issue (Works optimistically)"""
def __init__(self, map_manager) -> None:
- self._previous_cleaning_sequence: dict[int, list[int]] = {}
- self.map_manager = map_manager
+ self.map_manager: DreameMapVacuumMapManager = map_manager
def _set_updated_frame_id(self, frame_id) -> None:
self.map_manager._updated_frame_id = frame_id
- def refresh_map(self, map_id: int = None) -> None:
+ def _refresh_map(self, map_id: int = None) -> None:
if map_id:
if self._saved_map_data and map_id in self._saved_map_data:
self._saved_map_data[map_id].last_updated = time.time()
+ self.map_manager._map_data_updated()
return
if self._map_data is not None:
self._map_data.last_updated = time.time()
+ self.map_manager._map_data_updated()
+
+ def refresh_map(self, map_id: int = None) -> None:
+ timer = Timer(0.5, self._refresh_map, [map_id])
+ timer.start()
def set_active_areas(self, active_areas: list[list[int]]) -> None:
map_data = self._map_data
if map_data is not None:
+ map_data.active_cruise_points = None
map_data.active_areas = []
for area in active_areas:
x_coords = sorted([area[0], area[2]])
@@ -1277,41 +1816,82 @@ def set_active_points(self, active_points: list[list[int]]) -> None:
self._set_updated_frame_id(map_data.frame_id)
self.refresh_map()
+ def set_cruise_points(self, active_cruise_points: list[list[int]]) -> None:
+ map_data = self._map_data
+ if map_data is not None:
+ map_data.active_cruise_points = {}
+ index = 0
+ if active_cruise_points:
+ map_data.path = None
+ map_data.obstacles = None
+ map_data.active_areas = None
+ map_data.active_segments = None
+ for point in active_cruise_points:
+ index = index + 1
+ map_data.active_cruise_points[index] = Coordinate(
+ point[0],
+ point[1],
+ bool(point[2]),
+ point[3],
+ )
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+
def clear_path(self) -> None:
map_data = self._map_data
if map_data is not None:
map_data.path = None
+ # map_data.obstacles = None
+ # map_data.active_cruise_points = None
+ map_data.active_areas = None
+ map_data.active_segments = None
self._set_updated_frame_id(map_data.frame_id)
self.refresh_map()
def reset_map(self) -> None:
map_data = self._map_data
- if map_data is not None:
+ if map_data is not None and not map_data.new_map and not map_data.empty_map:
map_data.dimensions.width = 0
map_data.dimensions.height = 0
map_data.segments = {}
+ map_data.floor_material = None
+ map_data.carpet_cleanset = None
+ map_data.hidden_segments = None
map_data.path = None
+ map_data.carpets = None
+ map_data.detected_carpets = None
+ map_data.deleted_carpets = None
+ map_data.carpet_pixels = None
+ map_data.obstacles = None
map_data.empty_map = True
map_data.saved_map_status = 0
- self._set_updated_frame_id(map_data.frame_id + 2)
+ self._set_updated_frame_id(map_data.frame_id + 1)
self.refresh_map()
def set_rotation(self, map_id: int, rotation: int) -> None:
if map_id in self._saved_map_data:
self._saved_map_data[map_id].rotation = rotation
+ if self.map_manager._capability.floor_material:
+ DreameVacuumMapDecoder.set_floor_material(self._saved_map_data[map_id], self.map_manager._capability)
if self._map_data is not None and map_id == self._selected_map_id:
self._map_data.rotation = rotation
+ if self.map_manager._capability.floor_material:
+ DreameVacuumMapDecoder.set_floor_material(self._map_data, self.map_manager._capability)
self.refresh_map()
self.refresh_map(map_id)
def set_map_name(self, map_id: int, name: str) -> None:
if map_id in self._saved_map_data:
- self._saved_map_data[map_id].custom_name = name
- self._saved_map_data[map_id].map_name = name
+ if name and len(name):
+ self._saved_map_data[map_id].custom_name = name
+ self._saved_map_data[map_id].map_name = name
+ else:
+ self._saved_map_data[map_id].custom_name = None
+ self._saved_map_data[map_id].map_name = f"Map {str(self._saved_map_data[map_id].map_index)}"
self.refresh_map(map_id)
self.refresh_map()
- def select_map(self, map_id: int) -> None:
+ def set_selected_map(self, map_id: int) -> None:
if map_id != self._selected_map_id:
self.set_current_map(map_id)
@@ -1322,286 +1902,1503 @@ def set_current_map(self, map_id: int) -> None:
saved_map_data.timestamp_ms = self._current_timestamp_ms
saved_map_data.frame_id = None
saved_map_data.map_name = None
- saved_map_data.map_index = 0
+ saved_map_data.saved_map_id = map_id
saved_map_data.custom_name = None
saved_map_data.saved_map = False
saved_map_data.restored_map = True
saved_map_data.temporary_map = False
saved_map_data.empty_map = False
saved_map_data.saved_map_status = 2
- DreameVacuumMapDecoder.set_segment_cleanset(saved_map_data, saved_map_data.cleanset)
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ saved_map_data,
+ saved_map_data.cleanset,
+ self.map_manager._capability,
+ )
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ saved_map_data, saved_map_data.carpet_cleanset, self.map_manager._capability
+ )
+ DreameVacuumMapDecoder.set_floor_material(saved_map_data, self.map_manager._capability)
self.map_manager._map_data = saved_map_data
self.map_manager._current_frame_id = None
self.map_manager._current_map_id = map_id
self.map_manager._selected_map_id = map_id
self.refresh_map()
+ self.refresh_map(map_id)
- def delete_map(self, map_id: int = None) -> None:
+ def set_carpet_area(self, carpets, deleted_carpets):
map_data = self._map_data
- if map_data and map_data.temporary_map:
+ if (
+ not map_data
+ or not self._selected_map_id
+ or (map_data.carpets is None and map_data.deleted_carpets is None)
+ ):
return
- if map_id is None:
- self.map_manager._map_data = None
- self.map_manager._selected_map_id = None
- self.map_manager._updated_frame_id = None
- self.map_manager._saved_map_data = {}
- self.map_manager._refresh_map_list()
- self.map_manager.request_next_map_list()
- else:
- if self._saved_map_data and map_id not in self._saved_map_data:
- self.map_manager.schedule_update(2)
- return
+ new_carpets = []
+ carpet_types = [] if self.map_manager._capability.carpet_type else None
+ carpet_tassels = [] if self.map_manager._capability.carpet_tassel else None
+ if carpets:
+ carpet_id = self.map_manager._capability.carpet_id
+ if not carpet_id: ## Fallback for older vacuum plugins that does not have carpet id indicator
+ for map_carpet in map_data.carpets:
+ if map_carpet.id is not None:
+ carpet_id = True
+ break
- if map_data and self._selected_map_id == map_id:
- if len(self.map_manager._map_list) > 1:
- self.set_current_map(self.map_manager._map_list[-1])
- else:
- self.map_manager._map_data = None
- self._updated_frame_id = None
- self._selected_map_id = None
+ if carpet_id:
+ carpet_id = 1
+ for i in range(len(carpets)):
+ carpet = carpets[i]
+ if len(carpet) < 5 or carpet[4] < 0:
+ if self.map_manager._capability.carpet_material:
+ carpet_id = -1
+ else:
+ flag = True
+ found = False
+
+ while flag:
+ found = False
+ for map_carpet in map_data.carpets:
+ if map_carpet.id == carpet_id:
+ carpet_id = carpet_id + 1
+ found = True
+ break
+ flag = found
+
+ if len(carpet) < 5:
+ carpets[i].append(carpet_id)
+ else:
+ carpets[i][4] = carpet_id
+ carpet_id = carpet_id + 1
+ else:
+ for i in range(len(carpets)):
+ if len(carpets[i]) > 4:
+ carpets[i] = carpets[i][:4]
+
+ for i in range(len(carpets)):
+ carpet = carpets[i]
+ carpet_type = None
+ if carpet_types is not None:
+ carpet_type = 7
+ if len(carpet) > 6:
+ if (
+ carpet[6] == 5
+ or carpet[6] == 6
+ or (carpet[6] == 8 and self.map_manager._capability.floor_mats)
+ ):
+ carpet_type = carpet[6]
+ elif len(carpet) > 4 and carpet[4] >= 0:
+ for map_carpet in map_data.carpets:
+ if map_carpet.id == carpet[4]:
+ carpet_type = map_carpet.carpet_type
+ break
- del self.map_manager._saved_map_data[map_id]
- self.map_manager._refresh_map_list()
- self.map_manager.request_next_map_list()
+ carpet_types.append([carpet[4], carpet_type])
+
+ carpet_tassel = None
+ hidden = None
+ if carpet_tassels is not None:
+ hidden = 0
+ carpet_tassel = [0, 0, 0, 0, 0]
+ if len(carpet) > 4 and carpet[4] >= 0:
+ for map_carpet in map_data.carpets:
+ if map_carpet.id == carpet[4]:
+ carpet_tassel = map_carpet.tassel
+ hidden = map_carpet.hidden
+ break
+ if len(carpet) > 7 and carpet[7] and len(carpet[7]) == 5:
+ carpet_tassel = carpet[7]
+
+ carpet_tassels.append([carpet[4], carpet_tassel])
+
+ new_carpets.append(
+ Carpet(
+ carpet[4] if len(carpet) > 4 else None,
+ carpet[0],
+ carpet[1],
+ carpet[2],
+ carpet[1],
+ carpet[2],
+ carpet[3],
+ carpet[0],
+ carpet[3],
+ carpet[5] if len(carpet) > 5 else None,
+ carpet_type,
+ None,
+ None,
+ None,
+ hidden,
+ carpet_tassel,
+ )
+ )
- def merge_segments(self, map_id: int, segments: list[int]) -> None:
- saved_map_data = self._saved_map_data
- if saved_map_data and map_id in saved_map_data and len(segments) == 2:
- map_data = saved_map_data[map_id]
- if map_data.segments and segments[0] in map_data.segments and segments[1] in map_data.segments:
- if segments[1] not in map_data.segments[segments[0]].neighbors:
- _LOGGER.error("Segments are not neighbors with each other: %s", segments)
- return
+ if len(carpet) > 6: ## Remove carpet type from array to be sent to device
+ carpets[i] = carpet[:6]
- data = np.zeros((map_data.dimensions.width * map_data.dimensions.height), np.uint8)
- for y in range(map_data.dimensions.height):
- for x in range(map_data.dimensions.width):
- index = y * map_data.dimensions.width + x
- if (map_data.data[index] & 0x3F) == segments[1]:
- data[index] = segments[0]
- else:
- data[index] = map_data.data[index]
+ map_data.carpets = new_carpets
+ DreameVacuumMapDecoder.set_carpet_cleanset(map_data, map_data.carpet_cleanset, self.map_manager._capability)
- if int(map_data.pixel_type[x, y]) == segments[1]:
- map_data.pixel_type[x, y] = segments[0]
+ new_deleted_carpets = []
+ if deleted_carpets:
+ for carpet in deleted_carpets:
+ x_coords = sorted([carpet[0], carpet[2]])
+ y_coords = sorted([carpet[1], carpet[3]])
+ new_deleted_carpets.append(
+ Carpet(
+ None,
+ x_coords[0],
+ y_coords[0],
+ x_coords[1],
+ y_coords[0],
+ x_coords[1],
+ y_coords[1],
+ x_coords[0],
+ y_coords[1],
+ )
+ )
+ map_data.deleted_carpets = new_deleted_carpets
- map_data.data = bytes(data)
- del self.map_manager._saved_map_data[map_id].segments[segments[1]]
- new_segments = DreameVacuumMapDecoder.get_segments(map_data, self.map_manager._vslam_map)
- map_data.segments[segments[0]].x = new_segments[segments[0]].x
- map_data.segments[segments[0]].y = new_segments[segments[0]].y
+ self._saved_map_data[self._selected_map_id].carpets = map_data.carpets
+ self._saved_map_data[self._selected_map_id].deleted_carpets = map_data.deleted_carpets
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map(self._selected_map_id)
+ self.refresh_map()
+ return carpets, deleted_carpets, carpet_types, carpet_tassels
- for k, v in map_data.segments.items():
- if segments[1] in v.neighbors:
- map_data.segments[k].neighbors.remove(segments[1])
+ def set_carpet_type(self, carpet_types) -> dict[str, list[int]]:
+ map_data = self._map_data
+ if (
+ not map_data
+ or not self._selected_map_id
+ or not (map_data.detected_carpets is not None or map_data.carpets is not None)
+ ):
+ return
- DreameVacuumMapDecoder.set_segment_color_index(map_data)
- if self._map_data and map_id == self._selected_map_id:
- self.set_current_map(map_id)
- self.refresh_map(map_id)
+ def set_carpet_cleaning(carpet, carpet_type, object_type):
+ if map_data.carpet_cleanset is not None and not (
+ carpet.carpet_cleaning == 0 or carpet.carpet_cleaning is None or carpet.carpet_cleaning > 0
+ ):
+ if carpet_type == 7 or not self.map_manager._capability.mop_pad_unmounting:
+ carpet.carpet_cleaning = 2
+ elif carpet_type == 5:
+ carpet.carpet_cleaning = 1
+ elif carpet_type == 6:
+ carpet.carpet_cleaning = 3
+ elif carpet_type == 8:
+ carpet.carpet_cleaning = 7
+
+ for cleanset in map_data.carpet_cleanset:
+ if cleanset[0] == object_type and cleanset[1] == carpet.id:
+ cleanset[2] = carpet.carpet_cleaning
+
+ carpet_type = {}
+ key = "origincpt"
+ for carpet in map_data.detected_carpets:
+ if key in carpet_types:
+ for selected_carpet in carpet_types[key]:
+ if selected_carpet[0] == carpet.id:
+ if carpet.carpet_type != selected_carpet[1]:
+ carpet.carpet_type = selected_carpet[1]
+ set_carpet_cleaning(carpet, carpet.carpet_type, 0)
+ break
+ if key not in carpet_type:
+ carpet_type[key] = []
+ carpet_type[key].append([carpet.id, carpet.carpet_type if carpet.carpet_type else 7])
+
+ key = "addcpt"
+ for carpet in map_data.carpets:
+ if key in carpet_types:
+ for selected_carpet in carpet_types[key]:
+ if selected_carpet[0] == carpet.id:
+ if carpet.carpet_type != selected_carpet[1]:
+ carpet.carpet_type = selected_carpet[1]
+ set_carpet_cleaning(carpet, carpet.carpet_type, 1)
+ break
+ if key not in carpet_type:
+ carpet_type[key] = []
+ carpet_type[key].append([carpet.id, carpet.carpet_type if carpet.carpet_type else 7])
- def split_segments(self, map_id: int, segment: int, line: list[int]) -> None:
- if self._saved_map_data and map_id in self._saved_map_data:
- if self._map_data and map_id == self._selected_map_id:
- self.set_current_map(map_id)
- self.refresh_map(map_id)
+ if self.map_manager._capability.carpet_material:
+ key = "roomcpt"
+ for k, v in map_data.segments.items():
+ if key in carpet_types:
+ for selected_carpet in carpet_types[key]:
+ if selected_carpet[0] == k:
+ if v.floor_material != selected_carpet[1]:
+ v.floor_material = selected_carpet[1]
+ set_carpet_cleaning(v, v.floor_material, 2)
+ break
+ if key not in carpet_type:
+ carpet_type[key] = []
+ carpet_type[key].append([k, v.floor_material if v.floor_material else 0])
- def save_temporary_map(self) -> None:
- if self._map_data and self._map_data.temporary_map:
- self._map_data.temporary_map = False
- self.refresh_map()
- self.map_manager.request_next_map_list()
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].carpet_cleanset = map_data.carpet_cleanset.copy()
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ self._saved_map_data[self._selected_map_id],
+ self._saved_map_data[self._selected_map_id].carpet_cleanset,
+ self.map_manager._capability,
+ )
+ self.refresh_map(self._selected_map_id)
- def discard_temporary_map(self) -> None:
- if self._map_data and self._map_data.temporary_map and self._selected_map_id:
- self.set_current_map(self._selected_map_id)
- self.map_manager.request_next_map_list()
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return carpet_type
- def replace_temporary_map(self, map_id: int = None) -> None:
+ def set_virtual_thresholds(self, virtual_thresholds) -> None:
map_data = self._map_data
- if map_data and map_data.temporary_map:
- if not map_id and self._selected_map_id:
- map_id = self._selected_map_id
+ if (
+ not map_data
+ or not self._selected_map_id
+ or not (map_data.virtual_thresholds is not None or map_data.passable_thresholds is not None)
+ ):
+ return
- if map_id in self._saved_map_data:
- new_map = copy.deepcopy(map_data)
- new_map.map_id = new_map.saved_map_id
- new_map.saved_map_id = None
- new_map.saved_map_status = -1
- new_map.saved_map = True
- new_map.cleanset = {}
- self.map_manager._saved_map_data[new_map.map_id] = new_map
- del self.map_manager._saved_map_data[map_id]
- self.map_manager._refresh_map_list()
+ thresholds = []
+ if virtual_thresholds:
+ for line in virtual_thresholds:
+ thresholds.append(
+ Wall(
+ line[0],
+ line[1],
+ line[2],
+ line[3],
+ )
+ )
- map_data.saved_map_id = new_map.map_id
- map_data.temporary_map = False
- map_data.saved_map = False
- map_data.saved_map_status = 0
- map_data.restored_map = True
- map_data.empty_map = False
- map_data.cleanset = {}
- DreameVacuumMapDecoder.set_segment_cleanset(map_data, map_data.cleanset)
- self.map_manager._map_data = map_data
- self.map_manager._selected_map_id = new_map.map_id
- self.map_manager.request_next_map_list()
- self.refresh_map()
+ if map_data.passable_thresholds is not None:
+ map_data.passable_thresholds = thresholds
+ else:
+ map_data.virtual_thresholds = thresholds
- def restore_map(self, map_id: int, map_url: str) -> None:
- self.map_manager.request_next_map_list()
+ self._set_updated_frame_id(map_data.frame_id)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].virtual_thresholds = map_data.virtual_thresholds
+ self._saved_map_data[self._selected_map_id].passable_thresholds = map_data.passable_thresholds
+ self.refresh_map(self._selected_map_id)
+ self.refresh_map()
+
+ def set_thresholds(self, passable_thresholds, impassable_thresholds, ramps) -> None:
+ map_data = self._map_data
+ if not map_data or not self._selected_map_id or map_data.passable_thresholds is None:
+ return
+
+ if passable_thresholds:
+ map_data.passable_thresholds = [
+ Wall(
+ wall[0],
+ wall[1],
+ wall[2],
+ wall[3],
+ )
+ for wall in passable_thresholds
+ ]
+ else:
+ map_data.passable_thresholds = []
+
+ if impassable_thresholds:
+ map_data.impassable_thresholds = [
+ Wall(
+ wall[0],
+ wall[1],
+ wall[2],
+ wall[3],
+ )
+ for wall in impassable_thresholds
+ ]
+ else:
+ map_data.impassable_thresholds = []
+
+ map_data.ramps = []
+ if ramps:
+ for area in ramps:
+ x_coords = sorted([area[0], area[2]])
+ y_coords = sorted([area[1], area[3]])
+ map_data.ramps.append(
+ Area(
+ x_coords[0],
+ y_coords[0],
+ x_coords[1],
+ y_coords[0],
+ x_coords[1],
+ y_coords[1],
+ x_coords[0],
+ y_coords[1],
+ area[4],
+ )
+ )
+
+ self._set_updated_frame_id(map_data.frame_id)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].passable_thresholds = map_data.passable_thresholds
+ self._saved_map_data[self._selected_map_id].impassable_thresholds = map_data.impassable_thresholds
+ self._saved_map_data[self._selected_map_id].ramps = map_data.ramps
+ self.refresh_map(self._selected_map_id)
+ self.refresh_map()
+
+ def set_furnitures(self, furnitures) -> dict[str, list[int | float]]:
+ map_data = self._map_data
+ if not map_data or not self._selected_map_id or map_data.furnitures is None or not map_data.furniture_version:
+ return
+
+ if map_data.furniture_version >= 2:
+ furniture_id = 0
+ for furniture in furnitures:
+ if furniture[0] < 0:
+ flag = True
+ found = False
+
+ while flag:
+ found = False
+ for map_furniture in map_data.furnitures.values():
+ if map_furniture.furniture_id == furniture_id:
+ furniture_id = furniture_id + 1
+ found = True
+ break
+ flag = found
+
+ furniture[0] = furniture_id
+ furniture_id = furniture_id + 1
+
+ map_data.furnitures = {}
+ index = 0
+ for furniture in furnitures:
+ if (
+ furniture[1] not in FurnitureType._value2member_map_
+ or (
+ map_data.furniture_version >= 2
+ and not self.map_manager._capability.extended_furnitures
+ and ((furniture[1] > 13 and furniture[1] != 25) or furniture[1] == 8)
+ )
+ or (map_data.furniture_version < 2 and furniture[1] >= 10)
+ or (not self.map_manager._capability.pet_furniture and furniture[1] >= 10 and furniture[1] <= 13)
+ ):
+ continue
+
+ map_data.furnitures[index] = Furniture(
+ furniture_id=furniture[0] if map_data.furniture_version >= 2 else None,
+ type=FurnitureType(furniture[1]),
+ segment_id=furniture[2],
+ width=furniture[3],
+ height=furniture[4],
+ x0=int(furniture[5] - (furniture[3] / 2)),
+ y0=int(furniture[6] - (furniture[4] / 2)),
+ x=furniture[5],
+ y=furniture[6],
+ angle=furniture[7],
+ scale=furniture[8],
+ edit_type=furniture[9],
+ modified=furniture[10],
+ )
+ index = index + 1
+ if map_data.furniture_version >= 2:
+ return {
+ "mapfurniture_v2": [
+ [
+ furniture.furniture_id,
+ 25 if furniture.type.value == 8 else 8 if furniture.type.value == 25 else furniture.type.value,
+ furniture.segment_id,
+ furniture.width,
+ furniture.height,
+ 0,
+ furniture.x,
+ furniture.y,
+ 0,
+ furniture.angle,
+ 0,
+ 0,
+ furniture.scale,
+ furniture.edit_type,
+ furniture.modified,
+ ]
+ for furniture in map_data.furnitures.values()
+ ]
+ }
+ return {
+ "mapfurniture": [
+ [
+ furniture.x,
+ furniture.y,
+ furniture.type.value,
+ furniture.edit_type,
+ furniture.x0,
+ furniture.y0,
+ furniture.width,
+ furniture.height,
+ furniture.angle,
+ furniture.scale,
+ ]
+ for furniture in map_data.furnitures.values()
+ ],
+ "mfet": [1 if furniture.modified else 0 for furniture in map_data.furnitures.values()],
+ }
+
+ def set_curtains(self, curtains) -> None:
+ map_data = self._map_data
+ if not map_data or not self._selected_map_id or map_data.curtains is None:
+ return
+
+ map_data.curtains = []
+ for line in curtains:
+ map_data.curtains.append(
+ Wall(
+ line[0],
+ line[1],
+ line[2],
+ line[3],
+ )
+ )
+
+ self._set_updated_frame_id(map_data.frame_id)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].curtains = map_data.curtains
+ self.refresh_map(self._selected_map_id)
+ self.refresh_map()
+
+ def set_predefined_points(self, predefined_points) -> None:
+ map_data = self._map_data
+ if not map_data or not self._selected_map_id or map_data.predefined_points is None:
+ return
+
+ map_data.predefined_points = []
+ if predefined_points:
+ for point in predefined_points:
+ map_data.predefined_points.append(
+ Coordinate(
+ point[0],
+ point[1],
+ bool(point[2]),
+ point[3],
+ )
+ )
+
+ self._saved_map_data[self._selected_map_id].predefined_points = map_data.predefined_points
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map(self._selected_map_id)
+ self.refresh_map()
+ return
+
+ def set_obstacle_ignore(self, x, y, obstacle_ignored):
+ map_data = self._map_data
+ if not map_data or not map_data.obstacles:
+ return
+
+ for k, v in map_data.obstacles.items():
+ if int(v.x) == int(x) and int(v.y) == int(y):
+ map_data.obstacles[k].ignore_status = (
+ ObstacleIgnoreStatus.MANUALLY_IGNORED
+ if bool(obstacle_ignored)
+ else ObstacleIgnoreStatus.NOT_IGNORED
+ )
+ break
+
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return
+
+ def set_router_position(self, x, y):
+ map_data = self._map_data
+ if not map_data or not self._selected_map_id or map_data.router_position is None:
+ return
+
+ router_position = Point(int(x), int(y))
+ self._saved_map_data[self._selected_map_id].router_position = router_position
+ if self._saved_map_data[self._selected_map_id].wifi_map_data:
+ self._saved_map_data[self._selected_map_id].wifi_map_data.router_position = router_position
+ map_data.router_position = router_position
+ if map_data.wifi_map_data:
+ map_data.wifi_map_data.router_position = router_position
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map(self._selected_map_id)
+ self.refresh_map()
+ return
+
+ def delete_map(self, map_id: int = None) -> None:
+ map_data = self._map_data
+ if map_data and map_data.temporary_map:
+ return
+
+ if map_id is None:
+ self.map_manager._map_data = None
+ self.map_manager._selected_map_id = None
+ self.map_manager._updated_frame_id = None
+ self.map_manager._saved_map_data = {}
+ self.map_manager._refresh_map_list()
+ self.map_manager.request_next_map_list()
+ else:
+ if self._saved_map_data and map_id not in self._saved_map_data:
+ self.map_manager.schedule_update(2)
+ return
+
+ if map_data and self._selected_map_id == map_id:
+ if len(self.map_manager._map_list) >= 2:
+ for id in reversed(self.map_manager._saved_map_data.keys()):
+ if id != map_id:
+ del self.map_manager._saved_map_data[map_id]
+ self.map_manager._refresh_map_list()
+ self.set_current_map(id)
+ break
+ else:
+ del self.map_manager._saved_map_data[map_id]
+ self.map_manager._map_data = None
+ self._updated_frame_id = None
+ self.map_manager._selected_map_id = None
+ self.map_manager._refresh_map_list()
+ else:
+ del self.map_manager._saved_map_data[map_id]
+ self.map_manager._refresh_map_list()
+
+ self.map_manager.request_next_map_list()
+
+ def save_temporary_map(self) -> None:
+ if self._map_data and self._map_data.temporary_map:
+ self._map_data.temporary_map = False
+ self.refresh_map()
+ self.map_manager.request_next_map_list()
+
+ def discard_temporary_map(self) -> None:
+ if self._map_data and self._map_data.temporary_map and self._selected_map_id:
+ self.set_current_map(self._selected_map_id)
+ self.map_manager.request_next_map_list()
+
+ def replace_temporary_map(self, map_id: int = None) -> None:
+ map_data = self._map_data
+ if map_data and map_data.temporary_map:
+ if not map_id and self._selected_map_id:
+ map_id = self._selected_map_id
+
+ if map_id in self._saved_map_data:
+ new_map = copy.deepcopy(map_data)
+ new_map.map_id = new_map.saved_map_id
+ new_map.saved_map_id = None
+ new_map.saved_map_status = -1
+ new_map.saved_map = True
+ new_map.cleanset = {}
+ self.map_manager._saved_map_data[new_map.map_id] = new_map
+ del self.map_manager._saved_map_data[map_id]
+ self.map_manager._refresh_map_list()
+
+ map_data.saved_map_id = new_map.map_id
+ if map_data.saved_map_id and map_data.saved_map_id in self._saved_map_data:
+ map_data.map_index = self._saved_map_data[map_data.saved_map_id].map_index
+ else:
+ map_data.map_index = 0
+ map_data.temporary_map = False
+ map_data.saved_map = False
+ map_data.saved_map_status = 0
+ map_data.restored_map = True
+ map_data.empty_map = False
+ map_data.cleanset = {}
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ map_data, map_data.carpet_cleanset, self.map_manager._capability
+ )
+ DreameVacuumMapDecoder.set_floor_material(map_data, self.map_manager._capability)
+ self.map_manager._map_data = map_data
+ self.map_manager._selected_map_id = new_map.map_id
+ self.map_manager.request_next_map_list()
+ self.refresh_map()
+
+ def restore_map(self, recovery_map_info: RecoveryMapInfo) -> None:
+ if recovery_map_info and recovery_map_info.map_id in self.map_manager._map_list:
+ self.map_manager.schedule_update(15)
+
+ if recovery_map_info.raw_map is None and recovery_map_info.map_object_name is not None:
+ try:
+ response = self._get_interim_file_data(recovery_map_info.map_object_name)
+ if response:
+ recovery_map_info.raw_map = response.decode()
+ except Exception as ex:
+ _LOGGER.warning("Get Recovery Map Object failed: %s", ex)
+ return
+
+ recovery_map_data = (
+ (
+ DreameVacuumMapDecoder.decode_saved_map(
+ recovery_map_info.raw_map,
+ self.map_manager._vslam_map,
+ self._saved_map_data[recovery_map_info.map_id].rotation,
+ self.map_manager._aes_iv,
+ )
+ )
+ if recovery_map_info.map_data is None
+ else recovery_map_info.map_data
+ )
+ recovery_map_data.recovery_map = False
+ recovery_map_data.saved_map = True
+ recovery_map_data.map_name = self._saved_map_data[recovery_map_info.map_id].map_name
+ recovery_map_data.custom_name = self._saved_map_data[recovery_map_info.map_id].custom_name
+ recovery_map_data.rotation = self._saved_map_data[recovery_map_info.map_id].rotation
+ recovery_map_data.map_index = self._saved_map_data[recovery_map_info.map_id].map_index
+ recovery_map_data.recovery_map_list = self._saved_map_data[recovery_map_info.map_id].recovery_map_list
+ recovery_map_data.timestamp_ms = self._saved_map_data[recovery_map_info.map_id].timestamp_ms
+ recovery_map_data.last_updated = time.time()
+ if recovery_map_data.wifi_map:
+ recovery_map_data.wifi_map.last_updated = time.time()
+
+ self._saved_map_data[recovery_map_info.map_id] = recovery_map_data
+ self.refresh_map(recovery_map_info.map_id)
+ if recovery_map_info.map_id == self._selected_map_id:
+ self.set_current_map(recovery_map_info.map_id)
+ # self._map_data.restored_map = False
+ DreameVacuumMapDecoder.set_floor_material(self._map_data, self.map_manager._capability)
+
+ self.map_manager._map_request_count = 0
+ self.map_manager._map_request_time = None
+ self.map_manager._need_map_request = True
+ self.map_manager._need_map_list_request = True
def set_cleaning_sequence(self, cleaning_sequence: list[int]) -> list[int] | None:
map_data = self._map_data
if map_data and map_data.segments and not map_data.temporary_map:
+ cleaning_sequence_v2 = self.map_manager._capability.cleaning_sequence_v2
new_cleaning_sequence = []
+
+ if cleaning_sequence_v2 and not cleaning_sequence:
+ cleaning_sequence = [v.id for v in map_data.segments.values()]
+
if cleaning_sequence:
+ index = len(cleaning_sequence) + 1
+ for k in map_data.segments.keys():
+ if k not in cleaning_sequence:
+ if cleaning_sequence_v2:
+ map_data.segments[k].order = index
+ index = index + 1
+ else:
+ map_data.segments[k].order = 0
+ map_data.cleanset[str(k)][3] = 0
+
index = 1
- for k in (
- cleaning_sequence
- if (
- len(cleaning_sequence) == len(map_data.segments.items())
- and all(k in cleaning_sequence for k in map_data.segments.keys())
- )
- else sorted(map_data.segments.keys())
- ):
- map_data.segments[k].order = index
- map_data.cleanset[str(k)][3] = map_data.segments[k].order
- new_cleaning_sequence.append(k)
- index = index + 1
+ for k in cleaning_sequence:
+ if int(k) in map_data.segments.keys():
+ map_data.segments[k].order = index
+ if not cleaning_sequence_v2:
+ map_data.cleanset[str(k)][3] = index
+ new_cleaning_sequence.append(k)
+ index = index + 1
else:
- for v in map_data.segments.values():
- if v.order:
- self._previous_cleaning_sequence[map_data.map_id] = [
- (k) for k, v in sorted(map_data.segments.items(), key=lambda s: s[1].order) if v.order
- ]
- break
-
for k in map_data.segments.keys():
map_data.segments[k].order = 0
map_data.cleanset[str(k)][3] = 0
+ if cleaning_sequence_v2:
+ map_data.cleaning_sequence = {
+ str(k): map_data.segments[k].order
+ for k in sorted(map_data.segments.keys(), key=lambda k: map_data.segments[k].id)
+ if map_data.segments[k].visibility != False
+ }
+
if self._saved_map_data and map_data.map_id in self._saved_map_data:
- self._saved_map_data[map_data.map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if cleaning_sequence_v2:
+ self._saved_map_data[self._selected_map_id].cleaning_sequence = map_data.cleaning_sequence.copy()
+ else:
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
- self._set_updated_frame_id(map_data.frame_id + 1)
+ self._set_updated_frame_id(map_data.frame_id)
self.refresh_map()
- return [(k) for k, v in sorted(map_data.segments.items(), key=lambda s: s[1].order) if v.order]
+ return self.map_manager.cleaning_sequence
def set_segment_order(self, segment_id: int, order: int) -> list[int] | None:
+ if order is None or (isinstance(order, str) and not order.isnumeric()):
+ order = 0
map_data = self._map_data
if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
- if order > 0:
- if (
- not map_data.segments[segment_id].order
- and map_data.map_id in self._previous_cleaning_sequence
- and len(self._previous_cleaning_sequence[map_data.map_id]) == len(map_data.segments.items())
- and all(k in self._previous_cleaning_sequence[map_data.map_id] for k in map_data.segments.keys())
- ):
- cleaning_sequence = self.set_cleaning_sequence(self._previous_cleaning_sequence[map_data.map_id])
- del self._previous_cleaning_sequence[map_data.map_id]
- return cleaning_sequence
-
- index = 1
- for k in sorted(map_data.segments.keys()):
- if not map_data.segments[k].order:
- map_data.segments[k].order = index
- map_data.cleanset[str(k)][3] = map_data.segments[k].order
- index = index + 1
+ cleaning_sequence_v2 = self.map_manager._capability.cleaning_sequence_v2
+ if not order and cleaning_sequence_v2:
+ order = max([v.order for v in map_data.segments.values() if v.order]) + 1
+ if order > 0:
current_order = map_data.segments[segment_id].order
if current_order != order:
map_data.segments[segment_id].order = order
- map_data.cleanset[str(segment_id)][3] = order
+ if not cleaning_sequence_v2:
+ map_data.cleanset[str(segment_id)][3] = order
for k, v in map_data.segments.items():
if k != segment_id and v.order == order:
- map_data.segments[k].order = current_order
- map_data.cleanset[str(k)][3] = map_data.segments[k].order
+ map_data.segments[k].order = (
+ (len(self.map_manager.cleaning_sequence) + 1) if not current_order else current_order
+ )
else:
- for v in map_data.segments.values():
- if v.order:
- self._previous_cleaning_sequence[map_data.map_id] = [
- (k) for k, v in sorted(map_data.segments.items(), key=lambda s: s[1].order) if v.order
- ]
- break
+ map_data.segments[segment_id].order = 0
- for k in map_data.segments.keys():
- map_data.segments[k].order = 0
+ index = 1
+ for k in self.map_manager.cleaning_sequence:
+ if map_data.segments[k].order or cleaning_sequence_v2:
+ map_data.segments[k].order = index
+ if not cleaning_sequence_v2:
+ map_data.cleanset[str(k)][3] = index
+ index = index + 1
+ else:
map_data.cleanset[str(k)][3] = 0
- if self._saved_map_data and map_data.map_id in self._saved_map_data:
- self._saved_map_data[map_data.map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if cleaning_sequence_v2:
+ map_data.cleaning_sequence = {
+ str(k): map_data.segments[k].order
+ for k in sorted(map_data.segments.keys(), key=lambda k: map_data.segments[k].id)
+ }
- self._set_updated_frame_id(map_data.frame_id + 1)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ if cleaning_sequence_v2:
+ self._saved_map_data[self._selected_map_id].cleaning_sequence = map_data.cleaning_sequence.copy()
+ else:
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+
+ self._set_updated_frame_id(map_data.frame_id)
self.refresh_map()
- return [(k) for k, v in sorted(map_data.segments.items(), key=lambda s: s[1].order) if v.order]
- def cleanset(self, map_data: MapData) -> list[list[int]] | None:
- cleanset = []
- for k, v in map_data.segments.items():
- if v.suction_level is None:
- v.suction_level = 1
- if v.water_volume is None:
- v.water_volume = 2
- if v.cleaning_times is None:
- v.cleaning_times = 1
+ return self.map_manager.cleaning_sequence
- settings = [
- k,
- v.suction_level,
- v.water_volume + 1,
- v.cleaning_times,
- ]
+ def set_floor_material(self, floor_material: dict[str, list], map_id) -> Any:
+ if self._saved_map_data and map_id in self._saved_map_data:
+ map_data = self._saved_map_data[map_id]
+ if map_data.segments and not self._map_data.temporary_map:
+ carpet_type = {}
+ for segment_id in map_data.segments.keys():
+ key = str(segment_id)
+ if key in floor_material and len(floor_material[key]) == 2:
+ map_data.segments[segment_id].floor_material = floor_material[key][0]
+ if self.map_manager._capability.floor_direction_cleaning and floor_material[key][0] == 1:
+ map_data.segments[segment_id].floor_material_direction = floor_material[key][1]
+ map_data.segments[segment_id].floor_material_rotated_direction = (
+ floor_material[key][1]
+ if map_data.rotation == 0 or map_data.rotation == 180
+ else 90 if floor_material[key][1] == 0 else 0
+ )
+ else:
+ map_data.segments[segment_id].floor_material_direction = None
+ map_data.segments[segment_id].floor_material_rotated_direction = None
+ else:
+ map_data.segments[segment_id].floor_material = 0
+ map_data.segments[segment_id].floor_material_direction = None
+ map_data.segments[segment_id].floor_material_rotated_direction = None
- if v.cleaning_mode is not None:
- settings.append(v.cleaning_mode)
+ DreameVacuumMapDecoder.set_segment_floor_material(
+ map_data, segment_id, map_data.floor_material, self.map_manager._capability
+ )
- cleanset.append(settings)
- return cleanset
+ if self._map_data and map_id == self._selected_map_id:
+ map_data = self._map_data
+ if map_data.segments:
+ for segment_id in map_data.segments.keys():
+ key = str(segment_id)
+ if key in floor_material and len(floor_material[key]) == 2:
+ material = floor_material[key][0]
+ if (
+ self.map_manager._capability.carpet_material
+ and map_data.segments[segment_id].floor_material != material
+ and (
+ (material >= 5 and material <= 6)
+ or (
+ map_data.segments[segment_id].floor_material >= 5
+ and map_data.segments[segment_id].floor_material <= 6
+ and material == 7
+ )
+ )
+ ):
+ carpet_type[segment_id] = material
+ if map_data.carpet_cleanset is not None and not (
+ map_data.segments[segment_id].carpet_cleaning == 0
+ or map_data.segments[segment_id].carpet_cleaning is None
+ or map_data.segments[segment_id].carpet_cleaning > 0
+ ):
+ if material == 7 or not self.map_manager._capability.mop_pad_unmounting:
+ map_data.segments[segment_id].carpet_cleaning = 2
+ elif material == 5:
+ map_data.segments[segment_id].carpet_cleaning = 1
+ elif material == 6:
+ map_data.segments[segment_id].carpet_cleaning = 3
+
+ for cleanset in map_data.carpet_cleanset:
+ if cleanset[0] == 2 and cleanset[1] == segment_id:
+ cleanset[2] = map_data.segments[segment_id].carpet_cleaning
+
+ map_data.segments[segment_id].floor_material = material
+ if self.map_manager._capability.floor_direction_cleaning and material == 1:
+ map_data.segments[segment_id].floor_material_direction = floor_material[key][1]
+ map_data.segments[segment_id].floor_material_rotated_direction = (
+ floor_material[key][1]
+ if map_data.rotation == 0 or map_data.rotation == 180
+ else 90 if floor_material[key][1] == 0 else 0
+ )
+ else:
+ map_data.segments[segment_id].floor_material_direction = None
+ map_data.segments[segment_id].floor_material_rotated_direction = None
+ else:
+ map_data.segments[segment_id].floor_material = 0
+ map_data.segments[segment_id].floor_material_direction = None
+ map_data.segments[segment_id].floor_material_rotated_direction = None
+
+ DreameVacuumMapDecoder.set_segment_floor_material(
+ map_data,
+ segment_id,
+ map_data.floor_material,
+ self.map_manager._capability,
+ )
- def set_segment_suction_level(self, segment_id: int, suction_level: int) -> list[list[int]] | None:
- map_data = self._map_data
- if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
- map_data.segments[segment_id].suction_level = suction_level
- map_data.cleanset[str(segment_id)][0] = suction_level
- if self._saved_map_data and map_data.map_id in self._saved_map_data:
- self._saved_map_data[map_data.map_id].cleanset = copy.deepcopy(map_data.cleanset)
- self._set_updated_frame_id(map_data.frame_id + 1)
- self.refresh_map()
- return self.cleanset(map_data)
+ self._saved_map_data[map_id].carpet_cleanset = map_data.carpet_cleanset.copy()
+ DreameVacuumMapDecoder.set_carpet_cleanset(
+ self._saved_map_data[map_id],
+ self._saved_map_data[map_id].carpet_cleanset,
+ self.map_manager._capability,
+ )
- def set_segment_water_volume(self, segment_id: int, water_volume: int) -> list[list[int]] | None:
- map_data = self._map_data
- if map_data and map_data.segments and segment_id in map_data.segments:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+
+ self.refresh_map(map_id)
+
+ return {
+ str(k): (
+ {
+ "material": v.floor_material,
+ "direction": v.floor_material_direction,
+ }
+ if v.floor_material_direction is not None
+ and self.map_manager._capability.floor_direction_cleaning
+ else {
+ "material": v.floor_material if k not in carpet_type else 6 if carpet_type[k] == 7 else 7
+ }
+ )
+ for k, v in self._saved_map_data[map_id].segments.items()
+ }, ([[k, v] for k, v in carpet_type.items()] if carpet_type else None)
+ return {}, None
+
+ def set_hidden_segments(self, hidden_segments, map_id):
+ if self._saved_map_data and map_id in self._saved_map_data:
+ map_data = self._saved_map_data[map_id]
+ if map_data.segments and not self._map_data.temporary_map:
+ for segment_id, segment in map_data.segments.items():
+ segment.visibility = segment_id not in hidden_segments
+ if not segment.visibility:
+ segment.order = None
+
+ if self._map_data and map_id == self._selected_map_id:
+ if segment.visibility and segment_id not in self._map_data.segments:
+ self._map_data.segments[segment_id] = copy.deepcopy(segment)
+
+ hidden_segments = [k for k, v in map_data.segments.items() if v.visibility == False]
+ hidden_segments.sort()
+ map_data.hidden_segments = hidden_segments
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+
+ if self._map_data and map_id == self._selected_map_id:
+ map_data = self._map_data
+ if map_data.segments:
+ map_data.hidden_segments = hidden_segments
+ for segment_id, segment in map_data.segments.items():
+ segment.visibility = segment_id not in hidden_segments
+ if not segment.visibility:
+ segment.order = None
+
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ self.refresh_map(map_id)
+ return hidden_segments
+ return []
+
+ def set_mop_type(self, mop_type, map_id):
+ if self._saved_map_data and map_id in self._saved_map_data:
+ map_data = self._saved_map_data[map_id]
+ if map_data.segments and not self._map_data.temporary_map:
+ for segment_id, segment in map_data.segments.items():
+ if segment_id in mop_type and mop_type[segment_id]:
+ mop = mop_type[segment_id].upper()
+ if mop == "A" or mop == "B" or mop == "C":
+ segment.mop_type = mop
+
+ mop_types = {
+ str(k): (1 if v.mop_type == "C" else 2 if v.mop_type == "B" else 3)
+ for k, v in dict(sorted(map_data.segments.items())).items()
+ }
+ map_data.mop_type = mop_types
+
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+
+ if self._map_data and map_id == self._selected_map_id:
+ map_data = self._map_data
+ if map_data.segments:
+ map_data.mop_type = mop_types
+ for segment_id, segment in map_data.segments.items():
+ if segment_id in mop_type and mop_type[segment_id]:
+ mop = mop_type[segment_id].upper()
+ if mop == "A" or mop == "B" or mop == "C":
+ segment.mop_type = mop
+
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ self.refresh_map(map_id)
+ return mop_types
+ return {}
+
+ def set_segment_type(self, segment_type, map_id):
+ if self._saved_map_data and map_id in self._saved_map_data:
+ map_data = self._saved_map_data[map_id]
+ if map_data.segments and not self._map_data.temporary_map:
+ segment_info = {}
+ for segment_id, segment in map_data.segments.items():
+ segment_id = str(segment_id)
+ if segment_id in segment_type and len(segment_type[segment_id]) == 3:
+ segment.type = segment_type[segment_id][0]
+ segment.index = segment_type[segment_id][1]
+ segment.custom_name = segment_type[segment_id][2]
+ else:
+ segment.type = 0
+ segment.index = 0
+ segment.custom_name = None
+
+ if segment.custom_name:
+ segment_info[segment_id] = {
+ MAP_PARAMETER_NAME: base64.b64encode(segment.custom_name.encode("utf-8")).decode("utf-8"),
+ MAP_REQUEST_PARAMETER_TYPE: 0,
+ MAP_REQUEST_PARAMETER_INDEX: 0,
+ }
+ elif segment.type:
+ segment_info[segment_id] = {
+ MAP_REQUEST_PARAMETER_TYPE: segment.type,
+ MAP_REQUEST_PARAMETER_INDEX: segment.index,
+ }
+ else:
+ segment_info[segment_id] = {}
+
+ if segment.unique_id:
+ segment_info[segment_id][MAP_REQUEST_PARAMETER_ROOM_ID] = segment.unique_id
+
+ if self._map_data and map_id == self._selected_map_id:
+ map_data = self._map_data
+ if map_data.segments:
+ for segment_id, segment in map_data.segments.items():
+ segment_id = str(segment_id)
+ if segment_id in segment_type and len(segment_type[segment_id]) == 3:
+ segment.type = segment_type[segment_id][0]
+ segment.index = segment_type[segment_id][1]
+ segment.custom_name = segment_type[segment_id][2]
+ else:
+ segment.type = 0
+ segment.index = 0
+ segment.custom_name = None
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+
+ self.refresh_map(map_id)
+ return segment_info
+ return {}
+
+ def cleanset(self, map_data: MapData) -> list[list[int]] | None:
+ cleanset = []
+ for k, v in map_data.segments.items():
+ if v.suction_level is None:
+ v.suction_level = 1
+ if v.water_volume is None:
+ v.water_volume = 2
+ if v.cleaning_times is None:
+ v.cleaning_times = 1
+
+ settings = [
+ k,
+ v.suction_level,
+ v.wetness_level if v.wetness_level != None else v.water_volume + 1,
+ v.cleaning_times,
+ ]
+
+ if self.map_manager._capability.custom_cleaning_mode:
+ settings.append(v.cleaning_mode if v.cleaning_mode is not None else 2)
+
+ if (
+ self.map_manager._capability.cleaning_route
+ or self.map_manager._capability.segment_mopping_type
+ or self.map_manager._capability.segment_mopping_settings
+ ):
+ settings.append(v.mopping_settings if v.mopping_settings else 0)
+
+ if self.map_manager._capability.mop_temperature:
+ settings.append(v.mop_temperature if v.mop_temperature is not None else 0)
+
+ if self.map_manager._capability.mop_pressure:
+ if len(settings) == 6:
+ settings.extend([0, 0])
+ elif len(settings) == 7:
+ settings.append(0)
+
+ settings.append(v.mop_pressure if v.mop_pressure is not None else 1)
+
+ cleanset.append(settings)
+ return cleanset
+
+ def set_carpet_cleanset(self, carpet_cleanset: list[list[int]]) -> None:
+ DreameVacuumMapDecoder.set_carpet_cleanset(self._map_data, carpet_cleanset, self.map_manager._capability)
+ self._map_data.carpet_cleanset = carpet_cleanset
+ self._set_updated_frame_id(self._map_data.frame_id)
+ self.refresh_map()
+
+ def set_custom_carpet_settings(self, carpet_cleanset: list[list[int]]) -> None:
+ map_data = self._map_data
+ if map_data is not None and map_data.carpet_cleanset:
+ cleanset = []
+ new_carpet_cleanset = map_data.carpet_cleanset.copy()
+ for selected_carpet in carpet_cleanset:
+ for carpet in new_carpet_cleanset:
+ if carpet[0] == selected_carpet[0] and carpet[1] == selected_carpet[1]:
+ if len(carpet) > 3:
+ carpet[3] = selected_carpet[3]
+ cleanset.append(carpet.copy())
+ break
+ self.set_carpet_cleanset(new_carpet_cleanset)
+ carpet_cleanset = cleanset
+ return carpet_cleanset
+
+ def set_custom_carpet_cleaning(self, carpet_cleanset: list[list[int]]) -> None:
+ map_data = self._map_data
+ if map_data is not None and map_data.carpet_cleanset:
+ cleanset = []
+ new_carpet_cleanset = map_data.carpet_cleanset.copy()
+ for selected_carpet in carpet_cleanset:
+ for carpet in new_carpet_cleanset:
+ if carpet[0] == selected_carpet[0] and carpet[1] == selected_carpet[1]:
+ carpet[2] = selected_carpet[2]
+ item = [carpet[0], carpet[1], carpet[2]]
+ if len(carpet) > 3 and self.map_manager._capability.carpet_cleanset_v3:
+ if (
+ carpet[2] == -1
+ or len(selected_carpet) < 4
+ or selected_carpet[3] == -1
+ or selected_carpet[3] is None
+ ):
+ carpet[3] = -1
+ else:
+ carpet[3] = selected_carpet[3]
+ item.append(carpet[3])
+ cleanset.append(item)
+ break
+ self.set_carpet_cleanset(new_carpet_cleanset)
+ carpet_cleanset = cleanset
+ return carpet_cleanset
+
+ def set_segment_suction_level(
+ self, segment_id: int, suction_level: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
+ map_data.segments[segment_id].suction_level = suction_level
+ map_data.cleanset[str(segment_id)][0] = suction_level
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_water_volume(
+ self, segment_id: int, water_volume: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments:
map_data.segments[segment_id].water_volume = water_volume
map_data.cleanset[str(segment_id)][1] = water_volume + 1
- if self._saved_map_data and map_data.map_id in self._saved_map_data:
- self._saved_map_data[map_data.map_id].cleanset = copy.deepcopy(map_data.cleanset)
- self._set_updated_frame_id(map_data.frame_id + 1)
- self.refresh_map()
- return self.cleanset(map_data)
+ if map_data.segments[segment_id].custom_mopping_route is not None:
+ values = DreameVacuumMapDecoder.split_mopping_settings(map_data.segments[segment_id].mopping_settings)
+ if values:
+ # Set mopping mode or water volume according to the mopping effect switch
+ values[2 if map_data.segments[segment_id].custom_mopping_route == -1 else 1] = water_volume
+ map_data.segments[segment_id].mopping_settings = DreameVacuumMapDecoder.combine_mopping_settings(
+ values
+ )
+ map_data.cleanset[str(segment_id)][5] = map_data.segments[segment_id].mopping_settings
+
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_wetness_level(
+ self, segment_id: int, wetness_level: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments:
+ wetness_level = int(wetness_level)
+ map_data.cleanset[str(segment_id)][1] = wetness_level
+ map_data.segments[segment_id].wetness_level = wetness_level
+
+ if wetness_level > (14 if self.map_manager._capability.mop_clean_frequency else 26):
+ map_data.segments[segment_id].water_volume = 3
+ elif wetness_level < 6:
+ map_data.segments[segment_id].water_volume = 1
+ else:
+ map_data.segments[segment_id].water_volume = 2
+
+ if map_data.segments[segment_id].custom_mopping_route is not None:
+ map_data.segments[segment_id].custom_mopping_route = 0
+
+ values = DreameVacuumMapDecoder.split_mopping_settings(map_data.segments[segment_id].mopping_settings)
+ if values:
+ values[1] = 0
+ values[2] = 0
+ map_data.segments[segment_id].mopping_settings = DreameVacuumMapDecoder.combine_mopping_settings(
+ values
+ )
+ map_data.cleanset[str(segment_id)][5] = map_data.segments[segment_id].mopping_settings
+
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
- def set_segment_cleaning_times(self, segment_id: int, cleaning_times: int) -> list[list[int]] | None:
+ def set_segment_cleaning_times(
+ self, segment_id: int, cleaning_times: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
map_data = self._map_data
if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
map_data.segments[segment_id].cleaning_times = cleaning_times
map_data.cleanset[str(segment_id)][2] = cleaning_times
- if self._saved_map_data and map_data.map_id in self._saved_map_data:
- self._saved_map_data[map_data.map_id].cleanset = copy.deepcopy(map_data.cleanset)
- self._set_updated_frame_id(map_data.frame_id + 1)
- self.refresh_map()
- return self.cleanset(map_data)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
- def set_segment_cleaning_mode(self, segment_id: int, cleaning_mode: int) -> list[list[int]] | None:
+ def set_segment_cleaning_mode(
+ self, segment_id: int, cleaning_mode: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
map_data = self._map_data
- if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
+ if (
+ map_data
+ and map_data.segments
+ and segment_id in map_data.segments
+ and not map_data.temporary_map
+ and map_data.segments[segment_id].cleaning_mode is not None
+ ):
map_data.segments[segment_id].cleaning_mode = cleaning_mode
map_data.cleanset[str(segment_id)][4] = cleaning_mode
- if self._saved_map_data and map_data.map_id in self._saved_map_data:
- self._saved_map_data[map_data.map_id].cleanset = copy.deepcopy(map_data.cleanset)
- self._set_updated_frame_id(map_data.frame_id + 1)
- self.refresh_map()
- return self.cleanset(map_data)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_custom_mopping_route(
+ self, segment_id: int, custom_mopping_route: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments:
+ if map_data.segments[segment_id].custom_mopping_route is not None:
+ map_data.segments[segment_id].custom_mopping_route = custom_mopping_route
+ values = DreameVacuumMapDecoder.split_mopping_settings(map_data.segments[segment_id].mopping_settings)
+ if values:
+ # Set mopping effect switch or cleaning route
+ if map_data.segments[segment_id].custom_mopping_route == -1:
+ values[2] = map_data.segments[segment_id].water_volume
+ map_data.segments[segment_id].cleaning_route = 1 if values[2] == 2 else values[2]
+ else:
+ values[2] = 0
+ values[0] = custom_mopping_route + 1
+ map_data.segments[segment_id].cleaning_route = values[0]
+
+ map_data.segments[segment_id].mopping_settings = DreameVacuumMapDecoder.combine_mopping_settings(
+ values
+ )
+ map_data.cleanset[str(segment_id)][5] = map_data.segments[segment_id].mopping_settings
+
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_cleaning_route(
+ self, segment_id: int, cleaning_route: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments:
+ if map_data.segments[segment_id].cleaning_route is not None:
+ map_data.segments[segment_id].cleaning_route = cleaning_route
+ values = DreameVacuumMapDecoder.split_mopping_settings(map_data.segments[segment_id].mopping_settings)
+ if values:
+ values[2] = 0
+ values[0] = cleaning_route
+ map_data.segments[segment_id].custom_mopping_route = values[2] - 1
+ map_data.segments[segment_id].mopping_settings = DreameVacuumMapDecoder.combine_mopping_settings(
+ values
+ )
+ map_data.cleanset[str(segment_id)][5] = map_data.segments[segment_id].mopping_settings
+
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_mop_temperature(
+ self, segment_id: int, mop_temperature: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
+ map_data.segments[segment_id].mop_temperature = mop_temperature
+ map_data.cleanset[str(segment_id)][6] = mop_temperature
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_mop_pressure(
+ self, segment_id: int, mop_pressure: int, refresh_map: bool = True
+ ) -> list[list[int]] | None:
+ map_data = self._map_data
+ if map_data and map_data.segments and segment_id in map_data.segments and not map_data.temporary_map:
+ map_data.segments[segment_id].mop_pressure = mop_pressure
+ map_data.cleanset[str(segment_id)][7] = mop_pressure
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].cleanset = copy.deepcopy(map_data.cleanset)
+ if refresh_map:
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return self.cleanset(map_data)
+
+ def set_segment_floor_material(
+ self, segment_id: int, floor_material: int, direction: int = None
+ ) -> list[list[int]] | None:
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ map_data = self._saved_map_data[self._selected_map_id]
+ if map_data and map_data.segments:
+ if direction is not None:
+ if floor_material != 1:
+ direction = None
+ elif map_data.rotation == 90 or map_data.rotation == 270:
+ direction = 0 if direction else 90
+
+ carpet_type = {}
+ if segment_id in map_data.segments:
+ if (
+ self.map_manager._capability.carpet_material
+ and map_data.segments[segment_id].floor_material != floor_material
+ and (
+ (floor_material >= 5 and floor_material <= 6)
+ or (
+ map_data.segments[segment_id].floor_material >= 5
+ and map_data.segments[segment_id].floor_material <= 6
+ and floor_material == 7
+ )
+ )
+ ):
+ carpet_type[segment_id] = floor_material
+
+ map_data.segments[segment_id].floor_material = floor_material
+ map_data.segments[segment_id].floor_material_direction = direction
+ if direction is not None:
+ map_data.segments[segment_id].floor_material_rotated_direction = (
+ direction
+ if map_data.rotation == 0 or map_data.rotation == 180
+ else 90 if direction == 0 else 0
+ )
+ else:
+ map_data.segments[segment_id].floor_material_rotated_direction = None
+ DreameVacuumMapDecoder.set_segment_floor_material(
+ map_data,
+ segment_id,
+ map_data.floor_material,
+ self.map_manager._capability,
+ )
+ self.refresh_map(self._selected_map_id)
+
+ map_data = self._map_data
+ if map_data and not map_data.temporary_map and map_data.segments and segment_id in map_data.segments:
+ map_data.segments[segment_id].floor_material = floor_material
+ map_data.segments[segment_id].floor_material_direction = direction
+ if direction is not None:
+ map_data.segments[segment_id].floor_material_rotated_direction = (
+ direction
+ if map_data.rotation == 0 or map_data.rotation == 180
+ else 90 if direction == 0 else 0
+ )
+ else:
+ map_data.segments[segment_id].floor_material_rotated_direction = None
+
+ DreameVacuumMapDecoder.set_segment_floor_material(
+ map_data,
+ segment_id,
+ map_data.floor_material,
+ self.map_manager._capability,
+ )
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+
+ return {
+ str(k): (
+ {
+ "material": v.floor_material,
+ "direction": v.floor_material_direction,
+ }
+ if v.floor_material_direction is not None
+ and self.map_manager._capability.floor_direction_cleaning
+ else {
+ "material": v.floor_material if k not in carpet_type else 6 if carpet_type[k] == 7 else 7
+ }
+ )
+ for k, v in self._saved_map_data[self._selected_map_id].segments.items()
+ }, ([[k, v] for k, v in carpet_type.items()] if carpet_type else None)
+ return {}, None
+
+ def set_segment_visibility(self, segment_id: int, visibility: int) -> list[list[int]] | None:
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ map_data = self._saved_map_data[self._selected_map_id]
+ if map_data and map_data.segments:
+ if segment_id in map_data.segments:
+ map_data.segments[segment_id].visibility = visibility
+ if not visibility:
+ map_data.segments[segment_id].order = None
+ if map_data.segments[segment_id] and segment_id not in self._map_data.segments:
+ self._map_data.segments[segment_id] = copy.deepcopy(map_data.segments[segment_id])
+
+ hidden_segments = [k for k, v in map_data.segments.items() if v.visibility == False]
+ hidden_segments.sort()
+ map_data.hidden_segments = hidden_segments
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+ self.refresh_map(self._selected_map_id)
+
+ map_data = self._map_data
+ if map_data and map_data.segments and not map_data.temporary_map:
+ map_data.hidden_segments = hidden_segments
+ if segment_id in map_data.segments:
+ map_data.segments[segment_id].visibility = visibility
+ if not visibility:
+ map_data.segments[segment_id].order = None
+
+ DreameVacuumMapDecoder.set_segment_cleanset(
+ map_data,
+ map_data.cleanset,
+ self.map_manager._capability,
+ )
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return hidden_segments
+ return []
+
+ def set_segment_mop_type(self, segment_id: int, mop_type: str) -> dict[str, int] | None:
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ map_data = self._saved_map_data[self._selected_map_id]
+ if map_data and map_data.segments:
+ if segment_id in map_data.segments:
+ map_data.segments[segment_id].mop_type = mop_type
+
+ mop_types = {
+ str(k): (1 if v.mop_type == "C" else 2 if v.mop_type == "B" else 3)
+ for k, v in dict(sorted(map_data.segments.items())).items()
+ }
+ map_data.mop_type = mop_types
+ self.refresh_map(self._selected_map_id)
+
+ map_data = self._map_data
+ if map_data and map_data.segments and not map_data.temporary_map:
+ map_data.mop_type = mop_types
+ if segment_id in map_data.segments:
+ map_data.segments[segment_id].mop_type = mop_type
+
+ self._set_updated_frame_id(map_data.frame_id)
+ self.refresh_map()
+ return mop_types
+ return {}
def set_segment_name(self, segment_id: int, segment_type: int, custom_name: str = None) -> dict[str, Any] | None:
map_data = self._map_data
@@ -1645,30 +3442,28 @@ def set_segment_name(self, segment_id: int, segment_type: int, custom_name: str
self.refresh_map(self._selected_map_id)
for k, v in map_data.segments.items():
- if map_data.segments[k].custom_name is not None:
+ if v.custom_name is not None:
segment_info[k] = {
- MAP_PARAMETER_NAME: base64.b64encode(
- map_data.segments[k].custom_name.encode("utf-8")
- ).decode("utf-8"),
+ MAP_PARAMETER_NAME: base64.b64encode(v.custom_name.encode("utf-8")).decode("utf-8"),
MAP_REQUEST_PARAMETER_TYPE: 0,
MAP_REQUEST_PARAMETER_INDEX: 0,
}
- elif map_data.segments[k].type:
+ elif v.type:
segment_info[k] = {
- MAP_REQUEST_PARAMETER_TYPE: map_data.segments[k].type,
- MAP_REQUEST_PARAMETER_INDEX: map_data.segments[k].index,
+ MAP_REQUEST_PARAMETER_TYPE: v.type,
+ MAP_REQUEST_PARAMETER_INDEX: v.index,
}
else:
segment_info[k] = {}
- if map_data.segments[k].unique_id:
- segment_info[k][MAP_REQUEST_PARAMETER_ROOM_ID] = map_data.segments[k].unique_id
+ if v.unique_id:
+ segment_info[k][MAP_REQUEST_PARAMETER_ROOM_ID] = v.unique_id
- self._set_updated_frame_id(map_data.frame_id + 1)
+ self._set_updated_frame_id(map_data.frame_id)
self.refresh_map()
return segment_info
- def set_zones(self, walls, no_go_areas, no_mopping_areas) -> None:
+ def set_zones(self, virtual_walls, no_go_areas, no_mopping_areas) -> None:
map_data = self._map_data
if not map_data or not self._selected_map_id:
return
@@ -1709,24 +3504,29 @@ def set_zones(self, walls, no_go_areas, no_mopping_areas) -> None:
)
)
- if walls:
- map_data.walls = [
+ if virtual_walls:
+ map_data.virtual_walls = [
Wall(
wall[0],
wall[1],
wall[2],
wall[3],
)
- for wall in walls
+ for wall in virtual_walls
]
else:
- map_data.walls = []
+ map_data.virtual_walls = []
- self._saved_map_data[self._selected_map_id].no_go_areas = map_data.no_go_areas
- self._saved_map_data[self._selected_map_id].no_mopping_areas = map_data.no_mopping_areas
- self._saved_map_data[self._selected_map_id].walls = map_data.walls
- self._set_updated_frame_id(map_data.frame_id + 1)
- self.refresh_map(self._selected_map_id)
+ self._set_updated_frame_id(map_data.frame_id)
+ if (
+ self._saved_map_data
+ and self._selected_map_id is not None
+ and self._selected_map_id in self._saved_map_data
+ ):
+ self._saved_map_data[self._selected_map_id].no_go_areas = map_data.no_go_areas
+ self._saved_map_data[self._selected_map_id].no_mopping_areas = map_data.no_mopping_areas
+ self._saved_map_data[self._selected_map_id].virtual_walls = map_data.virtual_walls
+ self.refresh_map(self._selected_map_id)
self.refresh_map()
@property
@@ -1775,7 +3575,7 @@ def _compare_segment_neighbors(r1: Segment, r2: Segment) -> bool:
blen = len(r2.neighbors)
if alen == blen:
- return r1.segment_id - r2.segment_id
+ return r1.id - r2.id
return blen - alen
@@ -1784,50 +3584,55 @@ def _compare_colors(c1: list[int], c2: list[int]) -> bool:
return c1[1] - c2[1] if c1[1] != c2[1] else c1[0] - c2[0]
@staticmethod
- def _get_pixel_type(map_data: MapData, pixel, vslam_map: bool = False) -> MapPixelType:
+ def _get_pixel_type(map_data: MapData, pixel, vslam_map: bool = False) -> tuple[MapPixelType, bool]:
if map_data.frame_map:
+ carpet = bool((pixel & 0x03) == 3)
segment_id = pixel >> 2
if 0 < segment_id < 64:
if segment_id == 63:
- return MapPixelType.WALL.value
+ return (MapPixelType.WALL.value, carpet)
if segment_id == 62:
- return MapPixelType.FLOOR.value
+ return (MapPixelType.FLOOR.value, carpet)
if segment_id == 61:
- return MapPixelType.UNKNOWN.value
- return segment_id
+ return (MapPixelType.UNKNOWN.value, carpet)
+ return (segment_id, carpet)
- segment_id = pixel & 0x3F
+ segment_id = pixel & 0x03
# as implemented on the app
if segment_id == 1 or segment_id == 3:
- return MapPixelType.NEW_SEGMENT.value
+ return (MapPixelType.NEW_SEGMENT.value, carpet)
if segment_id == 2:
- return MapPixelType.WALL.value
+ return (MapPixelType.WALL.value, carpet)
elif vslam_map:
- segment_id = pixel & 0b01111111
- if segment_id == 1:
- return MapPixelType.NEW_SEGMENT.value
- elif segment_id == 3:
- return MapPixelType.NEW_SEGMENT_UNKNOWN.value
+ carpet = bool((pixel & 0x03) == 3)
+ segment_id = pixel & 0x7F
+ if segment_id == 1 or segment_id == 3:
+ return (MapPixelType.NEW_SEGMENT.value, carpet)
elif segment_id == 2:
- return MapPixelType.WALL.value
+ return (MapPixelType.WALL.value, carpet)
else:
+ carpet = bool((pixel & 0x40) == 64)
+ segment_id = pixel & 0x3F
if pixel >> 7:
- return MapPixelType.WALL.value
+ return (
+ (100 + segment_id) if segment_id else MapPixelType.WALL.value,
+ carpet,
+ )
- segment_id = pixel & 0x3F
+ # carpet = bool(pixel & 0x03 == 3)
if segment_id > 0:
if map_data.saved_map_status == 1 or map_data.saved_map_status == 0:
# as implemented on the app
if segment_id == 1 or segment_id == 3:
- return MapPixelType.NEW_SEGMENT.value
+ return (MapPixelType.NEW_SEGMENT.value, carpet)
if segment_id == 2:
- return MapPixelType.WALL.value
- return MapPixelType.OUTSIDE.value
+ return (MapPixelType.WALL.value, carpet)
+ return (MapPixelType.OUTSIDE.value, False)
- return segment_id
+ return (segment_id, carpet)
- return MapPixelType.OUTSIDE.value
+ return (MapPixelType.OUTSIDE.value, False)
@staticmethod
def _get_segment_center(map_data, segment_id: int, center: int, vertical: bool) -> int | None:
@@ -1877,9 +3682,52 @@ def _get_segment_center(map_data, segment_id: int, center: int, vertical: bool)
return None
@staticmethod
- def decode_map_partial(raw_map, iv=None, key=None) -> MapDataPartial | None:
- _LOGGER.debug("raw_map: %s", raw_map)
- raw_map = raw_map.replace("_", "/").replace("-", "+")
+ def _find_px_type(x, y, map_data: MapData) -> int:
+ pixel_type = map_data.pixel_type
+ dimensions = map_data.dimensions
+ if map_data.combined_pixel_type is not None:
+ pixel_type = map_data.combined_pixel_type
+ dimensions = map_data.combined_dimensions
+ x = int((x - dimensions.left) / dimensions.grid_size)
+ y = int((y - dimensions.top) / dimensions.grid_size)
+
+ directions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
+
+ def find(xx, yy, distance, steps):
+ if steps > 50:
+ return 0
+
+ for dx, dy in directions:
+ nx = xx + dx * distance
+ ny = yy + dy * distance
+ if 0 <= nx < pixel_type.shape[0] - 1 and 0 <= ny < pixel_type.shape[1] - 1:
+ px = pixel_type[nx, ny]
+ if px is not None:
+ if 100 < px < 200:
+ px -= 100
+ if px != 255 and px != 0:
+ return int(px)
+ return find(xx, yy, distance + 1, steps + 1)
+
+ if 0 <= x < pixel_type.shape[0] - 1 and 0 <= y < pixel_type.shape[1] - 1:
+ px = pixel_type[x, y]
+ if px is not None:
+ if 100 < px < 200:
+ px -= 100
+ if px == 255 or px == 0:
+ return find(x, y, 1, 1)
+ else:
+ return int(px)
+
+ return find(x, y, 1, 1)
+
+ @staticmethod
+ def decode_map_partial(raw_data, iv=None, key=None) -> MapDataPartial | None:
+ _LOGGER.debug("raw_map: %s", raw_data)
+ raw_map = raw_data.replace("_", "/").replace("-", "+")
+
+ if len(raw_map) < 3:
+ return None
if "," in raw_map and key is None:
values = raw_map.split(",")
@@ -1892,8 +3740,11 @@ def decode_map_partial(raw_map, iv=None, key=None) -> MapDataPartial | None:
if iv is None:
iv = ""
try:
- key = hashlib.sha256(key.encode()).hexdigest()[0:32].encode("utf8")
- cipher = Cipher(algorithms.AES(key), modes.CBC(iv.encode("utf8")), backend=default_backend())
+ cipher = Cipher(
+ algorithms.AES(hashlib.sha256(key.encode()).hexdigest()[0:32].encode("utf8")),
+ modes.CBC(iv.encode("utf8")),
+ backend=default_backend(),
+ )
decryptor = cipher.decryptor()
raw_map = decryptor.update(raw_map) + decryptor.finalize()
except Exception as ex:
@@ -1908,7 +3759,7 @@ def decode_map_partial(raw_map, iv=None, key=None) -> MapDataPartial | None:
_LOGGER.error("Wrong header size for map")
return None
except Exception as ex:
- _LOGGER.error("Map data decompression failed: %s", ex)
+ _LOGGER.error("Map data decompression failed: %s\n%s", ex, raw_data)
return None
partial_map = MapDataPartial()
@@ -1932,10 +3783,16 @@ def decode_map_partial(raw_map, iv=None, key=None) -> MapDataPartial | None:
@staticmethod
def decode_map(
- raw_map: str, vslam_map: bool, rotation: int = 0, iv: str = None, key: str = None
+ raw_map: str,
+ vslam_map: bool,
+ rotation: int = 0,
+ iv: str = None,
+ key: str = None,
) -> Tuple[MapData, Optional[MapData]]:
return DreameVacuumMapDecoder.decode_map_data_from_partial(
- DreameVacuumMapDecoder.decode_map_partial(raw_map, iv, key), vslam_map, rotation
+ DreameVacuumMapDecoder.decode_map_partial(raw_map, iv, key),
+ vslam_map,
+ rotation,
)
@staticmethod
@@ -1974,369 +3831,1079 @@ def decode_map_data_from_partial(
top = DreameVacuumMapDecoder._read_int_16_le(raw, 25)
image_size = DreameVacuumMapDecoder.HEADER_SIZE + width * height
- map_data.dimensions = MapImageDimensions(top, left, height, width, grid_size)
data_json = partial_map.data_json
if data_json is None:
data_json = {}
_LOGGER.debug("Map Data Json: %s", data_json)
- map_data.rotation = rotation
- if "mra" in data_json:
- map_data.rotation = int(data_json["mra"])
-
- if "robot_mode" in data_json:
- map_data.robot_mode = int(data_json["robot_mode"])
-
- if "map_used_times" in data_json:
- map_data.used_times = int(data_json["map_used_times"])
-
- if "cs" in data_json:
- map_data.cleaned_area = int(data_json["cs"])
-
- map_data.docked = bool(data_json.get("oc") and data_json["oc"])
-
- map_data.l2r = bool(data_json.get("l2r") and data_json["l2r"])
- map_data.frame_map = bool(data_json.get("fsm") and data_json["fsm"] == 1)
- map_data.restored_map = bool(data_json.get("rpur") and data_json["rpur"] == 1)
- map_data.saved_map_status = -1
- if "ris" in data_json:
- map_data.saved_map_status = data_json["ris"]
- map_data.clean_log = bool(data_json.get("iscleanlog") and data_json["iscleanlog"] == True)
- map_data.recovery_map = bool(data_json.get("us") and data_json["us"] == 1)
- map_data.new_map = bool("risp" in data_json and data_json["risp"] == 0)
-
- map_data.temporary_map = bool(
- data_json.get("suw") and (data_json["suw"] == 6 or data_json["suw"] == 5) and data_json.get("fsm") is None
- )
- map_data.saved_map = bool(
- map_data.frame_type == MapFrameType.I.value
- and not map_data.restored_map
- and not map_data.frame_map
- and map_data.saved_map_status == -1
- and not map_data.clean_log
- )
+ saved_map_data = None
+ try:
+ if "origin" in data_json and data_json["origin"] and len(data_json["origin"]) > 1:
+ left = data_json["origin"][0]
+ top = data_json["origin"][1]
+
+ map_data.dimensions = MapImageDimensions(top, left, height, width, grid_size)
+
+ map_data.rotation = rotation
+
+ if map_data.frame_type != MapFrameType.W.value:
+ if "mra" in data_json:
+ map_data.rotation = int(data_json["mra"])
+
+ if "cs" in data_json:
+ map_data.cleaned_area = int(data_json["cs"])
+
+ if "ct" in data_json:
+ value = data_json["ct"]
+ if isinstance(value, int) or isinstance(value, float) or isinstance(value, str):
+ map_data.cleaning_time = int(value)
+
+ if "wm" in data_json:
+ map_data.work_status = int(data_json["wm"])
+
+ if "cf" in data_json:
+ map_data.completed = bool(data_json["cf"] == 1)
+
+ if "clean_finish_remain_electricity" in data_json:
+ map_data.remaining_battery = int(data_json["clean_finish_remain_electricity"])
+
+ map_data.customized_cleaning = data_json.get("customeClean")
+ map_data.docked = bool("oc" in data_json and data_json["oc"])
+ map_data.line_to_robot = bool("l2r" in data_json and data_json["l2r"])
+ map_data.frame_map = bool(data_json.get("fsm") and data_json["fsm"] == 1)
+ map_data.restored_map = bool(data_json.get("rpur") and data_json["rpur"] == 1)
+ map_data.saved_map_status = -1
+ if "ris" in data_json:
+ map_data.saved_map_status = data_json["ris"]
+ map_data.clean_log = bool(data_json.get("iscleanlog") and data_json["iscleanlog"] == True)
+ map_data.recovery_map = bool("us" in data_json and data_json["us"] == 1)
+ map_data.new_map = bool("risp" in data_json and data_json["risp"] == 0)
+ if "smd" in data_json:
+ map_data.startup_method = (
+ StartupMethod(data_json["smd"])
+ if data_json["smd"] in StartupMethod._value2member_map_
+ else StartupMethod.OTHER
+ )
+ if "ctyi" in data_json:
+ map_data.task_end_type = (
+ TaskEndType(data_json["ctyi"])
+ if data_json["ctyi"] in TaskEndType._value2member_map_
+ else TaskEndType.OTHER
+ )
+ if "cmc" in data_json:
+ map_data.cleanup_method = (
+ CleanupMethod(data_json["cmc"])
+ if data_json["cmc"] in CleanupMethod._value2member_map_
+ else CleanupMethod.OTHER
+ )
+ if "ds" in data_json:
+ map_data.dust_collection_count = int(data_json.get("ds", 0))
+ if "wt" in data_json:
+ map_data.mop_wash_count = int(data_json.get("wt", 0))
+ map_data.multiple_cleaning_time = data_json.get("multime")
+ map_data.dos = data_json.get("dos")
+ map_data.mopping_mode = data_json.get("mooClean")
+ map_data.temporary_map = bool(
+ data_json.get("suw")
+ and (data_json["suw"] == 6 or data_json["suw"] == 5)
+ and data_json.get("fsm") is None
+ )
+ map_data.saved_map = bool(
+ map_data.frame_type == MapFrameType.I.value
+ and not map_data.restored_map
+ and not map_data.frame_map
+ and map_data.saved_map_status == -1
+ and not map_data.clean_log
+ )
- if (data_json.get("nc") and data_json["nc"]) or map_data.charger_position.a == 32767:
- map_data.charger_position = None
+ if (data_json.get("nc") and data_json["nc"]) or map_data.charger_position.a == 32767:
+ map_data.charger_position = None
- if (data_json.get("nr") and data_json["nr"]) or map_data.robot_position.a == 32767:
- map_data.robot_position = None
+ if (data_json.get("nr") and data_json["nr"]) or map_data.robot_position.a == 32767:
+ map_data.robot_position = None
- if not map_data.saved_map and not map_data.recovery_map:
- map_data.index = 0
+ if not map_data.saved_map and not map_data.recovery_map:
+ map_data.index = 0
- if data_json.get("tr"):
- matches = [
- m.groupdict()
- for m in re.compile(r"(?P[MWSLl])(?P-?\d+),(?P-?\d+)").finditer(data_json["tr"])
- ]
- current_position = Point(0, 0)
- map_data.path = []
- for match in matches:
- operator = match["operator"]
- x = int(match["x"])
- y = int(match["y"])
-
- if operator == "L":
- current_position = Path(current_position.x + x, current_position.y + y, PathType.LINE)
- else:
- # You will only get "l" paths with in a P frame.
- # It means path is connected with the path from previous frame and it should be rendered as a line.
- if operator == "l":
- operator = "L"
- current_position = Path(x, y, PathType(operator))
-
- map_data.path.append(current_position)
-
- if data_json.get("sa") and isinstance(data_json["sa"], list):
- map_data.active_segments = [sa[0] for sa in data_json["sa"]]
-
- if data_json.get("da2"):
- if data_json["da2"].get("areas"):
- map_data.active_areas = []
- for area in data_json["da2"]["areas"]:
- x_coords = sorted([area[0], area[2]])
- y_coords = sorted([area[1], area[3]])
- map_data.active_areas.append(
- Area(
- x_coords[0],
- y_coords[0],
- x_coords[1],
- y_coords[0],
- x_coords[1],
- y_coords[1],
- x_coords[0],
- y_coords[1],
+ if data_json.get("tr"):
+ matches = [
+ m.groupdict()
+ for m in re.compile(r"(?P[MWSLl])(?P-?\d+),(?P-?\d+)").finditer(
+ data_json["tr"]
)
- )
-
- if data_json.get("sp"):
- map_data.active_points = []
- for point in data_json["sp"]:
- map_data.active_points.append(Point(point[0], point[1]))
-
- if "cleanset" in data_json:
- map_data.cleanset = data_json["cleanset"]
- if isinstance(map_data.cleanset, str):
- map_data.cleanset = json.loads(map_data.cleanset)
-
- if "ai_obstacle" in data_json:
- map_data.obstacles = []
- for obstacle in data_json["ai_obstacle"]:
- if len(obstacle) >= 4:
- obstacle_type = int(obstacle[2])
- if obstacle_type in ObstacleType._value2member_map_:
- if len(obstacle) >= 7 and int(obstacle[4]) >= 1000:
- map_data.obstacles.append(
- Obstacle(
- float(obstacle[0]),
- float(obstacle[1]),
- ObstacleType(obstacle_type),
- int(float(obstacle[3]) * 100),
- obstacle[4],
- obstacle[5],
- obstacle[6],
- )
+ ]
+ current_position = Point(0, 0)
+ map_data.path = []
+ for match in matches:
+ operator = match["operator"]
+ x = int(match["x"])
+ y = int(match["y"])
+
+ if operator == "L":
+ current_position = Path(
+ current_position.x + x,
+ current_position.y + y,
+ PathType.LINE,
)
else:
- map_data.obstacles.append(
- Obstacle(
- float(obstacle[0]),
- float(obstacle[1]),
- ObstacleType(obstacle_type),
- int(float(obstacle[3]) * 100),
+ # You will only get "l" paths with in a P frame.
+ # It means path is connected with the path from previous frame and it should be rendered as a line.
+ if operator == "l":
+ operator = "L"
+ current_position = Path(x, y, PathType(operator))
+
+ map_data.path.append(current_position)
+
+ if data_json.get("sa") and isinstance(data_json["sa"], list):
+ map_data.active_segments = [sa[0] for sa in data_json["sa"]]
+
+ if "delsr" in data_json:
+ map_data.hidden_segments = data_json["delsr"]
+
+ if data_json.get("da2"):
+ if data_json["da2"].get("areas"):
+ map_data.active_areas = []
+ for area in data_json["da2"]["areas"]:
+ x_coords = sorted([area[0], area[2]])
+ y_coords = sorted([area[1], area[3]])
+ map_data.active_areas.append(
+ Area(
+ x_coords[0],
+ y_coords[0],
+ x_coords[1],
+ y_coords[0],
+ x_coords[1],
+ y_coords[1],
+ x_coords[0],
+ y_coords[1],
)
)
- map_data.empty_map = map_data.frame_type == MapFrameType.I.value
- if (width * height) > 0:
- map_data.data = raw[DreameVacuumMapDecoder.HEADER_SIZE : image_size]
- map_data.empty_map = bool(width == 2 and height == 2)
- if map_data.empty_map:
- for y in range(height):
- for x in range(width):
- if map_data.data[(width * y) + x] > 0:
- map_data.empty_map = False
- break
+ if data_json.get("sp"):
+ map_data.active_points = []
+ for point in data_json["sp"]:
+ map_data.active_points.append(Point(point[0], point[1]))
+
+ if "cleanset" in data_json:
+ map_data.cleanset = data_json["cleanset"]
+ if isinstance(map_data.cleanset, str):
+ map_data.cleanset = json.loads(map_data.cleanset)
+ map_data.sequence = True
+
+ if "carpetcleanset" in data_json:
+ map_data.carpet_cleanset = data_json["carpetcleanset"]
+ if isinstance(map_data.carpet_cleanset, str):
+ map_data.carpet_cleanset = json.loads(map_data.carpet_cleanset)
+ else:
+ map_data.need_optimization = True
+ map_data.wifi_map = True
- map_data.pixel_type = np.full((width, height), MapPixelType.OUTSIDE.value, dtype=np.uint8)
- if not map_data.empty_map:
- if map_data.frame_type == MapFrameType.I.value:
- if map_data.frame_map:
- for y in range(height):
- for x in range(width):
- pixel = map_data.data[(width * y) + x]
- if pixel > 0:
- map_data.empty_map = False
- segment_id = pixel >> 2
- if 0 < segment_id < 64:
- if segment_id == 63:
- map_data.pixel_type[x, y] = MapPixelType.WALL.value
- elif segment_id == 62:
- map_data.pixel_type[x, y] = MapPixelType.FLOOR.value
- elif segment_id == 61:
- map_data.pixel_type[x, y] = MapPixelType.UNKNOWN.value
+ carpet_pixels = []
+ map_data.empty_map = (
+ map_data.frame_type == MapFrameType.I.value or map_data.frame_type == MapFrameType.W.value
+ )
+ if (width * height) > 0:
+ map_data.data = raw[DreameVacuumMapDecoder.HEADER_SIZE : image_size]
+ map_data.empty_map = bool(width == 2 and height == 2)
+ if map_data.empty_map:
+ for y in range(height):
+ for x in range(width):
+ if map_data.data[(width * y) + x] > 0:
+ map_data.empty_map = False
+ break
+
+ np.seterr(over="ignore")
+ map_data.pixel_type = np.full((width, height), MapPixelType.OUTSIDE.value, dtype=np.uint8)
+ if not map_data.empty_map:
+ map_data.empty_map = True
+ if map_data.frame_type == MapFrameType.W.value:
+ try:
+ for y in range(height):
+ for x in range(width):
+ pixel = map_data.data[(width * y) + x] & 15
+ if pixel > 0:
+ map_data.empty_map = False
+ map_data.pixel_type[x, y] = MapPixelType(pixel)
+ except:
+ pass
+ elif map_data.frame_type == MapFrameType.I.value:
+ if map_data.frame_map:
+ for y in range(height):
+ for x in range(width):
+ pixel = map_data.data[(width * y) + x]
+ if pixel > 0:
+ if pixel & 0x03 == 3:
+ carpet_pixels.append((x, y))
+ map_data.empty_map = False
+ segment_id = pixel >> 2
+ if 0 < segment_id < 64:
+ if segment_id == 63:
+ map_data.pixel_type[x, y] = MapPixelType.WALL.value
+ elif segment_id == 62:
+ map_data.pixel_type[x, y] = MapPixelType.FLOOR.value
+ elif segment_id == 61:
+ map_data.pixel_type[x, y] = MapPixelType.UNKNOWN.value
+ else:
+ map_data.pixel_type[x, y] = segment_id
else:
- map_data.pixel_type[x, y] = segment_id
- else:
+ segment_id = pixel & 0x3F
+ if segment_id == 1 or segment_id == 3:
+ map_data.pixel_type[x, y] = MapPixelType.NEW_SEGMENT.value
+ elif segment_id == 2:
+ map_data.pixel_type[x, y] = MapPixelType.WALL.value
+ elif map_data.saved_map_status == 1 or map_data.saved_map_status == 0:
+ for y in range(height):
+ for x in range(width):
+ pixel = map_data.data[(width * y) + x]
+ if pixel > 0:
+ if pixel & 0x03 == 3:
+ carpet_pixels.append((x, y))
segment_id = pixel & 0x3F
+ # as implemented on the app
if segment_id == 1 or segment_id == 3:
+ map_data.empty_map = False
map_data.pixel_type[x, y] = MapPixelType.NEW_SEGMENT.value
elif segment_id == 2:
+ map_data.empty_map = False
map_data.pixel_type[x, y] = MapPixelType.WALL.value
- elif map_data.saved_map_status == 1 or map_data.saved_map_status == 0:
- for y in range(height):
- for x in range(width):
- segment_id = map_data.data[(width * y) + x] & 0x3F
- # as implemented on the app
- if segment_id == 1 or segment_id == 3:
- map_data.empty_map = False
- map_data.pixel_type[x, y] = MapPixelType.NEW_SEGMENT.value
- elif segment_id == 2:
- map_data.empty_map = False
- map_data.pixel_type[x, y] = MapPixelType.WALL.value
- elif vslam_map and not map_data.saved_map:
- for y in range(height):
- for x in range(width):
- segment_id = map_data.data[(width * y) + x] & 0b00000011
- if segment_id == 1:
- map_data.empty_map = False
- map_data.pixel_type[x, y] = MapPixelType.NEW_SEGMENT.value
- elif segment_id == 3:
- map_data.empty_map = False
- map_data.pixel_type[x, y] = MapPixelType.NEW_SEGMENT_UNKNOWN.value
- elif segment_id == 2:
- map_data.empty_map = False
- map_data.pixel_type[x, y] = MapPixelType.WALL.value
- else:
- for y in range(height):
- for x in range(width):
- pixel = map_data.data[(width * y) + x]
- if pixel > 0:
- map_data.empty_map = False
- if pixel >> 7:
- map_data.pixel_type[x, y] = MapPixelType.WALL.value
- else:
- segment_id = pixel & 0x3F
- if segment_id > 0:
- map_data.pixel_type[x, y] = segment_id
-
- segments = DreameVacuumMapDecoder.get_segments(map_data, vslam_map)
- if segments and data_json.get("seg_inf"):
- seg_inf = data_json["seg_inf"]
- for k, v in segments.items():
- if seg_inf.get(str(k)):
- segment_info = seg_inf[str(k)]
- if segment_info.get("nei_id"):
- segments[k].neighbors = segment_info["nei_id"]
- if segment_info.get("type"):
- segments[k].type = segment_info["type"]
- if segment_info.get("index"):
- segments[k].index = segment_info["index"]
- if segment_info.get("roomID"):
- segments[k].unique_id = segment_info["roomID"]
- if segment_info.get(MAP_PARAMETER_NAME):
- segments[k].custom_name = base64.b64decode(
- segment_info.get(MAP_PARAMETER_NAME)
- ).decode("utf-8")
- segments[k].set_name()
-
- map_data.segments = segments
-
- saved_map_data = None
- restored_map = map_data.restored_map
-
- if data_json.get("rism"):
- saved_map_data = DreameVacuumMapDecoder.decode_saved_map(
- data_json["rism"],
- vslam_map,
- map_data.rotation,
- )
+ elif (
+ vslam_map and not map_data.saved_map and not map_data.recovery_map
+ ) or map_data.saved_map_status == 2:
+ for y in range(height):
+ for x in range(width):
+ pixel = map_data.data[(width * y) + x]
+ if pixel & 0x03 == 3:
+ carpet_pixels.append((x, y))
+ segment_id = pixel & 0x3F
+ if segment_id > 0:
+ map_data.empty_map = False
+ if segment_id == 2:
+ map_data.pixel_type[x, y] = MapPixelType.WALL.value
+ else:
+ map_data.pixel_type[x, y] = MapPixelType.NEW_SEGMENT.value
+ else:
+ for y in range(height):
+ for x in range(width):
+ pixel = map_data.data[(width * y) + x]
+ if pixel > 0:
+ if (pixel & 0x40) == 64:
+ carpet_pixels.append((x, y))
+ map_data.empty_map = False
+ segment_id = pixel & 0x3F
+ if pixel >> 7:
+ map_data.pixel_type[x, y] = (
+ (100 + segment_id) if segment_id else MapPixelType.WALL.value
+ )
+ else:
+ if segment_id > 0:
+ map_data.pixel_type[x, y] = segment_id
+
+ if carpet_pixels:
+ map_data.carpet_pixels = carpet_pixels
+
+ segments = DreameVacuumMapDecoder.get_segments(map_data, vslam_map)
+ if segments and "seg_inf" in data_json:
+ seg_inf = data_json["seg_inf"]
+ for k, v in segments.items():
+ if seg_inf.get(str(k)):
+ segment_info = seg_inf[str(k)]
+ if segment_info.get("nei_id") is not None:
+ segments[k].neighbors = segment_info["nei_id"]
+ if segment_info.get("type") is not None:
+ segments[k].type = segment_info["type"]
+ if segment_info.get("index") is not None:
+ segments[k].index = segment_info["index"]
+ if segment_info.get("roomID") is not None:
+ segments[k].unique_id = segment_info["roomID"]
+ if segment_info.get("direction") is not None:
+ segments[k].floor_material_direction = segment_info["direction"]
+ if segment_info.get("material") is not None:
+ material = segment_info["material"]
+ if material in DreameVacuumFloorMaterial._value2member_map_:
+ segments[k].floor_material = material
+ elif material == 3:
+ segments[k].floor_material = DreameVacuumFloorMaterial.WOOD.value
+ segments[k].floor_material_direction = (
+ DreameVacuumFloorMaterialDirection.VERTICAL.value
+ )
+ elif material == 4:
+ segments[k].floor_material = DreameVacuumFloorMaterial.WOOD.value
+ segments[k].floor_material_direction = (
+ DreameVacuumFloorMaterialDirection.HORIZONTAL.value
+ )
+ else:
+ segments[k].floor_material = DreameVacuumFloorMaterial.NONE.value
+ if segment_info.get(MAP_PARAMETER_NAME):
+ segments[k].custom_name = base64.b64decode(
+ segment_info.get(MAP_PARAMETER_NAME)
+ ).decode("utf-8")
+ segments[k].visibility = (
+ bool(k not in map_data.hidden_segments)
+ if map_data.hidden_segments is not None
+ else True
+ )
+ segments[k].set_name()
+
+ map_data.segments = segments
+
+ if map_data.wifi_map:
+ map_data.robot_position = None
+ return map_data, saved_map_data
+
+ restored_map = map_data.restored_map
+
+ if "whmp" in data_json:
+ router_position = data_json["whmp"]
+ if router_position and len(router_position) > 1:
+ map_data.router_position = Point(
+ router_position[0],
+ router_position[1],
+ )
- if saved_map_data is not None:
- saved_map_data.timestamp_ms = map_data.timestamp_ms
- map_data.saved_map_id = saved_map_data.map_id
- if saved_map_data.temporary_map:
- map_data.temporary_map = saved_map_data.temporary_map
-
- if restored_map or map_data.recovery_map or (map_data.saved_map_status == 2 and map_data.empty_map):
- map_data.segments = copy.deepcopy(saved_map_data.segments)
- map_data.data = saved_map_data.data
- map_data.pixel_type = saved_map_data.pixel_type
- map_data.dimensions = saved_map_data.dimensions
-
- if map_data.empty_map:
- map_data.restored_map = False
- restored_map = True
- map_data.empty_map = False
- else:
- if saved_map_data.segments is not None:
- if map_data.segments is None and (
- map_data.saved_map_status == 1 or map_data.saved_map_status == 0
- ):
- map_data.segments = {}
-
- for k, v in saved_map_data.segments.items():
- if map_data.segments and k in map_data.segments:
- # as implemented on the app
- map_data.segments[k].icon = v.icon
- map_data.segments[k].name = v.name
- map_data.segments[k].custom_name = v.custom_name
- map_data.segments[k].type = v.type
- map_data.segments[k].index = v.index
- map_data.segments[k].unique_id = v.unique_id
- map_data.segments[k].neighbors = v.neighbors
- if map_data.saved_map_status == 2:
- map_data.segments[k].x = v.x
- map_data.segments[k].y = v.y
-
- if not saved_map_data.cleanset:
- saved_map_data.cleanset = copy.deepcopy(map_data.cleanset)
+ wifi_map = data_json.get("whm")
+ if map_data.saved_map and wifi_map and len(wifi_map) > 1:
+ wifi_map_data = DreameVacuumMapDecoder.decode_saved_map(data_json["whm"], False, map_data.rotation)
+ if wifi_map_data:
+ map_data.wifi_map_data = wifi_map_data
+ if map_data.wifi_map_data.router_position is None:
+ map_data.wifi_map_data.router_position = map_data.router_position
+
+ if "rism" in data_json:
+ _LOGGER.info("Decoding saved map: %s", map_data.map_id)
+ saved_map_data = DreameVacuumMapDecoder.decode_saved_map(
+ data_json["rism"],
+ vslam_map,
+ map_data.rotation,
+ )
- if (
- (map_data.saved_map_status == 2 or map_data.docked)
- and map_data.charger_position is None
- and not map_data.saved_map
- and saved_map_data.charger_position
- ):
- map_data.charger_position = saved_map_data.charger_position
+ if saved_map_data is not None:
+ _LOGGER.info("Decoded saved map: %s -> %s", map_data.map_id, saved_map_data.map_id)
+ saved_map_data.timestamp_ms = map_data.timestamp_ms
+ map_data.saved_map_id = saved_map_data.map_id
- if map_data.saved_map_status == 2:
- map_data.no_go_areas = saved_map_data.no_go_areas
- map_data.no_mopping_areas = saved_map_data.no_mopping_areas
- map_data.walls = saved_map_data.walls
+ if saved_map_data.temporary_map:
+ map_data.temporary_map = saved_map_data.temporary_map
- if vslam_map:
+ if (
+ restored_map
+ or map_data.recovery_map
+ or (
+ map_data.saved_map_status == 2
+ and (map_data.empty_map or (not map_data.frame_map and not vslam_map))
+ )
+ ):
map_data.segments = copy.deepcopy(saved_map_data.segments)
- map_data.charger_position = copy.deepcopy(saved_map_data.charger_position)
+ map_data.cleaning_sequence = saved_map_data.cleaning_sequence
+ map_data.mop_type = saved_map_data.mop_type
+ if saved_map_data.floor_material is not None:
+ map_data.floor_material = copy.deepcopy(saved_map_data.floor_material)
+ if map_data.hidden_segments is None and saved_map_data.hidden_segments is not None:
+ map_data.hidden_segments = copy.deepcopy(saved_map_data.hidden_segments)
+
+ if map_data.saved_map_status == 2 and not map_data.frame_map:
+ left = min(map_data.dimensions.left, saved_map_data.dimensions.left)
+ top = min(map_data.dimensions.top, saved_map_data.dimensions.top)
+ width = int(
+ (
+ max(
+ map_data.dimensions.left
+ + (map_data.dimensions.width * map_data.dimensions.grid_size),
+ saved_map_data.dimensions.left
+ + (saved_map_data.dimensions.width * saved_map_data.dimensions.grid_size),
+ )
+ - left
+ )
+ / saved_map_data.dimensions.grid_size
+ )
+ height = int(
+ (
+ max(
+ map_data.dimensions.top
+ + (map_data.dimensions.height * map_data.dimensions.grid_size),
+ saved_map_data.dimensions.top
+ + (saved_map_data.dimensions.height * saved_map_data.dimensions.grid_size),
+ )
+ - top
+ )
+ / saved_map_data.dimensions.grid_size
+ )
+ si = int((saved_map_data.dimensions.left - left) / saved_map_data.dimensions.grid_size)
+ sj = int((saved_map_data.dimensions.top - top) / saved_map_data.dimensions.grid_size)
+ sim = si + saved_map_data.dimensions.width
+ sjm = sj + saved_map_data.dimensions.height
+ ni = int((map_data.dimensions.left - left) / map_data.dimensions.grid_size)
+ nj = int((map_data.dimensions.top - top) / map_data.dimensions.grid_size)
+ nim = ni + map_data.dimensions.width
+ njm = nj + map_data.dimensions.height
+ pixel_type = np.zeros((width, height), np.uint8)
+
+ for j in range(height):
+ for i in range(width):
+ if j >= sj and i >= si and j < sjm and i < sim:
+ saved_value = saved_map_data.data[
+ (i - si) + ((j - sj) * saved_map_data.dimensions.width)
+ ]
+ segment_id = saved_value & 0x3F
+ else:
+ saved_value = -1
+ segment_id = 0
+
+ if map_data.restored_map and segment_id and saved_value != -1:
+ if saved_value >> 7 == 1:
+ pixel_type[i, j] = 255
+ elif saved_value == 63:
+ pixel_type[i, j] = 253
+ else:
+ pixel_type[i, j] = segment_id
+ elif j >= nj and i >= ni and j < njm and i < nim:
+ value = int(map_data.pixel_type[(i - ni), ((j - nj))])
+ if value == 255:
+ pixel_type[i, j] = value
+ elif value == 253:
+ pixel_type[i, j] = segment_id if segment_id else 254
+
+ map_data.combined_pixel_type = pixel_type
+ map_data.combined_dimensions = MapImageDimensions(
+ top, left, height, width, map_data.dimensions.grid_size
+ )
- if (
- not map_data.saved_map
- and map_data.robot_position is None
- and map_data.docked
- and map_data.charger_position
- ):
- map_data.robot_position = copy.deepcopy(map_data.charger_position)
+ if map_data.restored_map:
+ map_data.carpet_pixels = DreameVacuumMapDecoder.get_carpets(map_data, saved_map_data)
+ else:
+ # map_data.data = saved_map_data.data
+ map_data.combined_pixel_type = saved_map_data.pixel_type
+ map_data.combined_dimensions = saved_map_data.dimensions
+ map_data.carpet_pixels = saved_map_data.carpet_pixels
+
+ if map_data.empty_map:
+ map_data.restored_map = False
+ restored_map = True
+ map_data.empty_map = False
+ else:
+ if saved_map_data.segments is not None:
+ if map_data.segments is None and (
+ map_data.saved_map_status == 1 or map_data.saved_map_status == 0
+ ):
+ map_data.segments = {}
+
+ map_data.cleaning_sequence = saved_map_data.cleaning_sequence
+ map_data.mop_type = saved_map_data.mop_type
+
+ for k, v in saved_map_data.segments.items():
+ if map_data.segments and k in map_data.segments:
+ # as implemented on the app
+ map_data.segments[k].icon = v.icon
+ map_data.segments[k].name = v.name
+ map_data.segments[k].custom_name = v.custom_name
+ map_data.segments[k].type = v.type
+ map_data.segments[k].index = v.index
+ map_data.segments[k].unique_id = v.unique_id
+ map_data.segments[k].neighbors = v.neighbors
+ map_data.segments[k].floor_material = v.floor_material
+ map_data.segments[k].floor_material_direction = v.floor_material_direction
+ map_data.segments[k].visibility = v.visibility
+ map_data.segments[k].color_index = v.color_index
+ map_data.segments[k].carpet_cleaning = v.carpet_cleaning
+ map_data.segments[k].carpet_preferences = v.carpet_preferences
+ if map_data.saved_map_status == 2:
+ map_data.segments[k].x = v.x
+ map_data.segments[k].y = v.y
+
+ if not saved_map_data.cleanset:
+ saved_map_data.cleanset = copy.deepcopy(map_data.cleanset)
- if map_data.segments:
- if not map_data.saved_map:
- DreameVacuumMapDecoder.set_segment_cleanset(map_data, map_data.cleanset)
- DreameVacuumMapDecoder.set_robot_segment(map_data)
-
- if map_data.saved_map_status == 2 or map_data.saved_map:
- DreameVacuumMapDecoder.set_segment_color_index(map_data)
-
- if data_json.get("vw"):
- if data_json["vw"].get("rect") and not map_data.no_go_areas:
- map_data.no_go_areas = []
- for area in data_json["vw"]["rect"]:
- x_coords = sorted([area[0], area[2]])
- y_coords = sorted([area[1], area[3]])
- map_data.no_go_areas.append(
- Area(
- x_coords[0],
- y_coords[0],
- x_coords[1],
- y_coords[0],
- x_coords[1],
- y_coords[1],
- x_coords[0],
- y_coords[1],
+ if (
+ (map_data.saved_map_status == 2 or map_data.docked)
+ and map_data.charger_position is None
+ and not map_data.saved_map
+ and not map_data.recovery_map
+ and saved_map_data.charger_position
+ ):
+ map_data.charger_position = saved_map_data.charger_position
+
+ # map_data.walls_info = saved_map_data.walls_info
+ # map_data.walls_info_new = saved_map_data.walls_info_new
+ # map_data.ai_outborders_ar_origin = saved_map_data.ai_outborders_ar_origin
+ # map_data.ai_furniture_ar_origin = saved_map_data.ai_furniture_ar_origin
+ # map_data.ai_furniture_ar_origin_v2 = saved_map_data.ai_furniture_ar_origin_v2
+
+ if map_data.saved_map_status == 2:
+ map_data.no_go_areas = saved_map_data.no_go_areas
+ map_data.no_mopping_areas = saved_map_data.no_mopping_areas
+ map_data.virtual_walls = saved_map_data.virtual_walls
+ map_data.virtual_thresholds = saved_map_data.virtual_thresholds
+ map_data.passable_thresholds = saved_map_data.passable_thresholds
+ map_data.impassable_thresholds = saved_map_data.impassable_thresholds
+ map_data.ramps = saved_map_data.ramps
+ map_data.carpets = saved_map_data.carpets
+ map_data.deleted_carpets = saved_map_data.deleted_carpets
+ map_data.detected_carpets = saved_map_data.detected_carpets
+ map_data.router_position = saved_map_data.router_position
+ map_data.curtains = saved_map_data.curtains
+ map_data.hidden_segments = saved_map_data.hidden_segments
+ map_data.predefined_points = saved_map_data.predefined_points
+ map_data.router_position = saved_map_data.router_position
+ map_data.cleaning_sequence = saved_map_data.cleaning_sequence
+ map_data.mop_type = saved_map_data.mop_type
+
+ if map_data.clean_log:
+ map_data.wifi_map_data = DreameVacuumMapDecoder.decode_wifi_map_data(
+ map_data, saved_map_data.wifi_map_data
+ )
+ if saved_map_data.saved_furnitures is not None:
+ map_data.furnitures = saved_map_data.saved_furnitures
+ map_data.furniture_version = saved_map_data.furniture_version
+ saved_map_data.furnitures = saved_map_data.saved_furnitures
+
+ if vslam_map:
+ map_data.segments = copy.deepcopy(saved_map_data.segments)
+ map_data.charger_position = copy.deepcopy(saved_map_data.charger_position)
+
+ if not map_data.carpet_pixels:
+ map_data.carpet_pixels = DreameVacuumMapDecoder.get_carpets(map_data, saved_map_data)
+
+ if (
+ not map_data.saved_map
+ and map_data.robot_position is None
+ and map_data.docked
+ and map_data.charger_position
+ ):
+ map_data.robot_position = copy.deepcopy(map_data.charger_position)
+
+ if map_data.segments:
+ DreameVacuumMapDecoder.set_station_segment(map_data)
+
+ if not map_data.saved_map:
+ DreameVacuumMapDecoder.set_robot_segment(map_data)
+
+ if map_data.saved_map or next(iter(map_data.segments.values())).color_index is None:
+ DreameVacuumMapDecoder.set_segment_color_index(map_data)
+
+ if "cleanareaorder" in data_json:
+ map_data.cleaning_sequence = {}
+ for item in data_json["cleanareaorder"]:
+ for k, v in item.items():
+ map_data.cleaning_sequence[k] = v
+ break
+
+ map_data.cleaning_sequence = dict(
+ sorted(map_data.cleaning_sequence.items(), key=lambda item: int(item[0]))
+ )
+
+ if "room_id_type" in data_json:
+ map_data.mop_type = {}
+ for k, v in data_json["room_id_type"].items():
+ if v == 1:
+ map_data.mop_type[k] = "C"
+ elif v == 2:
+ map_data.mop_type[k] = "B"
+ else:
+ map_data.mop_type[k] = "A"
+
+ if "nopush" in data_json:
+ map_data.notified = bool(data_json["nopush"])
+
+ if "funiture_info" in data_json:
+ map_data.furniture_version = 2
+ map_data.saved_furnitures = {}
+ index = 0
+ for furniture in data_json["funiture_info"]:
+ index = index + 1
+ furniture_type = int(furniture[1])
+ if furniture_type == 8:
+ furniture_type = 25
+ elif furniture_type == 25:
+ furniture_type = 8
+
+ if furniture[3] > 0 and furniture[4] > 0:
+ if furniture_type in FurnitureType._value2member_map_:
+ map_data.saved_furnitures[index] = Furniture(
+ int(furniture[6]),
+ int(furniture[7]),
+ int(furniture[6] - (furniture[3] / 2)),
+ int(furniture[7] - (furniture[4] / 2)),
+ furniture[3],
+ furniture[4],
+ FurnitureType(furniture_type),
+ furniture[13] if len(furniture) >= 14 and furniture[13] else 0,
+ furniture[9],
+ furniture[12],
+ furniture[0],
+ furniture[2],
+ )
+ elif furniture_type != 27 and furniture_type != 28: ## Missing furnitures from app
+ _LOGGER.debug("Unknown furniture type: %s", furniture_type)
+
+ if map_data.furnitures is None:
+ furniture_key = (
+ "ai_furniture_user"
+ if "ai_furniture_user" in data_json and len(data_json["ai_furniture_user"])
+ else (
+ "ai_furniture_new"
+ if "ai_furniture_new" in data_json and len(data_json["ai_furniture_new"])
+ else "ai_furniture"
+ )
+ )
+ if furniture_key in data_json:
+ map_data.furniture_version = (
+ 1 if furniture_key == "ai_furniture_user" or furniture_key == "ai_furniture_new" else 0
+ )
+ map_data.furnitures = {}
+ index = 0
+ for furniture in data_json[furniture_key]:
+ size = len(furniture)
+ if size >= 4:
+ furniture_type = int(furniture[2])
+ index = index + 1
+ if furniture_type in FurnitureType._value2member_map_:
+ center_x = int(furniture[0])
+ center_y = int(furniture[1])
+ start_x0 = center_x
+ start_y0 = center_y
+ rect_width = 0
+ rect_height = 0
+ angle = 0
+ scale = 1.0
+ if size >= 8:
+ map_data.furniture_version = 1
+ start_x0 = int(furniture[4])
+ start_y0 = int(furniture[5])
+ rect_width = abs(int(furniture[6]))
+ rect_height = abs(int(furniture[7]))
+ if size >= 9:
+ angle = float(furniture[8])
+ if furniture_key == "ai_furniture":
+ if angle == 180:
+ angle = 0
+ elif angle == 0:
+ angle = 180
+ if size >= 10:
+ scale = float(furniture[9])
+ else:
+ map_data.furniture_version = 0
+
+ map_data.furnitures[index] = Furniture(
+ center_x,
+ center_y,
+ start_x0,
+ start_y0,
+ rect_width,
+ rect_height,
+ FurnitureType(furniture_type),
+ int(furniture[3]),
+ angle,
+ scale,
+ )
+
+ if "ai_obstacle" in data_json:
+ map_data.obstacles = {}
+ index = 1
+ for obstacle in data_json["ai_obstacle"]:
+ size = len(obstacle)
+ if size >= 4:
+ obstacle_type = int(obstacle[2])
+ if obstacle_type not in ObstacleType._value2member_map_:
+ if obstacle_type == 160 or obstacle_type == 166:
+ continue
+ obstacle_type = ObstacleType.OBSTACLE.value
+
+ id = obstacle[4]
+ x = float(obstacle[0])
+ y = float(obstacle[1])
+ possibility = int(float(obstacle[3]) * 100)
+ ignore_status = (
+ int(obstacle[-1])
+ if len(str(obstacle[-1])) == 1 and (int(obstacle[-1]) >= 0 or int(obstacle[-1]) <= 4)
+ else None
+ )
+
+ if (
+ ignore_status == ObstacleIgnoreStatus.HIDDEN.value
+ or ignore_status == ObstacleIgnoreStatus.ERROR.value
+ ):
+ continue
+
+ if size >= 7 and (float(id) >= 1000 or obstacle_type == ObstacleType.BLOCKED_ROOM.value):
+ if size >= 8:
+ map_data.obstacles[str(index)] = Obstacle(
+ x,
+ y,
+ ObstacleType(obstacle_type),
+ possibility,
+ id,
+ obstacle[5],
+ obstacle[6],
+ float(obstacle[7]) * 100,
+ float(obstacle[8]) * 100,
+ float(obstacle[9]) * 100 if size >= 10 else None,
+ float(obstacle[10]) * 100 if size >= 11 else None,
+ int(obstacle[11]) if size >= 13 else 2,
+ ignore_status,
+ )
+ else:
+ map_data.obstacles[str(index)] = Obstacle(
+ x,
+ y,
+ ObstacleType(obstacle_type),
+ possibility,
+ id,
+ obstacle[6],
+ obstacle[5],
+ )
+ else:
+ map_data.obstacles[str(index)] = Obstacle(
+ x, y, ObstacleType(obstacle_type), possibility, ignore_status=ignore_status
+ )
+ index = index + 1
+
+ DreameVacuumMapDecoder.set_obstacle_segment(map_data)
+
+ def parseAreas(areas):
+ if areas is not None:
+ map_areas = []
+ for area in areas:
+ x_coords = sorted([area[0], area[2]])
+ y_coords = sorted([area[1], area[3]])
+ map_areas.append(
+ Area(
+ x_coords[0],
+ y_coords[0],
+ x_coords[1],
+ y_coords[0],
+ x_coords[1],
+ y_coords[1],
+ x_coords[0],
+ y_coords[1],
+ area[4] if len(area) > 4 else None,
+ )
+ )
+ return map_areas
+
+ def parseLines(lines):
+ if lines is not None:
+ return [
+ Wall(
+ wall[0],
+ wall[1],
+ wall[2],
+ wall[3],
+ )
+ for wall in lines
+ ]
+
+ def parseCarpets(carpets):
+ if carpets is not None:
+ map_carpets = []
+ for carpet in carpets:
+ map_carpets.append(
+ Carpet(
+ int(carpet[4]) if len(carpet) > 4 else None,
+ carpet[0],
+ carpet[1],
+ carpet[2],
+ carpet[1],
+ carpet[2],
+ carpet[3],
+ carpet[0],
+ carpet[3],
+ carpet[5] if len(carpet) > 5 else None,
+ carpet[6] if len(carpet) > 6 else None,
+ None,
+ None,
+ None,
+ carpet[7] if len(carpet) > 7 else None,
+ carpet[8:13] if len(carpet) > 12 else None,
+ )
+ )
+ return map_carpets
+
+ if "vw" in data_json:
+ virtual_walls = data_json["vw"]
+ if virtual_walls:
+ if not map_data.no_go_areas:
+ map_data.no_go_areas = parseAreas(virtual_walls.get("rect"))
+ if not map_data.no_mopping_areas:
+ map_data.no_mopping_areas = parseAreas(virtual_walls.get("mop"))
+ if not map_data.virtual_walls:
+ map_data.virtual_walls = parseLines(virtual_walls.get("line"))
+ if not map_data.carpets:
+ map_data.carpets = parseCarpets(virtual_walls.get("addcpt"))
+ if not map_data.deleted_carpets:
+ map_data.deleted_carpets = parseCarpets(virtual_walls.get("nocpt"))
+
+ recommended_virtual_walls = data_json.get("rec_vw")
+ if recommended_virtual_walls:
+ map_data.recommended_area_type = recommended_virtual_walls.get("type")
+ map_data.recommended_no_go_areas = parseAreas(recommended_virtual_walls.get("rect"))
+ map_data.recommended_no_mopping_areas = parseAreas(recommended_virtual_walls.get("mop"))
+ map_data.recommended_virtual_walls = parseLines(recommended_virtual_walls.get("line"))
+ map_data.recommended_carpets = parseCarpets(recommended_virtual_walls.get("carpet"))
+
+ if "vws" in data_json:
+ virtual_thresholds = data_json["vws"]
+ if not map_data.virtual_thresholds:
+ map_data.virtual_thresholds = parseLines(virtual_thresholds.get("vwsl"))
+ if "npthrsd" in virtual_thresholds:
+ map_data.passable_thresholds = map_data.virtual_thresholds
+ map_data.virtual_thresholds = None
+
+ if not map_data.impassable_thresholds:
+ map_data.impassable_thresholds = parseLines(virtual_thresholds["npthrsd"])
+ if not map_data.ramps:
+ map_data.ramps = parseAreas(virtual_thresholds.get("ramp"))
+ if not map_data.cliffs:
+ map_data.cliffs = parseLines(virtual_thresholds.get("cliff"))
+
+ recommended_virtual_thresholds = data_json.get("rec_vws")
+ if recommended_virtual_thresholds:
+ map_data.recommended_threshold_type = recommended_virtual_walls.get("type")
+ map_data.recommended_virtual_thresholds = parseAreas(recommended_virtual_thresholds.get("vwsl"))
+ if "npthrsd" in recommended_virtual_thresholds:
+ map_data.recommended_passable_thresholds = map_data.recommended_virtual_thresholds
+ map_data.recommended_virtual_thresholds = None
+ map_data.recommended_impassable_thresholds = parseLines(recommended_virtual_thresholds["npthrsd"])
+ map_data.recommended_ramps = parseAreas(recommended_virtual_thresholds.get("ramp"))
+ map_data.recommended_cliffs = parseLines(recommended_virtual_thresholds.get("cliff"))
+
+ if "ct" in data_json:
+ curtains = data_json["ct"]
+ if isinstance(curtains, dict) and "line" in curtains and not map_data.curtains:
+ map_data.curtains = []
+ for line in curtains["line"]:
+ map_data.curtains.append(
+ Wall(
+ line[0],
+ line[1],
+ line[2],
+ line[3],
+ )
+ )
+
+ if "carpet_polygon" in data_json and len(data_json["carpet_polygon"]):
+ map_data.detected_carpets = []
+ for carpet_id in data_json["carpet_polygon"]:
+ carpet = data_json["carpet_polygon"][carpet_id]
+ if len(carpet) > 0 and len(carpet[0]) >= 8:
+ coords = carpet[0]
+ x_coords = []
+ y_coords = []
+ for k in range(0, len(coords), 2):
+ x_coords.append(coords[k])
+ y_coords.append(coords[k + 1])
+
+ max_x = max(x_coords)
+ max_y = max(y_coords)
+ min_x = min(x_coords)
+ min_y = min(y_coords)
+
+ map_data.detected_carpets.append(
+ Carpet(
+ int(carpet_id),
+ min_x,
+ min_y,
+ max_x,
+ min_y,
+ max_x,
+ max_y,
+ min_x,
+ max_y,
+ False,
+ int(carpet[1]) if len(carpet) > 1 else None,
+ None,
+ None,
+ coords,
+ not (len(carpet) <= 2 or carpet[2] == 0),
+ )
+ )
+ elif "carpet_info" in data_json:
+ map_data.detected_carpets = []
+ for carpet_id in data_json["carpet_info"]:
+ carpet = data_json["carpet_info"][carpet_id]
+ map_data.detected_carpets.append(
+ Carpet(
+ int(carpet_id),
+ carpet[0],
+ carpet[1],
+ carpet[2],
+ carpet[1],
+ carpet[2],
+ carpet[3],
+ carpet[0],
+ carpet[3],
+ carpet[6] if len(carpet) > 6 else None,
+ None,
+ carpet[5] if len(carpet) > 5 else None,
+ carpet[4],
)
)
- if data_json["vw"].get("mop") and not map_data.no_mopping_areas:
- map_data.no_mopping_areas = []
- for area in data_json["vw"]["mop"]:
- x_coords = sorted([area[0], area[2]])
- y_coords = sorted([area[1], area[3]])
- map_data.no_mopping_areas.append(
- Area(
- x_coords[0],
- y_coords[0],
- x_coords[1],
- y_coords[0],
- x_coords[1],
- y_coords[1],
- x_coords[0],
- y_coords[1],
+ if ("sneak_areas_end" in data_json or "sneak_areas" in data_json) and not map_data.low_lying_areas:
+ map_data.low_lying_areas = []
+ areas = data_json["sneak_areas_end" if "sneak_areas_end" in data_json else "sneak_areas"]
+ for area in areas:
+ coords = area["roi"]
+ x_coords = []
+ y_coords = []
+ for k in range(0, len(coords), 2):
+ x_coords.append(coords[k])
+ y_coords.append(coords[k + 1])
+
+ max_x = max(x_coords)
+ max_y = max(y_coords)
+ min_x = min(x_coords)
+ min_y = min(y_coords)
+
+ map_data.low_lying_areas.append(
+ Polygon(
+ area["id"],
+ min_x,
+ min_y,
+ max_x,
+ min_y,
+ max_x,
+ max_y,
+ min_x,
+ max_y,
+ coords,
+ area.get("type"),
+ area.get("hide"),
+ area.get("ms"),
+ area.get("area"),
)
)
- if data_json["vw"].get("line") and not map_data.walls:
- map_data.walls = [
- Wall(
- virtual_wall[0],
- virtual_wall[1],
- virtual_wall[2],
- virtual_wall[3],
+ if "pointinfo" in data_json:
+ points = data_json["pointinfo"]
+ if points:
+ if isinstance(points, list):
+ points = points[0]
+ if not map_data.predefined_points:
+ if "spoint" in points:
+ map_data.predefined_points = []
+ for point in points["spoint"]:
+ map_data.predefined_points.append(
+ Coordinate(
+ point[0],
+ point[1],
+ bool(point[2]),
+ point[3],
+ )
+ )
+ else:
+ map_data.predefined_points = []
+
+ if "tpoint" in points and not map_data.active_cruise_points:
+ map_data.active_cruise_points = {}
+ index = 0
+ for point in points["tpoint"]:
+ index = index + 1
+ map_data.active_cruise_points[index] = Coordinate(
+ point[0],
+ point[1],
+ bool(point[2]),
+ point[3],
+ )
+ elif not map_data.predefined_points:
+ map_data.predefined_points = []
+
+ if "tpointinfo" in data_json:
+ map_data.task_cruise_points = {}
+ for point in data_json["tpointinfo"]:
+ index = index + 1
+ map_data.task_cruise_points[index] = Coordinate(
+ point[0],
+ point[1],
+ bool(point[2]),
+ point[3],
)
- for virtual_wall in data_json["vw"]["line"]
- ]
- if vslam_map and not map_data.saved_map:
- map_data.need_optimization = not restored_map
+ if "area_clean_detail" in data_json:
+ values = data_json["area_clean_detail"]
+ if values:
+ map_data.blocked_segments = {
+ v[0]: ([SegmentSkipReason(v[1]), v[2], v[3]] if len(v) > 3 else [SegmentSkipReason(v[1])])
+ for v in values
+ if v[1] in SegmentSkipReason._value2member_map_
+ }
+
+ if "decmap" in data_json or map_data.multiple_cleaning_time:
+ map_data.cleaning_map_data = DreameVacuumMapDecoder.decode_cleaning_map_data(
+ map_data, data_json.get("decmap")
+ )
+ if map_data.cleaning_map_data:
+ map_data.cleaned_segments = map_data.cleaning_map_data.cleaned_segments
+ map_data.has_dirty_area = map_data.cleaning_map_data.has_dirty_area
+ map_data.has_cleaned_area = map_data.cleaning_map_data.has_cleaned_area
+
+ if map_data.obstacles:
+ obstacles = copy.deepcopy(map_data.obstacles)
+ for k, v in obstacles.items():
+ if v.type == ObstacleType.BLOCKED_ROOM:
+ if (
+ map_data.blocked_segments
+ and v.segment_id in map_data.blocked_segments
+ and (
+ len(map_data.blocked_segments[v.segment_id]) <= 4
+ or map_data.blocked_segments[v.segment_id][4] != 0
+ )
+ ):
+ blocked_segment = map_data.blocked_segments[v.segment_id]
+ obstacle = map_data.obstacles[k]
+ obstacle.reason = blocked_segment[0]
+ if len(blocked_segment) > 1:
+ obstacle.x = blocked_segment[1]
+ obstacle.y = blocked_segment[2]
+ else:
+ del map_data.obstacles[k]
+
+ if map_data.blocked_segments and not map_data.cleaning_map:
+ for k, v in map_data.blocked_segments.items():
+ if len(v) <= 4 or v[4] != 0:
+ found = False
+ if map_data.obstacles:
+ for obstacle in map_data.obstacles.values():
+ if obstacle.type == ObstacleType.BLOCKED_ROOM and obstacle.segment_id == k:
+ found = True
+ break
+
+ if not found:
+ obstacle = Obstacle(k, 0, ObstacleType.BLOCKED_ROOM, None)
+ obstacle.reason = v[0]
+ if obstacle.segment_id in map_data.segments:
+ segment = map_data.segments[obstacle.segment_id]
+ obstacle.x = segment.x
+ obstacle.y = segment.y
+ obstacle.segment = segment.name
+ obstacle.color_index = segment.color_index
+
+ if len(v) > 1:
+ obstacle.x = v[1]
+ obstacle.y = v[2]
+
+ if not map_data.obstacles:
+ map_data.obstacles = {}
+ map_data.obstacles[str(len(map_data.obstacles) + 1 if map_data.obstacles else 1)] = (
+ obstacle
+ )
+
+ # map_data.ai_outborders_user = data_json.get("ai_outborders_user")
+ # map_data.ai_outborders = data_json.get("ai_outborders")
+ # map_data.ai_outborders_new = data_json.get("ai_outborders_new")
+ # map_data.ai_outborders_2d = data_json.get("ai_outborders_2d")
+ # map_data.ai_outborders_ar_origin = data_json.get("ai_outborders_ar_origin")
+ # map_data.ai_furniture_ar_origin = data_json.get("ai_furniture_ar_origin")
+ # map_data.ai_furniture_ar_origin_v2 = data_json.get("ai_furniture_ar_origin_v2")
+ # map_data.ai_furniture_warning = data_json.get("ai_furniture_warning")
+ # if "walls_info" in data_json:
+ # map_data.walls_info = data_json["walls_info"]
+ # if "walls_info_new" in data_json:
+ # map_data.walls_info = data_json["walls_info_new"]
+
+ if vslam_map and not map_data.saved_map:
+ map_data.need_optimization = not restored_map
+ except Exception:
+ _LOGGER.error("Map Parse Failed: %s", traceback.format_exc())
return map_data, saved_map_data
@@ -2358,6 +4925,7 @@ def decode_p_map_data_from_partial(
current_map_data.robot_position = map_data.robot_position
current_map_data.timestamp_ms = map_data.timestamp_ms
current_map_data.docked = map_data.docked
+ current_map_data.line_to_robot = map_data.line_to_robot
current_map_data.temporary_map = map_data.temporary_map
current_map_data.saved_map = False
current_map_data.empty_map = False
@@ -2365,12 +4933,27 @@ def decode_p_map_data_from_partial(
current_map_data.recovery_map = False
current_map_data.clean_log = False
+ if map_data.docked is not None:
+ current_map_data.docked = map_data.docked
+
if map_data.charger_position is not None and (not vslam_map or current_map_data.saved_map_status != 2):
current_map_data.charger_position = map_data.charger_position
if map_data.obstacles is not None:
current_map_data.obstacles = map_data.obstacles
+ if map_data.detected_carpets is not None:
+ current_map_data.detected_carpets = map_data.detected_carpets
+
+ if map_data.active_cruise_points is not None:
+ current_map_data.active_cruise_points = map_data.active_cruise_points
+
+ if map_data.low_lying_areas is not None:
+ current_map_data.low_lying_areas = map_data.low_lying_areas
+
+ if map_data.carpet_cleanset is not None:
+ current_map_data.carpet_cleanset = map_data.carpet_cleanset
+
# P map only returns difference between its previous frame.
# Calculate new map size and update the buffer according to the received data at received offset.
if map_data.data:
@@ -2423,11 +5006,20 @@ def decode_p_map_data_from_partial(
# Add current buffer value to new buffer value for finding the new pixel value
data[new_index] = data[new_index] + map_data.data[current_index]
# Calculate the new pixel type from updated buffer value
- pixel_type[left_offset + x, top_offset + y] = DreameVacuumMapDecoder._get_pixel_type(
+ pixel_type[left_offset + x, top_offset + y], carpet = DreameVacuumMapDecoder._get_pixel_type(
current_map_data,
int(data[new_index]),
vslam_map,
)
+ if carpet and current_map_data.carpet_pixels is None:
+ current_map_data.carpet_pixels = []
+
+ if current_map_data.carpet_pixels is not None:
+ coord = (left_offset + x, top_offset + y)
+ if not carpet and coord in current_map_data.carpet_pixels:
+ current_map_data.carpet_pixels.remove(coord)
+ elif carpet and coord not in current_map_data.carpet_pixels:
+ current_map_data.carpet_pixels.append(coord)
# Update size and buffer
current_map_data.data = bytes(data)
@@ -2445,13 +5037,209 @@ def decode_p_map_data_from_partial(
current_map_data.path = map_data.path
DreameVacuumMapDecoder.set_robot_segment(current_map_data)
-
- # if robotPos.l2r == True and self._robotPos.l2r == True:
- # self._lastPos = self._robotPos
- # else:
- # self._lastPos = None
+ DreameVacuumMapDecoder.set_station_segment(current_map_data)
+ DreameVacuumMapDecoder.set_obstacle_segment(current_map_data)
return current_map_data
+ @staticmethod
+ def decode_wifi_map_data(map_data, wifi_map_data):
+ if (
+ wifi_map_data
+ and not map_data.saved_map
+ and not map_data.empty_map
+ and not wifi_map_data.empty_map
+ and wifi_map_data.wifi_map
+ ):
+ wifi_map = MapData()
+ wifi_map.map_id = wifi_map_data.map_id
+ wifi_map.frame_id = wifi_map_data.frame_id
+ wifi_map.frame_type = wifi_map_data.frame_type
+ wifi_map.timestamp_ms = map_data.timestamp_ms
+ wifi_map.rotation = wifi_map_data.rotation
+ wifi_map.router_position = wifi_map_data.router_position
+ wifi_map.charger_position = map_data.charger_position
+ wifi_map.robot_position = map_data.robot_position
+ wifi_map.docked = map_data.docked
+ wifi_map.saved_map_status = map_data.saved_map_status
+ wifi_map.need_optimization = True
+ wifi_map.saved_map = False
+ wifi_map.wifi_map = True
+ wifi_map.last_updated = map_data.timestamp_ms / 1000.0
+ if wifi_map.docked and wifi_map.robot_position is None:
+ wifi_map.robot_position = map_data.charger_position
+
+ left = min(map_data.dimensions.left, wifi_map_data.dimensions.left)
+ top = min(map_data.dimensions.top, wifi_map_data.dimensions.top)
+ width = int(
+ (
+ max(
+ map_data.dimensions.left + (map_data.dimensions.width * map_data.dimensions.grid_size),
+ wifi_map_data.dimensions.left
+ + (wifi_map_data.dimensions.width * wifi_map_data.dimensions.grid_size),
+ )
+ - left
+ )
+ / wifi_map_data.dimensions.grid_size
+ )
+ height = int(
+ (
+ max(
+ map_data.dimensions.top + (map_data.dimensions.height * map_data.dimensions.grid_size),
+ wifi_map_data.dimensions.top
+ + (wifi_map_data.dimensions.height * wifi_map_data.dimensions.grid_size),
+ )
+ - top
+ )
+ / wifi_map_data.dimensions.grid_size
+ )
+ si = int((wifi_map_data.dimensions.left - left) / wifi_map_data.dimensions.grid_size)
+ sj = int((wifi_map_data.dimensions.top - top) / wifi_map_data.dimensions.grid_size)
+ sim = si + wifi_map_data.dimensions.width
+ sjm = sj + wifi_map_data.dimensions.height
+ ni = int((map_data.dimensions.left - left) / map_data.dimensions.grid_size)
+ nj = int((map_data.dimensions.top - top) / map_data.dimensions.grid_size)
+ nim = ni + map_data.dimensions.width
+ njm = nj + map_data.dimensions.height
+ pixel_type = np.zeros((width, height), np.uint8)
+
+ for j in range(height):
+ for i in range(width):
+ if j >= nj and i >= ni and j < njm and i < nim:
+ value = int(map_data.pixel_type[(i - ni), ((j - nj))])
+ if value == 255:
+ pixel_type[i, j] = 2
+ elif value:
+ pixel_type[i, j] = max(
+ (
+ wifi_map_data.data[(i - si) + ((j - sj) * wifi_map_data.dimensions.width)] & 15
+ if j >= sj and i >= si and j < sjm and i < sim
+ else 0
+ ),
+ 10,
+ )
+
+ wifi_map.pixel_type = pixel_type
+ wifi_map.dimensions = MapImageDimensions(top, left, height, width, map_data.dimensions.grid_size)
+ wifi_map_data.data = None
+ return wifi_map
+ return wifi_map_data
+
+ @staticmethod
+ def decode_cleaning_map_data(map_data, cleaning_map_str):
+ partial_cleaning_map = None
+ if cleaning_map_str and len(cleaning_map_str) > 1:
+ partial_cleaning_map = DreameVacuumMapDecoder.decode_map_partial(cleaning_map_str)
+ if partial_cleaning_map is None:
+ return
+
+ cleaning_map = MapData()
+ if partial_cleaning_map:
+ cleaning_map.map_id = partial_cleaning_map.map_id
+ cleaning_map.frame_id = partial_cleaning_map.frame_id
+ cleaning_map.frame_type = partial_cleaning_map.frame_type
+ cleaning_map.timestamp_ms = partial_cleaning_map.timestamp_ms
+ cleaning_map.cleaned_segments = partial_cleaning_map.data_json.get("CleanArea")
+ else:
+ cleaning_map.map_id = map_data.map_id
+ cleaning_map.frame_id = map_data.frame_id
+ cleaning_map.frame_type = map_data.frame_type
+ cleaning_map.timestamp_ms = map_data.timestamp_ms
+
+ cleaning_map.dimensions = map_data.dimensions
+ cleaning_map.charger_position = map_data.charger_position
+ cleaning_map.robot_position = map_data.robot_position
+ cleaning_map.segments = map_data.segments
+ cleaning_map.pixel_type = map_data.pixel_type.copy()
+ cleaning_map.rotation = map_data.rotation
+ cleaning_map.saved_map_status = map_data.saved_map_status
+ cleaning_map.docked = map_data.docked
+ cleaning_map.dos = map_data.dos
+ cleaning_map.multiple_cleaning_time = map_data.multiple_cleaning_time
+ cleaning_map.mop_wash_count = map_data.mop_wash_count
+ cleaning_map.dust_collection_count = map_data.dust_collection_count
+ cleaning_map.cleanup_method = map_data.cleanup_method
+ cleaning_map.startup_method = map_data.startup_method
+ cleaning_map.blocked_segments = map_data.blocked_segments
+ cleaning_map.last_updated = map_data.timestamp_ms / 1000.0
+ cleaning_map.history_map = True
+ cleaning_map.saved_map = False
+ cleaning_map.cleaning_map = True
+ if cleaning_map.docked and cleaning_map.robot_position is None:
+ cleaning_map.robot_position = map_data.charger_position
+
+ if partial_cleaning_map:
+ grid_size = DreameVacuumMapDecoder._read_int_16_le(partial_cleaning_map.raw, 17)
+ width = DreameVacuumMapDecoder._read_int_16_le(partial_cleaning_map.raw, 19)
+ height = DreameVacuumMapDecoder._read_int_16_le(partial_cleaning_map.raw, 21)
+ left = DreameVacuumMapDecoder._read_int_16_le(partial_cleaning_map.raw, 23)
+ top = DreameVacuumMapDecoder._read_int_16_le(partial_cleaning_map.raw, 25)
+
+ data = partial_cleaning_map.raw[
+ DreameVacuumMapDecoder.HEADER_SIZE : DreameVacuumMapDecoder.HEADER_SIZE + width * height
+ ]
+
+ cleaning_map.has_dirty_area = False
+ cleaning_map.has_cleaned_area = False
+
+ for y in range(height):
+ for x in range(width):
+ value = data[int(y * width + x)] & 0x03
+ if value > 0:
+ xx = int(((left + (x * grid_size)) - map_data.dimensions.left) / map_data.dimensions.grid_size)
+ yy = int(((top + (y * grid_size)) - map_data.dimensions.top) / map_data.dimensions.grid_size)
+ if cleaning_map.check_point(xx, yy, True):
+ if value == 1:
+ cleaning_map.pixel_type[xx, yy] = 249
+ cleaning_map.has_cleaned_area = True
+ elif value == 2:
+ cleaning_map.pixel_type[xx, yy] = 250
+ cleaning_map.has_dirty_area = True
+ return cleaning_map
+
+ @staticmethod
+ def optimize_wifi_map(map_data):
+ if map_data.wifi_map:
+ if map_data.need_optimization:
+ map_data.optimized_pixel_type = np.copy(map_data.pixel_type)
+ map_data.optimized_dimensions = map_data.dimensions
+ map_data.optimized_dimensions.left = (
+ map_data.optimized_dimensions.original_left - map_data.optimized_dimensions.offset
+ )
+ map_data.optimized_dimensions.top = (
+ map_data.optimized_dimensions.original_top - map_data.optimized_dimensions.offset
+ )
+
+ if not map_data.empty_map:
+ for y in range(map_data.dimensions.height):
+ for x in range(map_data.dimensions.width):
+ if int(map_data.pixel_type[x, y]) > 2:
+ max_count = 0
+ max_px = -1
+ value_count = [0, 0, 0, 0]
+ for delta in range(3, 6):
+ for n in range(y - delta, y + delta + 1):
+ for m in range(x - delta, x + delta + 1):
+ if (
+ n < 0
+ or n >= map_data.dimensions.height
+ or m < 0
+ or m >= map_data.dimensions.width
+ ):
+ continue
+
+ px = int(map_data.pixel_type[m, n]) - 11
+ if px >= 0:
+ value_count[px] = value_count[px] + 1
+ if value_count[px] > max_count:
+ max_count = value_count[px]
+ max_px = px
+
+ if max_px >= 0:
+ map_data.optimized_pixel_type[x, y] = MapPixelType(max_px + 11)
+ break
+ map_data.need_optimization = False
+ return map_data
+
@staticmethod
def get_segments(map_data: MapData, vslam_map: bool) -> dict[str, Any]:
segments = {}
@@ -2463,101 +5251,361 @@ def get_segments(map_data: MapData, vslam_map: bool) -> dict[str, Any]:
segments[segment_id] = Segment(segment_id, x, y, x, y)
continue
- if x < segments[segment_id].x0:
- segments[segment_id].x0 = x
- elif x > segments[segment_id].x1:
- segments[segment_id].x1 = x
+ if x < segments[segment_id].coords[0]:
+ segments[segment_id].coords[0] = x
+ elif x > segments[segment_id].coords[2]:
+ segments[segment_id].coords[2] = x
- if y < segments[segment_id].y0:
- segments[segment_id].y0 = y
- elif y > segments[segment_id].y1:
- segments[segment_id].y1 = y
+ if y < segments[segment_id].coords[1]:
+ segments[segment_id].coords[1] = y
+ elif y > segments[segment_id].coords[3]:
+ segments[segment_id].coords[3] = y
if segments:
- for k, v in segments.items():
- x = int(math.ceil((v.x1 - v.x0) / 2 + v.x0))
- y = int(math.ceil((v.y1 - v.y0) / 2 + v.y0))
+ for segment in segments.values():
+ x = int(math.ceil((segment.coords[2] - segment.coords[0]) / 2 + segment.coords[0]))
+ y = int(math.ceil((segment.coords[3] - segment.coords[1]) / 2 + segment.coords[1]))
if map_data.saved_map:
if vslam_map:
- if map_data.pixel_type[x, y] != k:
+ if map_data.pixel_type[x, y] != segment.id:
startI = -1
endI = -1
for i in range(map_data.dimensions.width):
value = map_data.pixel_type[i, y]
if startI == -1:
- if value == k:
+ if value == segment.id:
startI = i
- elif value != k or i == (map_data.dimensions.width - 1):
+ elif value != segment.id or i == (map_data.dimensions.width - 1):
endI = i - 1
break
if startI != -1 and endI != -1:
x = (endI - startI) + startI
else:
- center_x = DreameVacuumMapDecoder._get_segment_center(map_data, k, y, False)
+ center_x = DreameVacuumMapDecoder._get_segment_center(map_data, segment.id, y, False)
if center_x is not None:
- center_y = DreameVacuumMapDecoder._get_segment_center(map_data, k, center_x, True)
+ center_y = DreameVacuumMapDecoder._get_segment_center(map_data, segment.id, center_x, True)
if center_y is not None:
x = center_x
y = center_y
- segments[k].x0 = int(map_data.dimensions.left + (v.x0 * map_data.dimensions.grid_size))
- segments[k].y0 = int(
- map_data.dimensions.top + (v.y0 * map_data.dimensions.grid_size) - map_data.dimensions.grid_size
+ segment.x = math.floor(
+ map_data.dimensions.left + (x * map_data.dimensions.grid_size) + (map_data.dimensions.offset)
)
- segments[k].x1 = int(
- map_data.dimensions.left + (v.x1 * map_data.dimensions.grid_size) + map_data.dimensions.grid_size
+ segment.y = math.floor(
+ map_data.dimensions.top + (y * map_data.dimensions.grid_size) + (map_data.dimensions.offset)
)
- segments[k].y1 = int(map_data.dimensions.top + (v.y1 * map_data.dimensions.grid_size))
- segments[k].x = int(map_data.dimensions.left + (x * map_data.dimensions.grid_size))
- segments[k].y = int(map_data.dimensions.top + (y * map_data.dimensions.grid_size))
- segments[k].set_name()
+ segment.calculate_coords(map_data.dimensions)
+ segment.set_name()
return segments
@staticmethod
def set_robot_segment(map_data: MapData) -> None:
if map_data.segments and map_data.saved_map_status == 2 and map_data.robot_position is not None:
- map_data.robot_segment = map_data.pixel_type[
- int((map_data.robot_position.x - map_data.dimensions.left) / map_data.dimensions.grid_size),
- int((map_data.robot_position.y - map_data.dimensions.top) / map_data.dimensions.grid_size),
- ]
+ map_data.robot_segment = DreameVacuumMapDecoder._find_px_type(
+ map_data.robot_position.x, map_data.robot_position.y, map_data
+ )
+
if map_data.robot_segment not in map_data.segments:
map_data.robot_segment = 0
+ for k, v in map_data.segments.items():
+ if v.check_point(
+ map_data.robot_position.x,
+ map_data.robot_position.y,
+ map_data.dimensions.grid_size * 4,
+ ):
+ map_data.robot_segment = k
+ break
else:
map_data.robot_segment = None
@staticmethod
- def set_segment_cleanset(map_data: MapData, cleanset: dict[str, list[int]]) -> None:
+ def set_station_segment(map_data: MapData) -> None:
+ if map_data.segments and map_data.charger_position is not None:
+ map_data.station_segment = DreameVacuumMapDecoder._find_px_type(
+ map_data.charger_position.x, map_data.charger_position.y, map_data
+ )
+
+ if map_data.station_segment not in map_data.segments:
+ map_data.station_segment = 0
+ for k, v in map_data.segments.items():
+ if v.check_point(
+ map_data.charger_position.x,
+ map_data.charger_position.y,
+ map_data.dimensions.grid_size * 4,
+ ):
+ map_data.station_segment = k
+ break
+ else:
+ map_data.station_segment = None
+
+ @staticmethod
+ def set_obstacle_segment(map_data: MapData) -> None:
+ if map_data.segments and map_data.obstacles:
+ for k, obstacle in map_data.obstacles.items():
+ if obstacle.type == ObstacleType.BLOCKED_ROOM:
+ if obstacle.segment_id in map_data.segments:
+ segment = map_data.segments[obstacle.segment_id]
+ map_data.obstacles[k].x = segment.x
+ map_data.obstacles[k].y = segment.y
+ map_data.obstacles[k].segment = segment.name
+ map_data.obstacles[k].color_index = segment.color_index
+ else:
+ segment = DreameVacuumMapDecoder._find_px_type(obstacle.x, obstacle.y, map_data)
+
+ if segment not in map_data.segments:
+ for v in map_data.segments.values():
+ if v.check_point(
+ obstacle.x,
+ obstacle.y,
+ map_data.dimensions.grid_size * 4,
+ ):
+ map_data.obstacles[k].segment = v.name
+ map_data.obstacles[k].color_index = v.color_index
+ break
+ else:
+ map_data.obstacles[k].segment = map_data.segments[segment].name
+ map_data.obstacles[k].color_index = map_data.segments[segment].color_index
+
+ @staticmethod
+ def set_segment_cleanset(
+ map_data: MapData,
+ cleanset: dict[str, list[int]],
+ capability: DreameVacuumDeviceCapability = None,
+ ) -> None:
if map_data is not None and map_data.segments is not None:
+ default_cleanset = [
+ 1,
+ 3,
+ 1,
+ 0,
+ ] # Cleanset returns empty on restored map but robot uses these default values when that happens
+
+ if capability:
+ if capability.custom_cleaning_mode:
+ default_cleanset.append(2)
+
+ if capability.cleaning_route:
+ default_cleanset.append(33)
+ elif capability.segment_mopping_type:
+ default_cleanset.append(2)
+ elif capability.segment_mopping_settings:
+ default_cleanset.append(546)
+
+ if capability.wetness_level:
+ default_cleanset[1] = 16
+
+ if capability.mop_temperature:
+ default_cleanset.append(0)
+
+ if capability.mop_pressure:
+ if len(default_cleanset) == 6:
+ default_cleanset.extend([0, 0])
+ elif len(default_cleanset) == 7:
+ default_cleanset.append(0)
+
+ default_cleanset.append(1)
+
+ cleanset_type = CleansetType.NONE
+ if cleanset is not None:
+ cleanset_type = CleansetType.DEFAULT
+ if len(cleanset) == 0:
+ if capability:
+ if capability.wetness_level:
+ cleanset_type = (
+ CleansetType.WETNESS_LEVEL_MAX_15
+ if capability.mop_clean_frequency
+ else CleansetType.WETNESS_LEVEL
+ )
+ elif capability.cleaning_route:
+ cleanset_type = CleansetType.CLEANING_ROUTE
+ elif capability.segment_mopping_settings:
+ cleanset_type = CleansetType.CUSTOM_MOPPING_ROUTE
+ elif capability.custom_cleaning_mode:
+ cleanset_type = CleansetType.CLEANING_MODE
+ else:
+ for k, v in cleanset.items():
+ if len(v) > 5 and v[5] > 0:
+ cleanset_type = CleansetType.CLEANING_MODE
+ if capability:
+ if capability.wetness_level:
+ cleanset_type = (
+ CleansetType.WETNESS_LEVEL_MAX_15
+ if capability.mop_clean_frequency
+ else CleansetType.WETNESS_LEVEL
+ )
+ elif capability.cleaning_route:
+ cleanset_type = CleansetType.CLEANING_ROUTE
+ elif capability.segment_mopping_settings:
+ cleanset_type = CleansetType.CUSTOM_MOPPING_ROUTE
+ break
+ if len(v) > 4:
+ cleanset_type = CleansetType.CLEANING_MODE
+ break
+
for k, v in map_data.segments.items():
- if cleanset is not None:
+ map_data.segments[k].cleanset_type = cleanset_type
+ if cleanset_type != CleansetType.NONE:
segment_id = str(k)
if segment_id not in cleanset:
- cleanset[segment_id] = [
- 1,
- 3,
- 1,
- 0,
- ] # Cleanset returns empty on restored map but robot uses these default values when that happens
- if map_data.segments[k].cleaning_mode is not None:
- cleanset[segment_id].append(2)
+ cleanset[segment_id] = default_cleanset.copy()
item = cleanset[segment_id]
-
map_data.segments[k].suction_level = item[0]
map_data.segments[k].water_volume = (
- item[1] - 1
+ item[1] - 1 if item[1] > 1 and item[1] < 5 else 1
) # for some reason cleanset uses different int values for water volume
map_data.segments[k].cleaning_times = item[2]
- map_data.segments[k].order = item[3]
- map_data.segments[k].cleaning_mode = item[4] if len(item) > 4 else None
+
+ if capability.auto_change_mop:
+ map_data.segments[k].mop_type = map_data.mop_type.get(segment_id, 1)
+
+ if len(item) > 4:
+ map_data.segments[k].cleaning_mode = item[4]
+ if len(item) > 5 and cleanset_type != CleansetType.CLEANING_MODE:
+ map_data.segments[k].mopping_settings = item[5]
+ # Logic for custom room mopping effect settings (mopping effect, mop pad humidity/wetness, route)
+ if item[5] > 0:
+ values = DreameVacuumMapDecoder.split_mopping_settings(
+ map_data.segments[k].mopping_settings
+ )
+ if values:
+ if values[2] == 0: # Means custom mopping route enabled
+ map_data.segments[k].custom_mopping_route = values[0] - 1
+ map_data.segments[k].water_volume = values[1]
+ map_data.segments[k].cleaning_route = values[0]
+ elif values[2] <= 3:
+ map_data.segments[k].custom_mopping_route = -1
+ map_data.segments[k].cleaning_route = 1 if values[2] == 2 else values[2]
+ map_data.segments[k].water_volume = values[2]
+
+ if cleanset_type == CleansetType.WETNESS_LEVEL:
+ map_data.segments[k].custom_mopping_route = 0
+ if values[2] == 0 and values[1] == 0:
+ map_data.segments[k].wetness_level = item[1] if item[1] else 16
+ if map_data.segments[k].wetness_level > 26:
+ map_data.segments[k].water_volume = 3
+ elif map_data.segments[k].wetness_level < 6:
+ map_data.segments[k].water_volume = 1
+ else:
+ map_data.segments[k].water_volume = 2
+ elif map_data.segments[k].water_volume == 1:
+ map_data.segments[k].wetness_level = 5
+ elif map_data.segments[k].water_volume == 3:
+ map_data.segments[k].wetness_level = 27
+ else:
+ map_data.segments[k].wetness_level = 16
+ elif cleanset_type == CleansetType.WETNESS_LEVEL_MAX_15:
+ map_data.segments[k].custom_mopping_route = 0
+ if values[2] == 0 and values[1] == 0:
+ map_data.segments[k].wetness_level = item[1] if item[1] else 10
+ if map_data.segments[k].wetness_level > 14:
+ map_data.segments[k].water_volume = 3
+ elif map_data.segments[k].wetness_level < 6:
+ map_data.segments[k].water_volume = 1
+ else:
+ map_data.segments[k].water_volume = 2
+ elif map_data.segments[k].water_volume == 1:
+ map_data.segments[k].wetness_level = 5
+ elif map_data.segments[k].water_volume == 3:
+ map_data.segments[k].wetness_level = 15
+ else:
+ map_data.segments[k].wetness_level = 10
+
+ if capability.mop_temperature:
+ map_data.segments[k].mop_temperature = item[6] if len(item) > 6 else 0
+
+ if capability.mop_pressure:
+ map_data.segments[k].mop_pressure = item[7] if len(item) > 7 else 1
+ else:
+ map_data.segments[k].mopping_settings = None
+ map_data.segments[k].cleaning_route = None
+ map_data.segments[k].custom_mopping_route = None
+ map_data.segments[k].wetness_level = None
+ map_data.segments[k].mop_pressure = None
+ map_data.segments[k].mop_temperature = None
else:
map_data.segments[k].suction_level = None
map_data.segments[k].water_volume = None
+ map_data.segments[k].wetness_level = None
map_data.segments[k].cleaning_times = None
map_data.segments[k].order = None
map_data.segments[k].cleaning_mode = None
+ map_data.segments[k].mopping_settings = None
+ map_data.segments[k].cleaning_route = None
+ map_data.segments[k].custom_mopping_route = None
+ map_data.segments[k].mop_pressure = None
+ map_data.segments[k].mop_temperature = None
+
+ if cleanset_type != CleansetType.NONE:
+ cleaning_sequence_v2 = capability.cleaning_sequence_v2 and map_data.cleaning_sequence
+ cleaning_sequence = map_data.cleaning_sequence if cleaning_sequence_v2 else (cleanset or {})
+ hidden_segments = set(map_data.hidden_segments or [])
+
+ sequence = sorted(
+ [
+ (int(k), v if cleaning_sequence_v2 else v[3])
+ for k, v in cleaning_sequence.items()
+ if int(k) not in hidden_segments and (cleaning_sequence_v2 or (len(v) > 3 and v[3]))
+ ],
+ key=lambda x: x[1],
+ )
+ ordered_keys = [k for k, v in sequence]
+ for i, k in enumerate(ordered_keys, 1):
+ if k in map_data.segments:
+ map_data.segments[k].order = i
+
+ if cleaning_sequence_v2:
+ index = len(ordered_keys) + 1
+ for k in list(sorted(map_data.segments.keys())):
+ if map_data.segments[k].order is None and map_data.segments[k].visibility != False:
+ map_data.segments[k].order = index
+ index = index + 1
+
+ @staticmethod
+ def set_carpet_cleanset(
+ map_data: MapData, cleanset: list[list[int]], capability: DreameVacuumDeviceCapability = None
+ ):
+ if (
+ map_data is not None
+ and cleanset is not None
+ and (map_data.detected_carpets or map_data.carpets or capability.carpet_material)
+ ):
+ for setting in cleanset:
+ if len(setting) > 1:
+ if setting[0] == 2:
+ if capability.carpet_material:
+ if map_data.segments and setting[1] in map_data.segments:
+ map_data.segments[setting[1]].set_custom_carpet_settings(
+ setting[2] if len(setting) > 2 else -1, setting[3] if len(setting) > 3 else None
+ )
+ else:
+ carpets = map_data.detected_carpets if setting[0] == 0 else map_data.carpets
+ if carpets:
+ for carpet in carpets:
+ if carpet.id == setting[1]:
+ carpet.set_custom_carpet_settings(
+ setting[2] if len(setting) > 2 else -1,
+ setting[3] if len(setting) > 3 else None,
+ )
+ break
+
+ @staticmethod
+ def split_mopping_settings(value: int) -> list[int]:
+ if value is not None:
+ value_list = []
+ for i in range(3):
+ value_list.append(value & 15)
+ value = value >> 4
+ return value_list
+
+ @staticmethod
+ def combine_mopping_settings(values: list[int]) -> int:
+ if values and len(values) == 3:
+ value = 0 ^ values[2]
+ value = value << 4 ^ values[1]
+ return value << 4 ^ values[0]
@staticmethod
def set_segment_color_index(map_data: MapData) -> None:
@@ -2589,17 +5637,112 @@ def set_segment_color_index(map_data: MapData) -> None:
for area_color in area_color_num:
color = area_color[0]
if color not in used_ids:
- area_color_index[segment.segment_id] = color
+ area_color_index[segment.id] = color
break
- if segment.segment_id not in area_color_index:
- area_color_index[segment.segment_id] = 0
+ if segment.id not in area_color_index:
+ area_color_index[segment.id] = 0
+
+ for k, v in area_color_index.items():
+ map_data.segments[k].color_index = v
+
+ @staticmethod
+ def get_carpets(map_data: MapData, saved_map_data: MapData) -> list[tuple]:
+ if saved_map_data and saved_map_data.carpet_pixels:
+ left_offset = 0
+ if saved_map_data.dimensions.left < map_data.dimensions.left:
+ left_offset = int(
+ (map_data.dimensions.left - saved_map_data.dimensions.left) / map_data.dimensions.grid_size
+ )
+ top_offset = 0
+ if saved_map_data.dimensions.top < map_data.dimensions.top:
+ top_offset = int(
+ (map_data.dimensions.top - saved_map_data.dimensions.top) / map_data.dimensions.grid_size
+ )
+
+ if left_offset != 0 or top_offset != 0:
+ carpet_pixels = []
+ for point in saved_map_data.carpet_pixels:
+ x = point[0] - left_offset
+ y = point[1] - top_offset
+ if x >= 0 and x < map_data.dimensions.width and y >= 0 and y < map_data.dimensions.height:
+ value = int(map_data.pixel_type[x, y])
+ if value > 0:
+ carpet_pixels.append((x, y))
+
+ return carpet_pixels
+ else:
+ return saved_map_data.carpet_pixels
+ return None
+
+ @staticmethod
+ def set_segment_floor_material(
+ map_data: MapData, segment_id: int, floor_material, capability: DreameVacuumDeviceCapability
+ ) -> None:
+ if floor_material is not None and map_data.segments and segment_id in map_data.segments:
+ material = map_data.segments[segment_id].floor_material
+ material_direction = map_data.segments[segment_id].floor_material_direction
+ if material is not None:
+ if material > 4:
+ if material > 7 or (
+ capability is not None and not (capability.carpet_type and capability.carpet_material)
+ ):
+ material = 0
+
+ floor_material[segment_id] = material
+ else:
+ if capability.floor_direction_cleaning and material == 1:
+ if material_direction is None:
+ material_direction = 0
+ map_data.segments[segment_id].floor_material_direction = material_direction
+ else:
+ material_direction = None
+ map_data.segments[segment_id].floor_material_direction = None
+
+ if material_direction is not None:
+ map_data.segments[segment_id].floor_material_rotated_direction = (
+ material_direction
+ if map_data.rotation == 0 or map_data.rotation == 180
+ else 90 if material_direction == 0 else 0
+ )
+
+ floor_material[segment_id] = (
+ 0
+ if material <= 0 or material > 2
+ else (
+ 3
+ if material == 2
+ else (
+ 2
+ if material_direction == 90
+ or (map_data.segments[segment_id].x1 - map_data.segments[segment_id].x0)
+ <= (map_data.segments[segment_id].y1 - map_data.segments[segment_id].y0)
+ else 1
+ )
+ )
+ )
+ elif capability and capability.floor_material:
+ floor_material[segment_id] = 0
+ map_data.segments[segment_id].floor_material = 0
+ if capability.floor_direction_cleaning:
+ map_data.segments[segment_id].floor_material_direction = 0
+ map_data.segments[segment_id].floor_material_rotated_direction = (
+ 0 if map_data.rotation == 0 or map_data.rotation == 180 else 90
+ )
+ else:
+ map_data.segments[segment_id].floor_material_direction = None
+ map_data.segments[segment_id].floor_material_rotated_direction = None
- for i in area_color_index:
- map_data.segments[i].color_index = area_color_index[i]
+ @staticmethod
+ def set_floor_material(map_data: MapData, capability: DreameVacuumDeviceCapability = None) -> None:
+ if map_data.segments:
+ floor_material = {}
+ for k in map_data.segments.keys():
+ DreameVacuumMapDecoder.set_segment_floor_material(map_data, k, floor_material, capability)
+ map_data.floor_material = floor_material if floor_material else None
-class DreameVacuumMapDataRenderer:
+class DreameVacuumMapDataJsonRenderer:
HALF_INT16 = 32768
HALF_INT16_UPPER_HALF = 32767
MAX = round(((HALF_INT16 + HALF_INT16_UPPER_HALF) / 10))
@@ -2632,8 +5775,8 @@ def _coordinate_tuple_sort(a: list[int], b: list[int]) -> bool:
@staticmethod
def _convert_coordinates(x: int, y: int) -> int:
return [
- round((x + DreameVacuumMapDataRenderer.HALF_INT16) / 10),
- DreameVacuumMapDataRenderer.MAX - round((y + DreameVacuumMapDataRenderer.HALF_INT16) / 10),
+ round((x + DreameVacuumMapDataJsonRenderer.HALF_INT16) / 10),
+ DreameVacuumMapDataJsonRenderer.MAX - round((y + DreameVacuumMapDataJsonRenderer.HALF_INT16) / 10),
]
@staticmethod
@@ -2644,18 +5787,17 @@ def _convert_angle(angle: int) -> int:
def _to_buffer(image, extra_data: str) -> bytes:
buffer = io.BytesIO()
info = PngImagePlugin.PngInfo()
- info.add_text("ValetudoMap", extra_data, zip=True)
+ info.add_text(MAP_DATA_JSON_CLASS, extra_data, zip=True)
image.save(buffer, format="PNG", pnginfo=info)
return buffer.getvalue()
- def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
+ def render_map(self, map_data: MapData, robot_status: int = 0, station_status: int = 0) -> bytes:
if map_data is None or map_data.empty_map:
return self.default_map_image
if (
self._map_data
and self._map_data == map_data
- and self._map_data.segments == map_data.segments
and self._map_data.frame_id == map_data.frame_id
and self._map_data_json
):
@@ -2674,22 +5816,22 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
or self._map_data.saved_map_status != map_data.saved_map_status
):
self._map_data = None
- self._left = round((map_data.dimensions.left + DreameVacuumMapDataRenderer.HALF_INT16) / 10)
- self._top = round((map_data.dimensions.top + DreameVacuumMapDataRenderer.HALF_INT16) / 10)
+ self._left = round((map_data.dimensions.left + DreameVacuumMapDataJsonRenderer.HALF_INT16) / 10)
+ self._top = round((map_data.dimensions.top + DreameVacuumMapDataJsonRenderer.HALF_INT16) / 10)
self._grid_size = round(map_data.dimensions.grid_size / 10)
map_data_json = {
- MAP_DATA_PARAMETER_CLASS: "ValetudoMap",
- MAP_DATA_PARAMETER_SIZE: {
- MAP_DATA_PARAMETER_X: DreameVacuumMapDataRenderer.MAX,
- MAP_DATA_PARAMETER_Y: DreameVacuumMapDataRenderer.MAX,
+ MAP_DATA_JSON_PARAMETER_CLASS: MAP_DATA_JSON_CLASS,
+ MAP_DATA_JSON_PARAMETER_SIZE: {
+ MAP_DATA_JSON_PARAMETER_X: DreameVacuumMapDataJsonRenderer.MAX,
+ MAP_DATA_JSON_PARAMETER_Y: DreameVacuumMapDataJsonRenderer.MAX,
},
- MAP_DATA_PARAMETER_PIXEL_SIZE: self._grid_size,
- MAP_DATA_PARAMETER_LAYERS: [],
- MAP_DATA_PARAMETER_ENTITIES: [],
- MAP_DATA_PARAMETER_META_DATA: {
- MAP_DATA_PARAMETER_VERSION: 2,
- MAP_DATA_PARAMETER_ROTATION: map_data.rotation,
+ MAP_DATA_JSON_PARAMETER_PIXEL_SIZE: self._grid_size,
+ MAP_DATA_JSON_PARAMETER_LAYERS: [],
+ MAP_DATA_JSON_PARAMETER_ENTITIES: [],
+ MAP_DATA_JSON_PARAMETER_META_DATA: {
+ MAP_DATA_JSON_PARAMETER_VERSION: 2,
+ MAP_DATA_JSON_PARAMETER_ROTATION: map_data.rotation,
},
}
@@ -2700,15 +5842,15 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
or not self._layers.get(MapRendererLayer.ROBOT)
):
self._layers[MapRendererLayer.ROBOT] = {
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_ROBOT_POSITION,
- MAP_DATA_PARAMETER_POINTS: DreameVacuumMapDataRenderer._convert_coordinates(
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_ROBOT_POSITION,
+ MAP_DATA_JSON_PARAMETER_POINTS: DreameVacuumMapDataJsonRenderer._convert_coordinates(
map_data.robot_position.x, map_data.robot_position.y
),
- MAP_DATA_PARAMETER_META_DATA: {
- MAP_PARAMETER_ANGLE: DreameVacuumMapDataRenderer._convert_angle(map_data.robot_position.a)
+ MAP_DATA_JSON_PARAMETER_META_DATA: {
+ MAP_PARAMETER_ANGLE: DreameVacuumMapDataJsonRenderer._convert_angle(map_data.robot_position.a)
},
}
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].append(self._layers[MapRendererLayer.ROBOT])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].append(self._layers[MapRendererLayer.ROBOT])
if map_data.charger_position:
if (
@@ -2717,15 +5859,17 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
or not self._layers.get(MapRendererLayer.CHARGER)
):
self._layers[MapRendererLayer.CHARGER] = {
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_CHARGER_POSITION,
- MAP_DATA_PARAMETER_POINTS: DreameVacuumMapDataRenderer._convert_coordinates(
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_CHARGER_POSITION,
+ MAP_DATA_JSON_PARAMETER_POINTS: DreameVacuumMapDataJsonRenderer._convert_coordinates(
map_data.charger_position.x, map_data.charger_position.y
),
- MAP_DATA_PARAMETER_META_DATA: {
- MAP_PARAMETER_ANGLE: DreameVacuumMapDataRenderer._convert_angle(map_data.charger_position.a)
+ MAP_DATA_JSON_PARAMETER_META_DATA: {
+ MAP_PARAMETER_ANGLE: DreameVacuumMapDataJsonRenderer._convert_angle(
+ map_data.charger_position.a
+ )
},
}
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].append(self._layers[MapRendererLayer.CHARGER])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].append(self._layers[MapRendererLayer.CHARGER])
if map_data.no_mopping_areas:
if (
@@ -2735,17 +5879,27 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
):
self._layers[MapRendererLayer.NO_MOP] = []
for area in map_data.no_mopping_areas:
- a = DreameVacuumMapDataRenderer._convert_coordinates(area.x0, area.y0)
- b = DreameVacuumMapDataRenderer._convert_coordinates(area.x1, area.y1)
- c = DreameVacuumMapDataRenderer._convert_coordinates(area.x2, area.y2)
- d = DreameVacuumMapDataRenderer._convert_coordinates(area.x3, area.y3)
- self._layers[MapRendererLayer.NO_MOP].append(
- {
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_NO_MOP_AREA,
- MAP_DATA_PARAMETER_POINTS: [a[0], a[1], b[0], b[1], c[0], c[1], d[0], d[1]],
- }
- )
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.NO_MOP])
+ if not area.hidden:
+ a = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x0, area.y0)
+ b = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x1, area.y1)
+ c = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x2, area.y2)
+ d = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x3, area.y3)
+ self._layers[MapRendererLayer.NO_MOP].append(
+ {
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_NO_MOP_AREA,
+ MAP_DATA_JSON_PARAMETER_POINTS: [
+ a[0],
+ a[1],
+ b[0],
+ b[1],
+ c[0],
+ c[1],
+ d[0],
+ d[1],
+ ],
+ }
+ )
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.NO_MOP])
if map_data.no_go_areas:
if (
@@ -2755,18 +5909,27 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
):
self._layers[MapRendererLayer.NO_GO] = []
for area in map_data.no_go_areas:
- a = DreameVacuumMapDataRenderer._convert_coordinates(area.x0, area.y0)
- b = DreameVacuumMapDataRenderer._convert_coordinates(area.x1, area.y1)
- c = DreameVacuumMapDataRenderer._convert_coordinates(area.x2, area.y2)
- d = DreameVacuumMapDataRenderer._convert_coordinates(area.x3, area.y3)
+ a = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x0, area.y0)
+ b = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x1, area.y1)
+ c = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x2, area.y2)
+ d = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x3, area.y3)
self._layers[MapRendererLayer.NO_GO].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_NO_GO_AREA,
- MAP_DATA_PARAMETER_POINTS: [a[0], a[1], b[0], b[1], c[0], c[1], d[0], d[1]],
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_NO_GO_AREA,
+ MAP_DATA_JSON_PARAMETER_POINTS: [
+ a[0],
+ a[1],
+ b[0],
+ b[1],
+ c[0],
+ c[1],
+ d[0],
+ d[1],
+ ],
}
)
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.NO_GO])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.NO_GO])
if map_data.active_areas:
if (
@@ -2776,18 +5939,27 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
):
self._layers[MapRendererLayer.ACTIVE_AREA] = []
for area in map_data.active_areas:
- a = DreameVacuumMapDataRenderer._convert_coordinates(area.x0, area.y0)
- b = DreameVacuumMapDataRenderer._convert_coordinates(area.x1, area.y1)
- c = DreameVacuumMapDataRenderer._convert_coordinates(area.x2, area.y2)
- d = DreameVacuumMapDataRenderer._convert_coordinates(area.x3, area.y3)
+ a = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x0, area.y0)
+ b = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x1, area.y1)
+ c = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x2, area.y2)
+ d = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x3, area.y3)
self._layers[MapRendererLayer.ACTIVE_AREA].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_ACTIVE_ZONE,
- MAP_DATA_PARAMETER_POINTS: [a[0], a[1], b[0], b[1], c[0], c[1], d[0], d[1]],
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_ACTIVE_ZONE,
+ MAP_DATA_JSON_PARAMETER_POINTS: [
+ a[0],
+ a[1],
+ b[0],
+ b[1],
+ c[0],
+ c[1],
+ d[0],
+ d[1],
+ ],
}
)
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.ACTIVE_AREA])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.ACTIVE_AREA])
if map_data.active_points:
if (
@@ -2809,40 +5981,50 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
point.y + size,
)
- a = DreameVacuumMapDataRenderer._convert_coordinates(area.x0, area.y0)
- b = DreameVacuumMapDataRenderer._convert_coordinates(area.x1, area.y1)
- c = DreameVacuumMapDataRenderer._convert_coordinates(area.x2, area.y2)
- d = DreameVacuumMapDataRenderer._convert_coordinates(area.x3, area.y3)
+ a = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x0, area.y0)
+ b = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x1, area.y1)
+ c = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x2, area.y2)
+ d = DreameVacuumMapDataJsonRenderer._convert_coordinates(area.x3, area.y3)
self._layers[MapRendererLayer.ACTIVE_POINT].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_ACTIVE_ZONE,
- MAP_DATA_PARAMETER_POINTS: [a[0], a[1], b[0], b[1], c[0], c[1], d[0], d[1]],
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_ACTIVE_ZONE,
+ MAP_DATA_JSON_PARAMETER_POINTS: [
+ a[0],
+ a[1],
+ b[0],
+ b[1],
+ c[0],
+ c[1],
+ d[0],
+ d[1],
+ ],
}
)
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.ACTIVE_POINT])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.ACTIVE_POINT])
- if map_data.walls:
+ if map_data.virtual_walls:
if (
self._map_data is None
- or self._map_data.walls != map_data.walls
+ or self._map_data.virtual_walls != map_data.virtual_walls
or not self._layers.get(MapRendererLayer.WALL)
):
self._layers[MapRendererLayer.WALL] = []
- for wall in map_data.walls:
- a = DreameVacuumMapDataRenderer._convert_coordinates(wall.x0, wall.y0)
- b = DreameVacuumMapDataRenderer._convert_coordinates(wall.x1, wall.y1)
+ for wall in map_data.virtual_walls:
+ a = DreameVacuumMapDataJsonRenderer._convert_coordinates(wall.x0, wall.y0)
+ b = DreameVacuumMapDataJsonRenderer._convert_coordinates(wall.x1, wall.y1)
self._layers[MapRendererLayer.WALL].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_VIRTUAL_WALL,
- MAP_DATA_PARAMETER_POINTS: [a[0], a[1], b[0], b[1]],
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_VIRTUAL_WALL,
+ MAP_DATA_JSON_PARAMETER_POINTS: [a[0], a[1], b[0], b[1]],
}
)
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.WALL])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.WALL])
- if (
+ if map_data.path and (
self._map_data is None
+ or self._map_data.path is None
or len(self._map_data.path) != len(map_data.path)
or not self._layers.get(MapRendererLayer.PATH)
):
@@ -2853,26 +6035,26 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
for point in map_data.path[1:]:
if point.path_type == PathType.LINE:
point = point
- a = DreameVacuumMapDataRenderer._convert_coordinates(s.x, s.y)
- b = DreameVacuumMapDataRenderer._convert_coordinates(point.x, point.y)
+ a = DreameVacuumMapDataJsonRenderer._convert_coordinates(s.x, s.y)
+ b = DreameVacuumMapDataJsonRenderer._convert_coordinates(point.x, point.y)
points.extend([a[0], a[1], b[0], b[1]])
else:
self._layers[MapRendererLayer.PATH].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_PATH,
- MAP_DATA_PARAMETER_POINTS: points,
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_PATH,
+ MAP_DATA_JSON_PARAMETER_POINTS: points,
}
)
points = []
s = point
self._layers[MapRendererLayer.PATH].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_PATH,
- MAP_DATA_PARAMETER_POINTS: points,
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_PATH,
+ MAP_DATA_JSON_PARAMETER_POINTS: points,
}
)
- map_data_json[MAP_DATA_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.PATH])
+ map_data_json[MAP_DATA_JSON_PARAMETER_ENTITIES].extend(self._layers[MapRendererLayer.PATH])
floor_pixels = []
wall_pixels = []
@@ -2895,7 +6077,7 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
(y + (self._top / self._grid_size)),
]
- coords[1] = (DreameVacuumMapDataRenderer.MAX / self._grid_size) - coords[1]
+ coords[1] = (DreameVacuumMapDataJsonRenderer.MAX / self._grid_size) - coords[1]
coords[0] = round(coords[0])
coords[1] = round(coords[1])
@@ -2918,12 +6100,12 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
if floor_pixels:
self._layers[MapRendererLayer.IMAGE].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_FLOOR,
- MAP_DATA_PARAMETER_PIXELS: [
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_FLOOR,
+ MAP_DATA_JSON_PARAMETER_PIXELS: [
val
for sublist in sorted(
floor_pixels,
- key=cmp_to_key(DreameVacuumMapDataRenderer._coordinate_tuple_sort),
+ key=cmp_to_key(DreameVacuumMapDataJsonRenderer._coordinate_tuple_sort),
)
for val in sublist
],
@@ -2933,12 +6115,12 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
if wall_pixels:
self._layers[MapRendererLayer.IMAGE].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_WALL,
- MAP_DATA_PARAMETER_PIXELS: [
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_WALL,
+ MAP_DATA_JSON_PARAMETER_PIXELS: [
val
for sublist in sorted(
wall_pixels,
- key=cmp_to_key(DreameVacuumMapDataRenderer._coordinate_tuple_sort),
+ key=cmp_to_key(DreameVacuumMapDataJsonRenderer._coordinate_tuple_sort),
)
for val in sublist
],
@@ -2954,41 +6136,41 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
name = map_data.segments[k].name
self._layers[MapRendererLayer.IMAGE].append(
{
- MAP_DATA_PARAMETER_TYPE: MAP_DATA_PARAMETER_SEGMENT,
- MAP_DATA_PARAMETER_PIXELS: [
+ MAP_DATA_JSON_PARAMETER_TYPE: MAP_DATA_JSON_PARAMETER_SEGMENT,
+ MAP_DATA_JSON_PARAMETER_PIXELS: [
val
for sublist in sorted(
v,
- key=cmp_to_key(DreameVacuumMapDataRenderer._coordinate_tuple_sort),
+ key=cmp_to_key(DreameVacuumMapDataJsonRenderer._coordinate_tuple_sort),
)
for val in sublist
],
- MAP_DATA_PARAMETER_META_DATA: {
- MAP_DATA_PARAMETER_SEGMENT_ID: k,
- MAP_DATA_PARAMETER_ACTIVE: (
+ MAP_DATA_JSON_PARAMETER_META_DATA: {
+ MAP_DATA_JSON_PARAMETER_SEGMENT_ID: k,
+ MAP_DATA_JSON_PARAMETER_ACTIVE: (
True if map_data.active_segments and k in map_data.active_segments else False
),
- MAP_DATA_PARAMETER_NAME: name,
+ MAP_DATA_JSON_PARAMETER_NAME: name,
},
}
)
for layers in self._layers[MapRendererLayer.IMAGE]:
- pixels = layers[MAP_DATA_PARAMETER_PIXELS]
- layers[MAP_DATA_PARAMETER_DIMENSIONS] = {
- MAP_DATA_PARAMETER_X: {
- MAP_DATA_PARAMETER_MIN: 65535,
- MAP_DATA_PARAMETER_MAX: -65535,
- MAP_DATA_PARAMETER_MID: None,
- MAP_DATA_PARAMETER_AVG: None,
+ pixels = layers[MAP_DATA_JSON_PARAMETER_PIXELS]
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS] = {
+ MAP_DATA_JSON_PARAMETER_X: {
+ MAP_DATA_JSON_PARAMETER_MIN: 65535,
+ MAP_DATA_JSON_PARAMETER_MAX: -65535,
+ MAP_DATA_JSON_PARAMETER_MID: None,
+ MAP_DATA_JSON_PARAMETER_AVG: None,
},
- MAP_DATA_PARAMETER_Y: {
- MAP_DATA_PARAMETER_MIN: 65535,
- MAP_DATA_PARAMETER_MAX: -65535,
- MAP_DATA_PARAMETER_MID: None,
- MAP_DATA_PARAMETER_AVG: None,
+ MAP_DATA_JSON_PARAMETER_Y: {
+ MAP_DATA_JSON_PARAMETER_MIN: 65535,
+ MAP_DATA_JSON_PARAMETER_MAX: -65535,
+ MAP_DATA_JSON_PARAMETER_MID: None,
+ MAP_DATA_JSON_PARAMETER_AVG: None,
},
- MAP_DATA_PARAMETER_PIXEL_COUNT: len(pixels) / 2,
+ MAP_DATA_JSON_PARAMETER_PIXEL_COUNT: len(pixels) / 2,
}
sum_x = 0
@@ -2997,51 +6179,81 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
sum_x = sum_x + pixels[i]
sum_y = sum_y + pixels[i + 1]
- if pixels[i] < layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MIN]:
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MIN] = pixels[i]
+ if (
+ pixels[i]
+ < layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_MIN
+ ]
+ ):
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_MIN
+ ] = pixels[i]
- if pixels[i] > layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MAX]:
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MAX] = pixels[i]
+ if (
+ pixels[i]
+ > layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_MAX
+ ]
+ ):
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_MAX
+ ] = pixels[i]
if (
pixels[i + 1]
- < layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MIN]
- ):
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MIN] = pixels[
- i + 1
+ < layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_MIN
]
+ ):
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_MIN
+ ] = pixels[i + 1]
if (
pixels[i + 1]
- > layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MAX]
- ):
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MAX] = pixels[
- i + 1
+ > layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_MAX
]
+ ):
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_MAX
+ ] = pixels[i + 1]
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MID] = round(
- (
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MAX]
- + layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_MIN]
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][MAP_DATA_JSON_PARAMETER_MID] = (
+ round(
+ (
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_MAX
+ ]
+ + layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_MIN
+ ]
+ )
+ / 2
)
- / 2
)
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MID] = round(
- (
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MAX]
- + layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_MIN]
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][MAP_DATA_JSON_PARAMETER_MID] = (
+ round(
+ (
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_MAX
+ ]
+ + layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_MIN
+ ]
+ )
+ / 2
)
- / 2
)
if sum_x:
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_X][MAP_DATA_PARAMETER_AVG] = round(
- sum_x / (len(pixels) / 2)
- )
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_X][
+ MAP_DATA_JSON_PARAMETER_AVG
+ ] = round(sum_x / (len(pixels) / 2))
if sum_y:
- layers[MAP_DATA_PARAMETER_DIMENSIONS][MAP_DATA_PARAMETER_Y][MAP_DATA_PARAMETER_AVG] = round(
- sum_y / (len(pixels) / 2)
- )
+ layers[MAP_DATA_JSON_PARAMETER_DIMENSIONS][MAP_DATA_JSON_PARAMETER_Y][
+ MAP_DATA_JSON_PARAMETER_AVG
+ ] = round(sum_y / (len(pixels) / 2))
current_x_start = -65535
current_y = -65535
@@ -3061,10 +6273,10 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
current_count = current_count + 1
compressed_pixels.extend([current_x_start, current_y, current_count])
- layers[MAP_DATA_PARAMETER_COMPRESSED_PIXELS] = compressed_pixels[3:]
- layers[MAP_DATA_PARAMETER_PIXELS] = []
+ layers[MAP_DATA_JSON_PARAMETER_COMPRESSED_PIXELS] = compressed_pixels[3:]
+ layers[MAP_DATA_JSON_PARAMETER_PIXELS] = []
- map_data_json[MAP_DATA_PARAMETER_LAYERS].extend(self._layers[MapRendererLayer.IMAGE])
+ map_data_json[MAP_DATA_JSON_PARAMETER_LAYERS].extend(self._layers[MapRendererLayer.IMAGE])
self._map_data = map_data
self._map_data_json = map_data_json
@@ -3086,19 +6298,24 @@ def default_map_image(self) -> bytes:
@property
def disconnected_map_image(self) -> bytes:
- return self.default_map_image
+ return self._default_map_image
class DreameVacuumMapRenderer:
+ MAP_FONT_UNPACKED = None
+
def __init__(
self,
color_scheme: str = None,
- icon_set: str = None,
+ icon_set: int = None,
hidden_map_objects: list[str] = None,
- robot_shape: int = 0,
+ robot_type: int = 0,
+ low_resolution: bool = False,
+ square: bool = False,
+ cache: bool = True,
) -> None:
self.color_scheme: MapRendererColorScheme = MAP_COLOR_SCHEME_LIST.get(color_scheme, MapRendererColorScheme())
- self.icon_set: int = MAP_ICON_SET_LIST.get(icon_set, 0)
+ self.icon_set: int = icon_set
self.config: MapRendererConfig = MapRendererConfig()
if hidden_map_objects is not None:
for attr in self.config.__dict__.keys():
@@ -3109,20 +6326,44 @@ def __init__(
self.render_complete: bool = True
self._layers: dict[MapRendererLayer, Any] = {}
self._robot_status: int = None
- self._robot_shape: int = robot_shape
+ self._station_status: int = None
+ self._robot_type: int = robot_type
+ self._low_resolution: bool = low_resolution
+ self._low_memory: bool = low_resolution
+ self._square: bool = square
+ self._cache: bool = cache
+ self._has_mask: bool = False
self._calibration_points: dict[str, int] = None
self._default_calibration_points: dict[str, int] = [
{
- MAP_PARAMETER_VACUUM: {MAP_DATA_PARAMETER_X: 0, MAP_DATA_PARAMETER_Y: 0},
- MAP_PARAMETER_MAP: {MAP_DATA_PARAMETER_X: 0, MAP_DATA_PARAMETER_Y: 0},
+ MAP_PARAMETER_VACUUM: {
+ MAP_DATA_JSON_PARAMETER_X: 0,
+ MAP_DATA_JSON_PARAMETER_Y: 0,
+ },
+ MAP_PARAMETER_MAP: {
+ MAP_DATA_JSON_PARAMETER_X: 0,
+ MAP_DATA_JSON_PARAMETER_Y: 0,
+ },
},
{
- MAP_PARAMETER_VACUUM: {MAP_DATA_PARAMETER_X: 1000, MAP_DATA_PARAMETER_Y: 0},
- MAP_PARAMETER_MAP: {MAP_DATA_PARAMETER_X: 0, MAP_DATA_PARAMETER_Y: 0},
+ MAP_PARAMETER_VACUUM: {
+ MAP_DATA_JSON_PARAMETER_X: 1000,
+ MAP_DATA_JSON_PARAMETER_Y: 0,
+ },
+ MAP_PARAMETER_MAP: {
+ MAP_DATA_JSON_PARAMETER_X: 0,
+ MAP_DATA_JSON_PARAMETER_Y: 0,
+ },
},
{
- MAP_PARAMETER_VACUUM: {MAP_DATA_PARAMETER_X: 0, MAP_DATA_PARAMETER_Y: 1000},
- MAP_PARAMETER_MAP: {MAP_DATA_PARAMETER_X: 0, MAP_DATA_PARAMETER_Y: 0},
+ MAP_PARAMETER_VACUUM: {
+ MAP_DATA_JSON_PARAMETER_X: 0,
+ MAP_DATA_JSON_PARAMETER_Y: 1000,
+ },
+ MAP_PARAMETER_MAP: {
+ MAP_DATA_JSON_PARAMETER_X: 0,
+ MAP_DATA_JSON_PARAMETER_Y: 0,
+ },
},
]
@@ -3134,64 +6375,87 @@ def __init__(
self._robot_warning_icon = None
self._robot_sleeping_icon = None
self._robot_washing_icon = None
+ self._robot_hot_washing_icon = None
+ self._robot_drying_icon = None
+ self._robot_hot_drying_icon = None
+ self._robot_dust_bag_drying_icon = None
+ self._robot_emptying_icon = None
self._robot_cleaning_direction_icon = None
self._obstacle_background = None
+ self._obstacle_hidden_background = None
+ self._cruise_path_point_background = None
+ self._cruise_point_background = None
+ self._furniture_background = None
+ self._wifi_icon = None
+ self._font_file = None
+ self._light_font_file = None
+ self._default_map_image = None
+ self._obstacle_bottom_left_icon = None
+ self._obstacle_top_left_icon = None
+ self._obstacle_bottom_right_icon = None
+ self._obstacle_top_right_icon = None
+ self._map_problem_icon = None
- default_map_image = Image.open(BytesIO(base64.b64decode(DEFAULT_MAP_IMAGE))).convert("RGBA")
- self._default_map_image = ImageOps.expand(
- default_map_image.resize(
- (
- int(default_map_image.size[0] * 0.8),
- int(default_map_image.size[1] * 0.8),
- )
- ),
- border=(50, 75, 50, 75),
- )
+ self._segment_icons = {}
+ self._obstacle_icons = {}
+ self._obstacle_hidden_icons = {}
+ self._furniture_icons = {}
+ self._furniture_images = {}
- icon_set = SEGMENT_ICONS_DREAME
- repeats = MAP_ICON_REPEATS_DREAME
- suction_level = MAP_ICON_SUCTION_LEVEL_DREAME
- water_volume = MAP_ICON_WATER_VOLUME_DREAME
- cleaning_mode = MAP_ICON_CLEANING_MODE_DREAME
+ if self._low_memory:
+ self.config.obstacle = False
+ self.config.pet = False
+ self.config.furniture = False
- self._segment_icons = {}
- if self.icon_set == 1:
- icon_set = SEGMENT_ICONS_DREAME_OLD
- elif self.icon_set == 2:
- icon_set = SEGMENT_ICONS_MIJIA
+ if self.icon_set == 2:
repeats = MAP_ICON_REPEATS_MIJIA
suction_level = MAP_ICON_SUCTION_LEVEL_MIJIA
water_volume = MAP_ICON_WATER_VOLUME_MIJIA
cleaning_mode = MAP_ICON_CLEANING_MODE_MIJIA
elif self.icon_set == 3:
- icon_set = SEGMENT_ICONS_MATERIAL
repeats = MAP_ICON_REPEATS_MATERIAL
suction_level = MAP_ICON_SUCTION_LEVEL_MATERIAL
water_volume = MAP_ICON_WATER_VOLUME_MATERIAL
cleaning_mode = MAP_ICON_CLEANING_MODE_MATERIAL
-
- self._cleaning_times_icon = [Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in repeats]
- self._suction_level_icon = [
- Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in suction_level
- ]
- self._water_volume_icon = [
- Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in water_volume
- ]
- self._cleaning_mode_icon = [
- Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in cleaning_mode
- ]
-
- for k, v in icon_set.items():
- self._segment_icons[k] = Image.open(BytesIO(base64.b64decode(v))).convert("RGBA")
- if self.color_scheme.invert:
- enhancer = ImageEnhance.Brightness(self._segment_icons[k])
- self._segment_icons[k] = enhancer.enhance(0.1)
-
- self._obstacle_icons = {}
- for k, v in OBSTACLE_TYPE_TO_ICON.items():
- self._obstacle_icons[k] = Image.open(BytesIO(base64.b64decode(v))).convert("RGBA")
-
- self.font_file = zlib.decompress(base64.b64decode(MAP_FONT), zlib.MAX_WBITS | 32)
+ else:
+ repeats = MAP_ICON_REPEATS_DREAME
+ suction_level = MAP_ICON_SUCTION_LEVEL_DREAME
+ water_volume = MAP_ICON_WATER_VOLUME_DREAME
+ cleaning_mode = MAP_ICON_CLEANING_MODE_DREAME
+
+ if self.config.cleaning_times:
+ self._cleaning_times_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in repeats
+ ]
+ if self.config.suction_level:
+ self._suction_level_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in suction_level
+ ]
+ if self.config.water_volume:
+ self._water_volume_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in water_volume
+ ]
+ self._mop_pad_humidity_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA")
+ for icon in (
+ MAP_ICON_MOP_PAD_HUMIDITY_MATERIAL if self.icon_set == 3 else MAP_ICON_MOP_PAD_HUMIDITY_DREAME
+ )
+ ]
+ if self.config.cleaning_mode:
+ self._cleaning_mode_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA") for icon in cleaning_mode
+ ]
+ if self.config.mopping_mode:
+ self._cleaning_route_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA")
+ for icon in (
+ MAP_ICON_CLEANING_ROUTE_MATERIAL if self.icon_set == 3 else MAP_ICON_CLEANING_ROUTE_DREAME
+ )
+ ]
+ self._custom_mopping_route_icon = [
+ Image.open(BytesIO(base64.b64decode(icon))).convert("RGBA")
+ for icon in MAP_ICON_CUSTOM_MOPPING_ROUTE_DREAME
+ ]
@staticmethod
def _to_buffer(image) -> bytes:
@@ -3232,11 +6496,28 @@ def _calculate_bounds(dimensions, segments) -> list[int]:
min_y = min(min(y_coords), min_y)
max_y = max(max(y_coords), max_y)
- return [min_x, min_y, max_x, max_y]
+ return [min_x, min_y, max_x, min_y]
@staticmethod
def _calculate_padding(
- dimensions, active_areas, no_mopping_areas, no_go_areas, walls, segments, padding, min_width, min_height, scale
+ dimensions,
+ active_areas,
+ no_mopping_areas,
+ no_go_areas,
+ walls,
+ virtual_thresholds,
+ passable_thresholds,
+ impassable_thresholds,
+ ramps,
+ furnitures,
+ furniture_version,
+ curtains,
+ segments,
+ padding,
+ min_width,
+ min_height,
+ scale,
+ icon_set,
) -> list[int]:
min_x = 0
min_y = 0
@@ -3293,6 +6574,84 @@ def _calculate_padding(
min_y = min(min(y_coords), min_y)
max_y = max(max(y_coords), max_y)
+ if virtual_thresholds:
+ for line in virtual_thresholds:
+ p = line.to_coord(dimensions)
+ x_coords = [p.x0, p.x1]
+ y_coords = [p.y0, p.y1]
+ min_x = min(min(x_coords), min_x)
+ max_x = max(max(x_coords), max_x)
+ min_y = min(min(y_coords), min_y)
+ max_y = max(max(y_coords), max_y)
+
+ if passable_thresholds:
+ for line in passable_thresholds:
+ p = line.to_coord(dimensions)
+ x_coords = [p.x0, p.x1]
+ y_coords = [p.y0, p.y1]
+ min_x = min(min(x_coords), min_x)
+ max_x = max(max(x_coords), max_x)
+ min_y = min(min(y_coords), min_y)
+ max_y = max(max(y_coords), max_y)
+
+ if impassable_thresholds:
+ for line in impassable_thresholds:
+ p = line.to_coord(dimensions)
+ x_coords = [p.x0, p.x1]
+ y_coords = [p.y0, p.y1]
+ min_x = min(min(x_coords), min_x)
+ max_x = max(max(x_coords), max_x)
+ min_y = min(min(y_coords), min_y)
+ max_y = max(max(y_coords), max_y)
+
+ if ramps:
+ for area in ramps:
+ p = area.to_coord(dimensions)
+ x_coords = [p.x0, p.x1, p.x2, p.x3]
+ y_coords = [p.y0, p.y1, p.y2, p.y3]
+ min_x = min(min(x_coords), min_x)
+ max_x = max(max(x_coords), max_x)
+ min_y = min(min(y_coords), min_y)
+ max_y = max(max(y_coords), max_y)
+
+ if furnitures:
+ if furniture_version >= 3:
+ furniture_images = (
+ FURNITURE_V2_TYPE_MIJIA_TO_IMAGE
+ if furniture_version == 5
+ else FURNITURE_V3_TYPE_TO_IMAGE if furniture_version == 6 else FURNITURE_V2_TYPE_TO_IMAGE
+ )
+ furniture_icons = FURNITURE_V2_TYPE_TO_ICON
+ else:
+ furniture_images = FURNITURE_TYPE_TO_IMAGE
+ furniture_icons = FURNITURE_TYPE_TO_ICON
+
+ for k, v in furnitures.items():
+ p = Point(v.x, v.y).to_coord(dimensions)
+ w = 0
+ h = 0
+ if v.width and v.height:
+ if v.type.value not in furniture_images:
+ continue
+ w = int((v.width / dimensions.grid_size) / 2)
+ h = int((v.height / dimensions.grid_size) / 2)
+ elif v.type.value not in furniture_icons:
+ continue
+ min_x = min(p.x - w, min_x)
+ max_x = max(p.x + w, max_x)
+ min_y = min(p.y - h, min_y)
+ max_y = max(p.y + h, max_y)
+
+ if curtains:
+ for line in curtains:
+ p = line.to_coord(dimensions)
+ x_coords = [p.x0, p.x1]
+ y_coords = [p.y0, p.y1]
+ min_x = min(min(x_coords), min_x)
+ max_x = max(max(x_coords), max_x)
+ min_y = min(min(y_coords), min_y)
+ max_y = max(max(y_coords), max_y)
+
if min_x < 0:
padding[0] = padding[0] + int(-min_x)
if max_x > dimensions.width:
@@ -3317,6 +6676,118 @@ def _calculate_padding(
return padding
+ @staticmethod
+ def _round_coord(coord, grid_size):
+ remainder = coord % grid_size
+ if remainder <= grid_size / 2:
+ return coord - remainder
+ return coord + grid_size - remainder
+
+ @staticmethod
+ def _get_carpet_coords(carpet, dimensions):
+ grid_size = dimensions.grid_size
+ if carpet.ellipse:
+ x0 = DreameVacuumMapRenderer._round_coord(carpet.x0 - dimensions.offset, grid_size) + dimensions.offset
+ y0 = DreameVacuumMapRenderer._round_coord(carpet.y0 - dimensions.offset, grid_size) + dimensions.offset
+ x2 = DreameVacuumMapRenderer._round_coord(carpet.x2, grid_size)
+ y2 = DreameVacuumMapRenderer._round_coord(carpet.y2, grid_size)
+
+ x_coords = sorted([x0, x2])
+ y_coords = sorted([y0, y2])
+
+ return (
+ int(math.ceil((x_coords[0] - x_coords[1] - dimensions.left) / grid_size)),
+ int(math.ceil((y_coords[0] - y_coords[1] - dimensions.top) / grid_size)),
+ int(math.ceil(((x_coords[0] + x_coords[1] - dimensions.left) / grid_size) + 1)),
+ int(math.ceil(((y_coords[0] + y_coords[1] - dimensions.top) / grid_size) + 1)),
+ )
+ else:
+ left = dimensions.left
+ top = dimensions.top
+ if left % dimensions.grid_size != 0 or top % dimensions.grid_size != 0:
+ left = left + (dimensions.offset)
+ top = top + (dimensions.offset)
+
+ x_coords = sorted([carpet.x0, carpet.x2])
+ y_coords = sorted([carpet.y0, carpet.y2])
+
+ return (
+ int(math.ceil((x_coords[0] - left) / grid_size)),
+ int(math.ceil((y_coords[0] - top) / grid_size)),
+ int(math.ceil((x_coords[1] - left) / grid_size)),
+ int(math.ceil((y_coords[1] - top) / grid_size)),
+ )
+
+ @staticmethod
+ def _optimize_carpet_pixels(carpet_pixels, dimensions, pixel_type):
+ carpet_data = {}
+ for pixel in carpet_pixels:
+ x = pixel[0]
+ y = pixel[1]
+ for xx in range(max(0, x - 1), min(x + 3, dimensions.width - 1)):
+ for yy in range(max(0, y - 1), min(y + 2, dimensions.height - 1)):
+ val = int(pixel_type[xx, yy])
+ if val > 0 and val <= 100:
+ carpet_data[(xx, yy)] = 1
+ return carpet_data
+
+ @staticmethod
+ def _check_carpet(x, y, carpet, dimensions, pixel_type=None):
+ if pixel_type is not None and (
+ pixel_type > 100
+ or pixel_type <= 0
+ or (pixel_type <= 100 and not carpet.polygon and carpet.segments and pixel_type not in carpet.segments)
+ ):
+ return False
+
+ if carpet.ellipse or carpet.ignored_areas or carpet.polygon:
+ x = (x * dimensions.grid_size) + dimensions.left
+ y = (y * dimensions.grid_size) + dimensions.top
+
+ if carpet.ellipse and not (
+ (x - carpet.x0) * (x - carpet.x0) / (carpet.x2 * carpet.x2)
+ + (y - carpet.y0) * (y - carpet.y0) / (carpet.y2 * carpet.y2)
+ < 1
+ ):
+ return False
+
+ if carpet.ignored_areas and isinstance(carpet.ignored_areas, list):
+ for area in carpet.ignored_areas:
+ if (
+ area
+ and isinstance(area, list)
+ and len(area) > 3
+ and x >= area[0]
+ and x <= area[2]
+ and y >= area[1]
+ and y <= area[3]
+ ):
+ return False
+
+ if carpet.polygon and len(carpet.polygon) <= 100:
+ check = False
+ polygon = carpet.polygon
+ for i in range(0, len(polygon), 2):
+ j = len(polygon) - 2 if i == 0 else i - 2
+
+ sx = polygon[i]
+ sy = polygon[i + 1]
+ tx = polygon[j]
+ ty = polygon[j + 1]
+
+ if sx == x and sy == y and tx == x and ty == y:
+ return True
+ if sy == ty and sy == y and (sx > x and tx < x or sx < x and tx > x):
+ return True
+ if sy < y and ty >= y or sy >= y and ty < y:
+ xx = sx + (y - sy) * (tx - sx) / (ty - sy)
+ if xx == x:
+ return True
+ if xx > x:
+ check = not check
+ return check
+ return True
+
@staticmethod
def _calculate_calibration_points(map_data: MapData) -> dict[str, int] | None:
if (map_data.dimensions.width * map_data.dimensions.height) > 0:
@@ -3325,16 +6796,1011 @@ def _calculate_calibration_points(map_data: MapData) -> dict[str, int] | None:
img_point = point.to_img(map_data.dimensions).rotated(map_data.dimensions, map_data.rotation)
calibration_points.append(
{
- MAP_PARAMETER_VACUUM: {MAP_DATA_PARAMETER_X: point.x, MAP_DATA_PARAMETER_Y: point.y},
+ MAP_PARAMETER_VACUUM: {
+ MAP_DATA_JSON_PARAMETER_X: point.x,
+ MAP_DATA_JSON_PARAMETER_Y: point.y,
+ },
MAP_PARAMETER_MAP: {
- MAP_DATA_PARAMETER_X: int(img_point.x),
- MAP_DATA_PARAMETER_Y: int(img_point.y),
+ MAP_DATA_JSON_PARAMETER_X: int(img_point.x),
+ MAP_DATA_JSON_PARAMETER_Y: int(img_point.y),
},
}
)
return calibration_points
- def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
+ @staticmethod
+ def _alpha_composite(source, destination):
+ srcA = source[3] / 255.0
+ dstA = destination[3] / 255.0
+ outA = srcA + dstA * (1 - srcA)
+ if outA:
+ outRGB = []
+ for i in range(3):
+ outRGB.append((float(source[i]) * srcA + float(destination[i]) * dstA * (1 - srcA)) / outA)
+ return (int(outRGB[0]), int(outRGB[1]), int(outRGB[2]), int(outA * 255))
+ return source
+
+ @staticmethod
+ def _combine_layers(cached_layers, layer_size, parent, sub):
+ cached_layers[parent] = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ if sub in cached_layers:
+ for k, v in sorted(cached_layers[sub].items()):
+ if v is not None:
+ try:
+ cached_layers[parent] = Image.alpha_composite(cached_layers[parent], v)
+ except:
+ pass
+
+ @staticmethod
+ def _coords_on_line(x0, y0, x1, y1, spacing, size=None):
+ x = x1 - x0
+ y = y1 - y0
+ count = size - 1 if size else math.floor(math.sqrt(x * x + y * y) / spacing)
+ points = []
+ for i in range(count + 1):
+ points.append((x0 + x * (i / count), y0 + y * (i / count)))
+ return points
+
+ @staticmethod
+ def color_to_tuple(color: str):
+ if not color or len(color) < 3:
+ return None
+
+ color = color.strip().lower()
+ if color.startswith("#"):
+ hex_value = color[1:]
+ if len(hex_value) == 3:
+ r = int(hex_value[0] * 2, 16)
+ g = int(hex_value[1] * 2, 16)
+ b = int(hex_value[2] * 2, 16)
+ return (r, g, b, 255)
+ if len(hex_value) == 4:
+ r = int(hex_value[0] * 2, 16)
+ g = int(hex_value[1] * 2, 16)
+ b = int(hex_value[2] * 2, 16)
+ a = int(hex_value[3] * 2, 16)
+ return (r, g, b, a)
+ if len(hex_value) == 6:
+ r = int(hex_value[0:2], 16)
+ g = int(hex_value[2:4], 16)
+ b = int(hex_value[4:6], 16)
+ return (r, g, b, 255)
+ if len(hex_value) == 8:
+ r = int(hex_value[0:2], 16)
+ g = int(hex_value[2:4], 16)
+ b = int(hex_value[4:6], 16)
+ a = int(hex_value[6:8], 16)
+ return (r, g, b, a)
+ return None
+
+ rgb_match = re.match(r"rgba?\((.*?)\)", color)
+ if rgb_match:
+ parts = [p.strip() for p in rgb_match.group(1).split(",")]
+ if len(parts) == 3:
+ r, g, b = map(int, parts)
+ return (r, g, b, 255)
+ if len(parts) == 4:
+ r, g, b = map(int, parts[:3])
+ a = float(parts[3])
+ return (r, g, b, a)
+ return None
+ return None
+
+ @staticmethod
+ def get_resources(capability, icon_set, as_json=False) -> MapRendererResources | str:
+ if icon_set == 2:
+ if capability.robot_type == RobotType.MOPPING:
+ robot_image = MAP_ROBOT_MOP_IMAGE_MIJIA
+ elif capability.robot_type == RobotType.VSLAM:
+ robot_image = MAP_ROBOT_VSLAM_IMAGE_MIJIA
+ else:
+ robot_image = MAP_ROBOT_LIDAR_IMAGE_MIJIA
+ else:
+ if capability.robot_type == RobotType.MOPPING:
+ robot_image = MAP_ROBOT_MOP_IMAGE_DREAME
+ elif capability.robot_type == RobotType.SWEEPING_AND_MOPPING:
+ robot_image = MAP_ROBOT_LIDAR_IMAGE_DREAME_LIGHT
+ elif capability.robot_type == RobotType.VSLAM:
+ if icon_set == 3:
+ robot_image = MAP_ROBOT_VSLAM_IMAGE_DREAME_LIGHT
+ else:
+ robot_image = MAP_ROBOT_VSLAM_IMAGE_DREAME_DARK
+ else:
+ if icon_set == 3:
+ robot_image = MAP_ROBOT_LIDAR_IMAGE_DREAME_LIGHT
+ else:
+ robot_image = MAP_ROBOT_LIDAR_IMAGE_DREAME_DARK
+
+ if icon_set == 3:
+ charger_image = MAP_CHARGER_IMAGE_MATERIAL
+ elif icon_set == 2:
+ charger_image = MAP_CHARGER_IMAGE_MIJIA
+ else:
+ if capability.robot_type == RobotType.VSLAM:
+ charger_image = MAP_CHARGER_VSLAM_IMAGE_DREAME
+ else:
+ charger_image = MAP_CHARGER_IMAGE_DREAME
+
+ icons = SEGMENT_ICONS_DREAME
+ if icon_set == 1:
+ icons = SEGMENT_ICONS_DREAME_OLD
+ elif icon_set == 2:
+ icons = SEGMENT_ICONS_MIJIA
+ elif icon_set == 3:
+ icons = SEGMENT_ICONS_MATERIAL
+
+ if icon_set == 2:
+ repeats = MAP_ICON_REPEATS_MIJIA
+ suction_level = MAP_ICON_SUCTION_LEVEL_MIJIA
+ water_volume = MAP_ICON_WATER_VOLUME_MIJIA
+ cleaning_mode = MAP_ICON_CLEANING_MODE_MIJIA
+ elif icon_set == 3:
+ repeats = MAP_ICON_REPEATS_MATERIAL
+ suction_level = MAP_ICON_SUCTION_LEVEL_MATERIAL
+ water_volume = MAP_ICON_WATER_VOLUME_MATERIAL
+ cleaning_mode = MAP_ICON_CLEANING_MODE_MATERIAL
+ else:
+ repeats = MAP_ICON_REPEATS_DREAME
+ suction_level = MAP_ICON_SUCTION_LEVEL_DREAME
+ water_volume = MAP_ICON_WATER_VOLUME_DREAME
+ cleaning_mode = MAP_ICON_CLEANING_MODE_DREAME
+
+ if DreameVacuumMapRenderer.MAP_FONT_UNPACKED is None:
+ DreameVacuumMapRenderer.MAP_FONT_UNPACKED = zlib.decompress(
+ base64.b64decode(MAP_FONT_LIGHT), zlib.MAX_WBITS | 32
+ )
+
+ resources = MapRendererResources(
+ icon_set=icon_set,
+ robot_type=capability.robot_type.value,
+ robot=robot_image,
+ charger=charger_image,
+ charging=MAP_ROBOT_CHARGING_IMAGE,
+ cleaning=MAP_ROBOT_CLEANING_IMAGE,
+ warning=MAP_ROBOT_WARNING_IMAGE,
+ sleeping=MAP_ROBOT_SLEEPING_IMAGE,
+ cleaning_direction=MAP_ROBOT_CLEANING_DIRECTION_IMAGE,
+ selected_segment=MAP_ICON_SELECTED_SEGMENT,
+ cruise_point_background=MAP_ICON_CRUISE_POINT_DREAME,
+ segment={k: {"name": SEGMENT_TYPE_CODE_TO_NAME.get(k), "icon": v} for k, v in icons.items()},
+ default_map_image=DEFAULT_MAP_IMAGE,
+ font=base64.b64encode(DreameVacuumMapRenderer.MAP_FONT_UNPACKED).decode("utf-8"),
+ rotate=MAP_ICON_ROTATE,
+ delete=MAP_ICON_DELETE,
+ resize=MAP_ICON_RESIZE,
+ move=MAP_ICON_MOVE,
+ problem=MAP_ICON_PROBLEM,
+ clean=MAP_ICON_CLEAN,
+ settings=MAP_ICON_SETTINGS,
+ edit=MAP_ICON_EDIT,
+ )
+
+ if capability.customized_cleaning:
+ resources.repeats = repeats
+ resources.suction_level = suction_level
+ resources.water_volume = water_volume
+ resources.mop_pad_humidity = (
+ MAP_ICON_MOP_PAD_HUMIDITY_MATERIAL if icon_set == 3 else MAP_ICON_MOP_PAD_HUMIDITY_DREAME
+ )
+ if capability.custom_cleaning_mode:
+ resources.cleaning_mode = cleaning_mode
+ if capability.cleaning_route:
+ resources.cleaning_route = (
+ MAP_ICON_CLEANING_ROUTE_MATERIAL if icon_set == 3 else MAP_ICON_CLEANING_ROUTE_DREAME
+ )
+ elif capability.segment_mopping_settings:
+ resources.custom_mopping_route = MAP_ICON_CUSTOM_MOPPING_ROUTE_DREAME
+
+ if capability.mop_temperature:
+ resources.mop_temperature = (
+ MAP_ICON_MOP_TEMPERATURE_MATERIAL if icon_set == 3 else MAP_ICON_MOP_TEMPERATURE_DREAME
+ )
+
+ if capability.mop_pressure:
+ resources.mop_pressure = (
+ MAP_ICON_MOP_PRESSURE_MATERIAL if icon_set == 3 else MAP_ICON_MOP_PRESSURE_DREAME
+ )
+
+ if capability.self_wash_base:
+ resources.washing = MAP_ROBOT_WASHING_IMAGE
+ resources.drying = MAP_ROBOT_DRYING_IMAGE
+ if capability.hot_washing:
+ resources.hot_washing = MAP_ROBOT_HOT_WASHING_IMAGE
+ resources.hot_drying = MAP_ROBOT_HOT_DRYING_IMAGE
+
+ if capability.auto_empty_base:
+ resources.emptying = MAP_ROBOT_EMPTYING_IMAGE
+ resources.emptying_animation = MAP_ROBOT_EMPTYING_ANIMATION
+
+ if capability.dust_bag_drying or capability.manual_dust_bag_drying:
+ resources.dust_bag_drying = MAP_ROBOT_DUST_BAG_DRYING_IMAGE
+ resources.dust_bag_drying_animation = MAP_ROBOT_DUST_BAG_DRYING_ANIMATION
+
+ if capability.wifi_map:
+ resources.wifi = MAP_WIFI_IMAGE_DREAME
+
+ if capability.camera_streaming or capability.furnitures_v2 or capability.saved_furnitures:
+ resources.cruise_path_point_background = MAP_ICON_CRUISE_POINT_BG_DREAME
+ resources.obstacle_background = MAP_ICON_OBSTACLE_BG_DREAME
+ resources.obstacle_hidden_background = MAP_ICON_OBSTACLE_HIDDEN_BG_DREAME
+ resources.obstacle = {
+ i.value: {
+ "name": i.name.replace("_", " ").capitalize(),
+ "icon": OBSTACLE_TYPE_TO_ICON.get(i.value),
+ "hidden_icon": OBSTACLE_TYPE_TO_HIDDEN_ICON.get(i.value),
+ }
+ for i in ObstacleType
+ }
+ furniture_types = [i for i in FurnitureType]
+ if not capability.pet_furniture:
+ furniture_types = list(
+ set(furniture_types)
+ - set(
+ [
+ FurnitureType.LITTER_BOX,
+ FurnitureType.PET_BED,
+ FurnitureType.FOOD_BOWL,
+ FurnitureType.PET_TOILET,
+ FurnitureType.ENCLOSED_LITTER_BOX,
+ ]
+ )
+ )
+
+ if not capability.extended_furnitures:
+ furniture_types = list(set(furniture_types) - set([i for i in FurnitureType if i.value > 13]))
+ if capability.furnitures_v2:
+ furniture_types.remove(8)
+ furniture_types.insert(7, FurnitureType.ROUND_COFFEE_TABLE)
+
+ if capability.furnitures_v2:
+ if icon_set == 2 and capability.mijia:
+ dimensions = FURNITURE_V2_TYPE_MIJIA_TO_DIMENSIONS
+ images = FURNITURE_V2_TYPE_MIJIA_TO_IMAGE
+ else:
+ dimensions = FURNITURE_V2_TYPE_TO_DIMENSIONS
+ images = FURNITURE_V3_TYPE_TO_IMAGE if capability.furnitures_v3 else FURNITURE_V2_TYPE_TO_IMAGE
+
+ resources.furniture = {
+ i.value: {
+ "name": i.name.replace("_", " ").capitalize(),
+ "icon": FURNITURE_V2_TYPE_TO_ICON.get(i.value),
+ "image": images.get(i.value),
+ "dimensions": dimensions.get(i.value),
+ }
+ for i in furniture_types
+ if i.value in dimensions
+ }
+ else:
+ resources.furniture = {
+ i.value: {
+ "name": i.name.replace("_", " ").capitalize(),
+ "icon": FURNITURE_V2_TYPE_TO_ICON.get(i.value),
+ "image": FURNITURE_TYPE_TO_IMAGE.get(i.value),
+ "dimensions": FURNITURE_TYPE_TO_DIMENSIONS.get(i.value),
+ }
+ for i in furniture_types
+ }
+
+ if as_json:
+ resources = json.dumps(
+ resources,
+ default=lambda o: dict((key, value) for key, value in o.__dict__.items() if value is not None),
+ allow_nan=False,
+ sort_keys=True,
+ separators=(",", ":"),
+ )
+
+ return resources
+
+ @staticmethod
+ def get_data(
+ map_data: MapData,
+ capability: DreameVacuumDeviceCapability,
+ icon_set: int = 0,
+ include_resources: bool = False,
+ robot_status: int = 0,
+ station_status: int = 0,
+ as_string: bool = True,
+ ) -> str:
+ resources = DreameVacuumMapRenderer.get_resources(capability, icon_set) if include_resources else None
+
+ if not map_data or map_data.empty_map or (map_data.dimensions.width * map_data.dimensions.height) < 2:
+ map_data_json = MapRendererData(
+ size=[
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 0,
+ 0,
+ [0, 0, 0, 0],
+ ],
+ data=None,
+ empty_map=True,
+ resources=resources,
+ )
+ else:
+ if map_data.optimized_pixel_type is not None:
+ map_data.pixel_type = map_data.optimized_pixel_type
+ map_data.dimensions = map_data.optimized_dimensions
+ if map_data.optimized_charger_position is not None:
+ map_data.charger_position = map_data.optimized_charger_position
+
+ pixels = {}
+ min_x = map_data.dimensions.width - 1
+ min_y = map_data.dimensions.height - 1
+ max_x = 0
+ max_y = 0
+ for y in range(map_data.dimensions.height):
+ for x in range(map_data.dimensions.width):
+ px_type = int(map_data.pixel_type[x, y])
+ if px_type:
+ if px_type in pixels:
+ pixels[px_type].extend([x, y])
+ else:
+ pixels[px_type] = [x, y]
+ max_x = max(x, max_x)
+ min_x = min(x, min_x)
+ max_y = max(y, max_y)
+ min_y = min(y, min_y)
+
+ if map_data.carpet_pixels:
+ px_type = 512
+ for px in map_data.carpet_pixels:
+ if px_type in pixels:
+ pixels[px_type].extend([px[0], px[1]])
+ else:
+ pixels[px_type] = [px[0], px[1]]
+
+ crop = [0, 0, 0, 0]
+
+ if not map_data.saved_map:
+ map_data.dimensions.bounds = DreameVacuumMapRenderer._calculate_bounds(
+ map_data.dimensions, map_data.segments
+ )
+
+ if map_data.dimensions.bounds:
+ min_x = max(min(map_data.dimensions.bounds[0], min_x), min_x)
+ max_x = min(max(map_data.dimensions.bounds[2], max_x), max_x)
+ min_y = max(min(map_data.dimensions.bounds[1], min_y), min_y)
+ max_y = min(max(map_data.dimensions.bounds[3], max_y), max_y)
+
+ if (
+ min_x != (map_data.dimensions.width - 1)
+ and min_y != (map_data.dimensions.height - 1)
+ and max_x != 0
+ and max_y != 0
+ ) and (
+ min_x != 0
+ or min_y != 0
+ or max_x != (map_data.dimensions.width - 1)
+ or max_y != (map_data.dimensions.height - 1)
+ ):
+ crop = [
+ min_x,
+ (map_data.dimensions.height - (max_y + 1)),
+ (map_data.dimensions.width - (max_x + 1)),
+ min_y,
+ ]
+
+ for layer in pixels.keys():
+ current_x_start = -1
+ current_y = -1
+ current_count = 0
+ compressed_pixels = []
+ coords = pixels[layer]
+ for i in range(0, len(coords), 2):
+ x = coords[i]
+ y = coords[i + 1]
+ if y != current_y or x > (current_x_start + current_count):
+ compressed_pixels.extend([current_x_start, current_y, current_count])
+ current_x_start = x
+ current_y = y
+ current_count = 1
+ elif x != current_x_start:
+ current_count = current_count + 1
+ compressed_pixels.extend([current_x_start, current_y, current_count])
+ pixels[layer] = compressed_pixels[3:]
+
+ path_types = {"S": 1, "W": 2, "M": 3}
+ paths = None
+ if map_data.path:
+ paths = []
+ coords = [
+ path_types.get(map_data.path[0].path_type),
+ map_data.path[0].x,
+ map_data.path[0].y,
+ ]
+ for path in map_data.path[1:]:
+ if path.path_type.value != "L":
+ paths.append(coords)
+ coords = [path_types.get(path.path_type)]
+ coords.extend([path.x, path.y])
+
+ if len(coords) > 2:
+ paths.append(coords)
+
+ map_data_json = MapRendererData(
+ data=pixels,
+ size=[
+ map_data.dimensions.left,
+ map_data.dimensions.top,
+ map_data.dimensions.original_left,
+ map_data.dimensions.original_top,
+ map_data.dimensions.width if not map_data.empty_map else 1,
+ map_data.dimensions.height if not map_data.empty_map else 1,
+ map_data.dimensions.grid_size,
+ map_data.rotation,
+ crop,
+ ],
+ need_optimization=True if map_data.need_optimization else None,
+ map_id=map_data.map_id,
+ saved_map_id=map_data.saved_map_id,
+ map_index=map_data.map_index,
+ saved_map_status=map_data.saved_map_status,
+ empty_map=map_data.empty_map,
+ temporary_map=map_data.temporary_map,
+ frame_id=map_data.frame_id,
+ active_segments=map_data.active_segments,
+ cleanset=(
+ bool(map_data.cleanset)
+ if not map_data.temporary_map and not map_data.saved_map and not map_data.wifi_map
+ else False
+ ),
+ sequence=(
+ bool(map_data.sequence)
+ if not map_data.temporary_map and not map_data.saved_map and not map_data.wifi_map
+ else False
+ ),
+ change_mop=(
+ bool(map_data.change_mop)
+ if not map_data.temporary_map and not map_data.saved_map and not map_data.wifi_map
+ else False
+ ),
+ docked=map_data.docked,
+ floor_material=map_data.floor_material,
+ hidden_segments=map_data.hidden_segments,
+ blocked_segments=map_data.blocked_segments if map_data.blocked_segments else None,
+ robot_status=robot_status if not map_data.saved_map and not map_data.wifi_map else 0,
+ station_status=station_status if not map_data.saved_map and not map_data.wifi_map else 0,
+ saved_map=map_data.saved_map,
+ wifi_map=map_data.wifi_map,
+ history_map=map_data.history_map,
+ recovery_map=map_data.recovery_map,
+ path=paths if not map_data.saved_map and not map_data.wifi_map else [],
+ robot_position=(
+ [
+ map_data.robot_position.x,
+ map_data.robot_position.y,
+ map_data.robot_position.a,
+ ]
+ if map_data.robot_position
+ else None
+ ),
+ charger_position=(
+ [
+ map_data.charger_position.x,
+ map_data.charger_position.y,
+ map_data.charger_position.a,
+ ]
+ if map_data.charger_position
+ else None
+ ),
+ router_position=(
+ [
+ map_data.router_position.x,
+ map_data.router_position.y,
+ ]
+ if map_data.router_position
+ else None
+ ),
+ station_segment=map_data.station_segment,
+ # ai_outborders_user=map_data.ai_outborders_user,
+ # ai_outborders=map_data.ai_outborders,
+ # ai_outborders_new=map_data.ai_outborders_new,
+ # ai_outborders_2d=map_data.ai_outborders_2d,
+ # ai_furniture_warning=map_data.ai_furniture_warning,
+ # walls_info=map_data.walls_info,
+ # walls_info_new=map_data.walls_info_new,
+ startup_method=map_data.startup_method if map_data.history_map else None,
+ cleanup_method=map_data.cleanup_method if map_data.history_map else None,
+ second_cleaning=map_data.second_cleaning,
+ second_mopping=map_data.second_mopping,
+ mop_wash_count=map_data.mop_wash_count if map_data.history_map else None,
+ recommended_carpets=map_data.recommended_carpets,
+ recommended_ramps=map_data.recommended_ramps,
+ recommended_cliffs=map_data.recommended_cliffs,
+ recommended_virtual_thresholds=map_data.recommended_virtual_thresholds,
+ recommended_passable_thresholds=map_data.recommended_passable_thresholds,
+ recommended_impassible_thresholds=map_data.recommended_impassible_thresholds,
+ recommended_virtual_walls=map_data.recommended_virtual_walls,
+ recommended_no_go_areas=map_data.recommended_no_go_areas,
+ recommended_no_mopping_areas=map_data.recommended_no_mopping_areas,
+ recommended_area_type=map_data.recommended_area_type,
+ recommended_threshold_type=map_data.recommended_threshold_type,
+ dust_collection_count=map_data.dust_collection_count if map_data.history_map else None,
+ dos=map_data.dos,
+ multiple_cleaning_time=map_data.multiple_cleaning_time,
+ task_interrupt_reason=map_data.task_interrupt_reason if map_data.history_map else None,
+ task_end_type=map_data.task_end_type if map_data.history_map else None,
+ cleaning_status=map_data.cleaning_status if map_data.history_map else None,
+ cleaning_map=map_data.cleaning_map,
+ cleaning_map_data=(
+ DreameVacuumMapRenderer.get_data(
+ map_data.cleaning_map_data, capability, icon_set, False, 0, 0, False
+ )
+ if map_data.history_map and map_data.cleaning_map_data
+ else None
+ ),
+ wifi_map_data=(
+ DreameVacuumMapRenderer.get_data(map_data.wifi_map_data, capability, icon_set, False, 0, 0, False)
+ if (map_data.history_map or map_data.saved_map) and map_data.wifi_map_data
+ else None
+ ),
+ has_cleaned_area=map_data.has_cleaned_area,
+ has_dirty_area=map_data.has_dirty_area,
+ cleaned_segments=map_data.cleaned_segments,
+ cleaned_area=map_data.cleaned_area,
+ cleaning_time=map_data.cleaning_time,
+ work_status=map_data.work_status,
+ completed=map_data.completed,
+ remaining_battery=map_data.remaining_battery,
+ zone_cleaning=map_data.zone_cleaning,
+ segments=(
+ [
+ [
+ k,
+ v.x,
+ v.y,
+ v.type,
+ base64.b64encode(v.custom_name.encode("utf-8")).decode("utf-8") if v.custom_name else None,
+ v.index,
+ v.color_index,
+ v.neighbors,
+ v.order,
+ v.suction_level,
+ v.water_volume,
+ v.cleaning_times,
+ v.cleaning_mode if v.cleanset_type != CleansetType.DEFAULT else None,
+ v.custom_mopping_route if v.cleanset_type == CleansetType.CUSTOM_MOPPING_ROUTE else None,
+ v.cleaning_route if v.cleanset_type != CleansetType.CUSTOM_MOPPING_ROUTE else None,
+ (
+ v.wetness_level
+ if v.cleanset_type == CleansetType.WETNESS_LEVEL
+ or v.cleanset_type == CleansetType.WETNESS_LEVEL_MAX_15
+ else None
+ ),
+ v.floor_material,
+ v.floor_material_direction,
+ v.visibility,
+ [v.x0, v.y0, v.x1, v.y1],
+ v.carpet_cleaning,
+ v.carpet_preferences,
+ v.mop_temperature,
+ v.mop_pressure,
+ v.mop_type,
+ ]
+ for (k, v) in map_data.segments.items()
+ ]
+ if map_data.segments
+ else None
+ ),
+ active_areas=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ ]
+ for area in map_data.active_areas
+ ]
+ if map_data.active_areas
+ else []
+ ),
+ active_points=(
+ [[point.x0, point.y0] for point in map_data.active_points] if map_data.active_points else []
+ ),
+ active_cruise_points=(
+ [
+ [point.x, point.y, point.type, point.completed]
+ for point in map_data.active_cruise_points.values()
+ ]
+ if map_data.active_cruise_points
+ else []
+ ),
+ task_cruise_points=bool(map_data.task_cruise_points),
+ virtual_walls=(
+ [
+ [virtual_wall.x0, virtual_wall.y0, virtual_wall.x1, virtual_wall.y1]
+ for virtual_wall in map_data.virtual_walls
+ ]
+ if map_data.virtual_walls
+ else []
+ ),
+ no_mop=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.angle,
+ 1 if area.hidden else 0,
+ ]
+ for area in map_data.no_mopping_areas
+ ]
+ if map_data.no_mopping_areas
+ else []
+ ),
+ no_go=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.angle,
+ ]
+ for area in map_data.no_go_areas
+ ]
+ if map_data.no_go_areas
+ else []
+ ),
+ obstacles=(
+ [
+ [
+ k,
+ v.x,
+ v.y,
+ v.type.value,
+ v.possibility,
+ v.ignore_status,
+ v.picture_status,
+ v.id,
+ v.pos_x,
+ v.pos_y,
+ v.width,
+ v.height,
+ v.segment,
+ v.color_index,
+ v.segment_id,
+ v.reason.name.replace("_", " ").capitalize() if v.reason else None,
+ ]
+ for k, v in map_data.obstacles.items()
+ ]
+ if map_data.obstacles is not None
+ else None
+ ),
+ predefined_points=(
+ [[point.x, point.y] for point in map_data.predefined_points]
+ if map_data.predefined_points is not None
+ else None
+ ),
+ carpets=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.id,
+ area.ellipse,
+ area.carpet_cleaning,
+ area.carpet_preferences,
+ area.carpet_type,
+ area.hidden,
+ area.tassel,
+ ]
+ for area in map_data.carpets
+ ]
+ if map_data.carpets is not None
+ else None
+ ),
+ deleted_carpets=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.id,
+ ]
+ for area in map_data.deleted_carpets
+ ]
+ if map_data.deleted_carpets is not None
+ else None
+ ),
+ detected_carpets=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.id,
+ area.ellipse,
+ area.carpet_cleaning,
+ area.carpet_preferences,
+ area.carpet_type,
+ area.hidden,
+ None,
+ area.ignored_areas,
+ area.segments,
+ area.polygon,
+ ]
+ for area in map_data.detected_carpets
+ ]
+ if map_data.detected_carpets is not None
+ else None
+ ),
+ virtual_thresholds=(
+ [[wall.x0, wall.y0, wall.x1, wall.y1] for wall in map_data.virtual_thresholds]
+ if map_data.virtual_thresholds is not None
+ else None
+ ),
+ passable_thresholds=(
+ [[wall.x0, wall.y0, wall.x1, wall.y1] for wall in map_data.passable_thresholds]
+ if map_data.passable_thresholds is not None
+ else None
+ ),
+ impassable_thresholds=(
+ [[wall.x0, wall.y0, wall.x1, wall.y1] for wall in map_data.impassable_thresholds]
+ if map_data.impassable_thresholds is not None
+ else None
+ ),
+ ramps=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.angle,
+ ]
+ for area in map_data.ramps
+ ]
+ if map_data.ramps is not None
+ else None
+ ),
+ low_lying_areas=(
+ [
+ [
+ area.x0,
+ area.y0,
+ area.x1,
+ area.y1,
+ area.x2,
+ area.y2,
+ area.x3,
+ area.y3,
+ area.id,
+ area.polygon,
+ area.type,
+ area.hidden,
+ area.ms,
+ area.area,
+ ]
+ for area in map_data.low_lying_areas
+ ]
+ if map_data.low_lying_areas is not None
+ else None
+ ),
+ furnitures=(
+ [
+ [
+ area.x,
+ area.y,
+ area.width,
+ area.height,
+ area.type.value,
+ area.edit_type,
+ area.angle,
+ area.scale,
+ area.segment_id,
+ area.furniture_id,
+ ]
+ for key, area in map_data.furnitures.items()
+ ]
+ if map_data.furnitures is not None
+ else None
+ ),
+ furniture_version=map_data.furniture_version,
+ curtains=(
+ [[wall.x0, wall.y0, wall.x1, wall.y1] for wall in map_data.curtains]
+ if map_data.curtains is not None
+ else None
+ ),
+ resources=resources,
+ )
+
+ if as_string:
+ return json.dumps(
+ map_data_json,
+ default=lambda o: dict((key, value) for key, value in o.__dict__.items() if value is not None),
+ allow_nan=False,
+ sort_keys=True,
+ separators=(",", ":"),
+ )
+ return map_data_json
+
+ def render_obstacle_image(
+ self,
+ image_bytes,
+ obstacle: Obstacle,
+ obstacle_image_crop: bool,
+ render_box: bool = True,
+ crop_image: bool = False,
+ color: str = None,
+ ):
+ if image_bytes:
+ if (
+ not obstacle
+ or not (obstacle.width and obstacle.height and obstacle.pos_x != None and obstacle.pos_y != None)
+ or (not crop_image and not render_box)
+ ):
+ return image_bytes
+
+ image = Image.open(io.BytesIO(image_bytes)).convert("RGBA")
+ w = image.size[0]
+ h = image.size[1]
+ crop = (int((h * 105) / 100.0) - h) * 2
+ if obstacle_image_crop:
+ if crop_image and h > 400:
+ image = image.crop((crop, 0, w - crop, h - int(crop / 2)))
+ w = image.size[0]
+ elif crop_image:
+ crop = int(round(crop * 0.55))
+ image = image.crop((crop, 0, w - crop, h))
+ w = image.size[0]
+
+ if render_box and obstacle.width and obstacle.height and obstacle.type is not ObstacleType.BLOCKED_ROOM:
+ x = obstacle.pos_x - 4
+ y = obstacle.pos_y - 4
+ width = obstacle.width + 8
+ height = obstacle.height + 8
+
+ if color:
+ stroke = 2
+ radius = 6
+ border_color = color
+ bg_color = (color[0], color[1], color[2], 25)
+ else:
+ stroke = 3
+ radius = 0
+ border_color = (49, 85, 225, 255)
+ bg_color = (49, 85, 225, 30)
+
+ x0 = ((x * w) / 100.0) - stroke
+ y0 = ((y * h) / 100.0) - stroke
+ x1 = (x0 + ((width * w) / 100.0)) + stroke
+ y1 = (y0 + ((height * h) / 100.0)) + stroke
+
+ if x0 <= 0:
+ new_x = int(w * 0.5 / 100.0)
+ x1 = x1 + new_x - x0
+ x0 = new_x
+ if y0 <= 0:
+ new_y = int(h * 0.5 / 100.0)
+ y1 = y1 + new_y - y0
+ y0 = new_y
+
+ if x1 >= w:
+ x1 = w - int(w * 0.5 / 100.0)
+ if y1 >= image.size[1]:
+ y1 = image.size[1] - int(image.size[1] * 0.5 / 100.0)
+
+ scale = 2
+ new_layer = Image.new("RGBA", (image.size[0] * scale, image.size[1] * scale), (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ draw.rounded_rectangle(
+ [
+ int(round(x0 * scale)),
+ int(round(y0 * scale)),
+ int(round(x1 * scale)),
+ int(round(y1 * scale)),
+ ],
+ fill=bg_color,
+ outline=border_color,
+ width=stroke * scale,
+ radius=radius * scale,
+ )
+ if new_layer.size != image.size:
+ new_layer.thumbnail(image.size, Image.Resampling.LANCZOS)
+ image = Image.alpha_composite(image, new_layer)
+
+ if not color:
+ if self._obstacle_bottom_left_icon is None:
+ self._obstacle_bottom_left_icon = Image.open(
+ BytesIO(base64.b64decode(MAP_ROBOT_OBSTACLE_BOTTOM_LEFT_IMAGE))
+ ).convert("RGBA")
+ self._obstacle_top_left_icon = Image.open(
+ BytesIO(base64.b64decode(MAP_ROBOT_OBSTACLE_TOP_LEFT_IMAGE))
+ ).convert("RGBA")
+ self._obstacle_bottom_right_icon = Image.open(
+ BytesIO(base64.b64decode(MAP_ROBOT_OBSTACLE_BOTTOM_RIGHT_IMAGE))
+ ).convert("RGBA")
+ self._obstacle_top_right_icon = Image.open(
+ BytesIO(base64.b64decode(MAP_ROBOT_OBSTACLE_TOP_RIGHT_IMAGE))
+ ).convert("RGBA")
+
+ icon_size = int(round(5 * h / 100.0))
+ obstacle_bottom_left_icon = self._obstacle_bottom_left_icon.resize((icon_size, icon_size))
+ obstacle_top_left_icon = self._obstacle_top_left_icon.resize((icon_size, icon_size))
+ obstacle_bottom_right_icon = self._obstacle_bottom_right_icon.resize((icon_size, icon_size))
+ obstacle_top_right_icon = self._obstacle_top_right_icon.resize((icon_size, icon_size))
+
+ offset = 6
+ new_layer = Image.new("RGBA", image.size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ new_layer.paste(
+ obstacle_top_left_icon,
+ (int(round(x0 + offset)), int(round(y0 + offset))),
+ )
+ new_layer.paste(
+ obstacle_bottom_left_icon,
+ (
+ int(round(x0 + offset)),
+ int(round(y1 - obstacle_bottom_left_icon.size[1] - offset)),
+ ),
+ )
+ new_layer.paste(
+ obstacle_bottom_right_icon,
+ (
+ int(round(x1 - obstacle_top_right_icon.size[0] - offset)),
+ int(round(y1 - obstacle_bottom_right_icon.size[1] - offset)),
+ ),
+ )
+ new_layer.paste(
+ obstacle_top_right_icon,
+ (
+ int(round(x1 - obstacle_top_right_icon.size[0] - offset)),
+ int(round(y0 + offset)),
+ ),
+ )
+ image = Image.alpha_composite(image, new_layer)
+
+ buffer = io.BytesIO()
+ image.convert("RGB").save(buffer, format="JPEG")
+ return buffer.getvalue()
+
+ def render_map(
+ self,
+ map_data: MapData,
+ robot_status: int = 0,
+ station_status: int = 0,
+ info_text: bool = False,
+ ) -> bytes:
if map_data is None or map_data.empty_map or (map_data.dimensions.width * map_data.dimensions.height) < 2:
return self.default_map_image
@@ -3343,117 +7809,239 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
if map_data.saved_map:
robot_status = 0
+ station_status = 0
try:
- if (
- self._map_data is None
- or self._map_data.dimensions != map_data.dimensions
- or self._map_data.map_id != map_data.map_id
- or self._map_data.saved_map_status != map_data.saved_map_status
- ):
- self._map_data = None
+ if self._cache:
+ if (
+ self._map_data is None
+ or self._map_data.dimensions != map_data.dimensions
+ or self._map_data.map_id != map_data.map_id
+ or self._map_data.saved_map_status != map_data.saved_map_status
+ ):
+ self._map_data = None
+
+ if (
+ self._map_data
+ and self._map_data == map_data
+ and self._robot_status == robot_status
+ and self._station_status == station_status
+ and self._map_data.segments == map_data.segments
+ and self._map_data.frame_id == map_data.frame_id
+ and self._image
+ ):
+ self.render_complete = True
+ _LOGGER.info("Skip render frame, map data not changed")
+ return self._to_buffer(self._image)
+
+ scale = (
+ 2
+ if self._low_resolution
+ else (
+ 4
+ if (map_data.saved_map_status == 2 or map_data.restored_map)
+ and not map_data.recovery_map
+ and not map_data.history_map
+ else 2 if (map_data.wifi_map or map_data.history_map) and self._cache else 3
+ )
+ )
+ object_scale = 2
- if (
- self._map_data
- and self._map_data == map_data
- and self._robot_status == robot_status
- and self._map_data.segments == map_data.segments
- and self._map_data.frame_id == map_data.frame_id
- and self._image
- ):
- self.render_complete = True
- _LOGGER.info("Skip render frame, map data not changed")
- return self._to_buffer(self._image)
+ render_material = False
+ render_carpet = bool(
+ (not map_data.saved_map or map_data.history_map or map_data.recovery_map) and self.config.carpet
+ )
+ if (map_data.saved_map_status == 2 or map_data.saved_map) and not map_data.wifi_map:
+ render_material = self.config.material and map_data.floor_material
+ render_carpet = render_carpet and bool(
+ map_data.carpets or map_data.detected_carpets or map_data.deleted_carpets or map_data.carpet_pixels
+ )
- scale = 4 if map_data.saved_map_status == 2 or map_data.saved_map else 3
+ if scale == 3 and (render_material or render_carpet):
+ scale = 2 if info_text else 4
if not map_data.saved_map:
if (
self._map_data is None
or self._map_data.segments != map_data.segments
or self._map_data.dimensions != map_data.dimensions
+ or self._map_data.saved_map_id != map_data.saved_map_id
):
map_data.dimensions.bounds = DreameVacuumMapRenderer._calculate_bounds(
map_data.dimensions, map_data.segments
)
- if self._map_data and self._map_data.dimensions.bounds != map_data.dimensions.bounds:
+ if self._map_data and (
+ self._map_data.dimensions.bounds != map_data.dimensions.bounds
+ or self._map_data.saved_map_id != map_data.saved_map_id
+ ):
self._map_data = None
else:
map_data.dimensions.bounds = self._map_data.dimensions.bounds
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.active_areas != map_data.active_areas
or self._map_data.no_mopping_areas != map_data.no_mopping_areas
or self._map_data.no_go_areas != map_data.no_go_areas
- or self._map_data.walls != map_data.walls
+ or self._map_data.virtual_walls != map_data.virtual_walls
+ or self._map_data.virtual_thresholds != map_data.virtual_thresholds
+ or self._map_data.passable_thresholds != map_data.passable_thresholds
+ or self._map_data.impassable_thresholds != map_data.impassable_thresholds
+ or self._map_data.ramps != map_data.ramps
+ or self._map_data.carpets != map_data.carpets
+ or self._map_data.curtains != map_data.curtains
or self._map_data.segments != map_data.segments
or self._map_data.dimensions != map_data.dimensions
or self._map_data.restored_map != map_data.restored_map
):
map_data.dimensions.padding = DreameVacuumMapRenderer._calculate_padding(
map_data.dimensions,
- map_data.active_areas,
- map_data.no_mopping_areas,
- map_data.no_go_areas,
- map_data.walls,
+ map_data.active_areas if self.config.active_area else None,
+ map_data.no_mopping_areas if self.config.no_mop else None,
+ map_data.no_go_areas if self.config.no_go else None,
+ map_data.virtual_walls if self.config.virtual_wall else None,
+ map_data.virtual_thresholds if self.config.pathway else None,
+ map_data.passable_thresholds if self.config.pathway else None,
+ map_data.impassable_thresholds if self.config.pathway else None,
+ map_data.ramps if self.config.ramp else None,
+ map_data.furnitures if self.config.furniture else None,
+ map_data.furniture_version,
+ map_data.curtains if self.config.curtain else None,
map_data.segments,
[14, 14, 14, 14],
120,
80,
scale,
+ self.icon_set,
)
- if self._map_data and self._map_data.dimensions.padding != map_data.dimensions.padding:
+ if self._cache and self._map_data and self._map_data.dimensions.padding != map_data.dimensions.padding:
self._map_data = None
else:
map_data.dimensions.padding = self._map_data.dimensions.padding
map_data.dimensions.scale = scale
+ segment_mask = None
+
+ if not self._low_memory and self.config.path and map_data.path and self._robot_type != RobotType.VSLAM:
+ if not self._cache or self._map_data is None or self._map_data.path != map_data.path:
+ self._has_mask = False
+ for path in map_data.path:
+ if path.path_type == PathType.SWEEP_AND_MOP or path.path_type == PathType.MOP:
+ self._has_mask = True
+ break
+ else:
+ self._has_mask = False
+
+ cached_layers = self._layers if self._cache else {}
+ if self._cache and not self._has_mask and cached_layers.get(MapRendererLayer.PATH_MASK):
+ del cached_layers[MapRendererLayer.PATH_MASK]
- if self._map_data and self._map_data.dimensions.scale != scale:
+ if self._cache and self._map_data and self._map_data.dimensions.scale != scale:
self._map_data = None
- if self._map_data is None or self._map_data.rotation != map_data.rotation:
- self._charger_icon = None
+ if not self._cache or (self._map_data is None or self._map_data.rotation != map_data.rotation):
self._robot_sleeping_icon = None
self._obstacle_background = None
+ self._obstacle_hidden_background = None
+ self._cruise_path_point_background = None
+ self._cruise_point_background = None
+ self._furniture_background = None
if self._map_data is None:
- self._robot_icon = None
self._robot_charging_icon = None
self._robot_cleaning_icon = None
self._robot_warning_icon = None
self._robot_washing_icon = None
+ self._robot_hot_washing_icon = None
+ self._robot_drying_icon = None
+ self._robot_hot_drying_icon = None
+ self._robot_dust_bag_drying_icon = None
+ self._robot_emptying_icon = None
self._robot_cleaning_direction_icon = None
+ bg_color = (
+ ((0, 0, 0, 255) if self.color_scheme.dark or self.color_scheme.invert else (255, 255, 255, 255))
+ if info_text
+ else ((0, 0, 0, 0) if map_data.wifi_map else self.color_scheme.outside)
+ )
+
if (
- self._map_data is None
- or not self._layers.get(MapRendererLayer.IMAGE)
+ not self._cache
+ or self._map_data is None
+ or not cached_layers.get(MapRendererLayer.IMAGE)
or self._map_data.active_segments != map_data.active_segments
or self._map_data.active_areas != map_data.active_areas
or self._map_data.segments != map_data.segments
or self._map_data.data != map_data.data
+ or (self._has_mask and not cached_layers.get(MapRendererLayer.PATH_MASK))
+ or (render_material and self._map_data.floor_material != map_data.floor_material)
+ or (
+ render_carpet
+ and (
+ self._map_data.carpets != map_data.carpets
+ or self._map_data.deleted_carpets != map_data.deleted_carpets
+ or self._map_data.detected_carpets != map_data.detected_carpets
+ or self._map_data.carpet_pixels != map_data.carpet_pixels
+ )
+ )
):
area_colors = {}
# as implemented on the app
- area_colors[MapPixelType.OUTSIDE.value] = self.color_scheme.outside
- area_colors[MapPixelType.WALL.value] = self.color_scheme.wall
- area_colors[MapPixelType.FLOOR.value] = self.color_scheme.floor
- area_colors[MapPixelType.NEW_SEGMENT.value] = self.color_scheme.new_segment
- area_colors[MapPixelType.UNKNOWN.value] = self.color_scheme.floor
- area_colors[MapPixelType.OBSTACLE_WALL.value] = self.color_scheme.wall
- area_colors[MapPixelType.NEW_SEGMENT_UNKNOWN.value] = self.color_scheme.new_segment
-
- if map_data.segments is not None:
+ if map_data.cleaning_map:
+ area_colors[MapPixelType.OUTSIDE.value] = bg_color
+ area_colors[MapPixelType.WALL.value] = self.color_scheme.wall
+ area_colors[MapPixelType.DIRTY_AREA.value] = (
+ self.color_scheme.clean_area if map_data.second_cleaning else self.color_scheme.dirty_area
+ )
+ area_colors[MapPixelType.CLEAN_AREA.value] = self.color_scheme.clean_area
+ area_colors[MapPixelType.NEW_SEGMENT.value] = self.color_scheme.passive_segment
+ elif map_data.wifi_map:
+ area_colors[MapPixelType.OUTSIDE.value] = bg_color
+ area_colors[MapPixelType.WIFI_EXCELLENT.value] = (
+ 129,
+ 168,
+ 245,
+ 255,
+ )
+ area_colors[MapPixelType.WIFI_HIGH.value] = (161, 189, 242, 255)
+ area_colors[MapPixelType.WIFI_LOW.value] = (205, 218, 239, 255)
+ area_colors[MapPixelType.WIFI_POOR.value] = (217, 226, 239, 255)
+ area_colors[MapPixelType.WIFI_UNREACHED.value] = (
+ 229,
+ 234,
+ 238,
+ 255,
+ )
+ area_colors[MapPixelType.WIFI_WALL.value] = (160, 160, 160, 255)
+ area_colors[MapPixelType.NEW_SEGMENT.value] = area_colors[MapPixelType.OUTSIDE.value]
+ else:
+ area_colors[MapPixelType.OUTSIDE.value] = bg_color
+ area_colors[MapPixelType.WALL.value] = self.color_scheme.wall
+ area_colors[MapPixelType.FLOOR.value] = self.color_scheme.floor
+ area_colors[MapPixelType.NEW_SEGMENT.value] = self.color_scheme.new_segment
+ area_colors[MapPixelType.UNKNOWN.value] = self.color_scheme.floor
+ area_colors[MapPixelType.OBSTACLE_WALL.value] = self.color_scheme.wall
+
+ if map_data.cleaning_map:
+ if map_data.blocked_segments:
+ for k in map_data.blocked_segments.keys():
+ area_colors[k] = (255, 255, 255, 255)
+ elif map_data.segments is not None:
for k, v in map_data.segments.items():
- if self.config.color:
- if map_data.active_segments and k not in map_data.active_segments:
- area_colors[k] = self.color_scheme.passive_segment
- elif v.color_index is not None:
- area_colors[k] = self.color_scheme.segment[v.color_index][0]
- else:
- area_colors[k] = area_colors[MapPixelType.FLOOR.value]
+ area_colors[100 + k] = self.color_scheme.wall
+ if not map_data.cleaning_map and not map_data.zone_cleaning:
+ if self.config.color:
+ if map_data.hidden_segments and k in map_data.hidden_segments:
+ area_colors[k] = self.color_scheme.hidden_segment
+ area_colors[100 + k] = self.color_scheme.hidden_segment
+ elif map_data.active_segments and k not in map_data.active_segments:
+ area_colors[k] = self.color_scheme.passive_segment
+ elif v.color_index is not None:
+ area_colors[k] = self.color_scheme.segment[v.color_index][0]
+ else:
+ area_colors[k] = area_colors[MapPixelType.FLOOR.value]
pixels = np.full(
(
@@ -3465,25 +8053,102 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
dtype=np.uint8,
)
+ if self._has_mask:
+ mask_color = (255, 255, 255, 255)
+ mask = np.full(
+ (
+ map_data.dimensions.height,
+ map_data.dimensions.width,
+ 4,
+ ),
+ (255, 255, 255, 0),
+ dtype=np.uint8,
+ )
+
+ if map_data.history_map and map_data.blocked_segments:
+ segment_mask = np.full(
+ (
+ map_data.dimensions.height,
+ map_data.dimensions.width,
+ 4,
+ ),
+ (255, 255, 255, 0),
+ dtype=np.uint8,
+ )
+
min_x = map_data.dimensions.width - 1
min_y = map_data.dimensions.height - 1
max_x = 0
max_y = 0
+
for y in range(map_data.dimensions.height):
for x in range(map_data.dimensions.width):
px_type = int(map_data.pixel_type[x, map_data.dimensions.height - y - 1])
- if px_type != MapPixelType.OUTSIDE.value:
- pixels[y, x] = (
- area_colors[px_type]
- if px_type in area_colors
- else area_colors[MapPixelType.NEW_SEGMENT.value]
- )
+
+ if px_type != 0:
+ pixels[y, x] = area_colors.get(px_type, area_colors[255 if px_type > 100 else 253])
max_x = max(x, max_x)
min_x = min(x, min_x)
max_y = max(y, max_y)
min_y = min(y, min_y)
+ if self._has_mask and px_type <= 100:
+ mask[y, x] = mask_color
+
+ if segment_mask is not None:
+ if px_type in map_data.blocked_segments:
+ segment_mask[y, x] = self.color_scheme.blocked_segment
+
+ if render_material or render_carpet:
+ floor_scale = 2
+ pixels = pixels.repeat(floor_scale, axis=0).repeat(floor_scale, axis=1)
+ if render_material:
+ floor_material = self.render_floor_material(
+ pixels,
+ map_data.floor_material,
+ map_data.hidden_segments,
+ map_data.pixel_type,
+ self.color_scheme.material_color,
+ map_data.dimensions,
+ floor_scale,
+ )
+ if floor_material is not None:
+ pixels = floor_material
+ _LOGGER.debug("Render MATERIAL")
+
+ carpet = None
+ if render_carpet:
+ carpet = self.render_carpets(
+ pixels,
+ map_data.pixel_type,
+ map_data.carpets,
+ map_data.deleted_carpets,
+ map_data.detected_carpets,
+ map_data.carpet_pixels,
+ map_data.segments,
+ map_data.hidden_segments,
+ self.color_scheme.carpet_color,
+ self.color_scheme.carpet_color_detected,
+ map_data.dimensions,
+ floor_scale,
+ )
+
+ if carpet is not None:
+ _LOGGER.debug("Render CARPET")
+ pixels = carpet
+
+ if scale != floor_scale:
+ pixels = pixels.repeat(scale / floor_scale, axis=0).repeat(scale / floor_scale, axis=1)
+ else:
+ pixels = pixels.repeat(scale, axis=0).repeat(scale, axis=1)
+
+ if self._has_mask:
+ mask = mask.repeat(scale, axis=0).repeat(scale, axis=1)
+
+ if segment_mask is not None:
+ segment_mask = segment_mask.repeat(scale, axis=0).repeat(scale, axis=1)
+
if map_data.dimensions.bounds:
# min_x = max(0, min(map_data.dimensions.bounds[0], min_x))
# max_x = min((map_data.dimensions.width - 1), max(map_data.dimensions.bounds[2], max_x))
@@ -3505,32 +8170,118 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
or max_x != (map_data.dimensions.width - 1)
or max_y != (map_data.dimensions.height - 1)
):
+ from_y = min_y * scale
+ to_y = (max_y + 1) * scale
+ from_x = min_x * scale
+ to_x = (max_x + 1) * scale
+ pixels = pixels[from_y:to_y, from_x:to_x]
+ if self._has_mask:
+ mask = mask[from_y:to_y, from_x:to_x]
+ if segment_mask is not None:
+ segment_mask = segment_mask[from_y:to_y, from_x:to_x]
map_data.dimensions.crop = [
- min_x * scale,
- min_y * scale,
+ from_x,
+ from_y,
(map_data.dimensions.width - (max_x + 1)) * scale,
(map_data.dimensions.height - (max_y + 1)) * scale,
]
- pixels = pixels[min_y : (max_y + 1), min_x : (max_x + 1)]
if self._map_data and self._map_data.dimensions.crop != map_data.dimensions.crop:
self._map_data = None
- self._layers[MapRendererLayer.IMAGE] = ImageOps.expand(
- Image.fromarray(pixels.repeat(scale, axis=0).repeat(scale, axis=1)),
+ image = Image.fromarray(pixels)
+ if self._square and not map_data.wifi_map: # and not map_data.saved_map:
+ height = image.size[0] + map_data.dimensions.padding[0] + map_data.dimensions.padding[2]
+ width = image.size[1] + map_data.dimensions.padding[1] + map_data.dimensions.padding[3]
+ if height != width:
+ dif = int(abs(height - width) / 2)
+ if height < width:
+ map_data.dimensions.padding[0] = map_data.dimensions.padding[0] + dif
+ map_data.dimensions.padding[2] = map_data.dimensions.padding[2] + dif
+ else:
+ map_data.dimensions.padding[1] = map_data.dimensions.padding[1] + dif
+ map_data.dimensions.padding[3] = map_data.dimensions.padding[3] + dif
+
+ cached_layers[MapRendererLayer.IMAGE] = ImageOps.expand(
+ Image.fromarray(pixels),
border=tuple(map_data.dimensions.padding),
+ fill=bg_color,
)
+
+ if self._has_mask:
+ if self._cache and self._map_data:
+ self._map_data.path = None
+
+ cached_layers[MapRendererLayer.PATH_MASK] = ImageOps.expand(
+ Image.fromarray(mask.repeat(object_scale, axis=0).repeat(object_scale, axis=1)),
+ border=(
+ map_data.dimensions.padding[0] * object_scale,
+ map_data.dimensions.padding[1] * object_scale,
+ map_data.dimensions.padding[2] * object_scale,
+ map_data.dimensions.padding[3] * object_scale,
+ ),
+ fill=(255, 255, 255, 0),
+ )
+
+ if segment_mask is not None:
+ segment_mask = ImageOps.expand(
+ Image.fromarray(segment_mask),
+ border=(
+ map_data.dimensions.padding[0],
+ map_data.dimensions.padding[1],
+ map_data.dimensions.padding[2],
+ map_data.dimensions.padding[3],
+ ),
+ fill=(255, 255, 255, 0),
+ )
else:
map_data.dimensions.crop = self._map_data.dimensions.crop
self._calibration_points = self._calculate_calibration_points(map_data)
- image = self.render_objects(
- map_data,
- robot_status,
- self._layers[MapRendererLayer.IMAGE],
- 2,
- )
+ image = cached_layers[MapRendererLayer.IMAGE]
+
+ if not map_data.saved_map and map_data.path and self.config.path:
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.path != map_data.path
+ or not cached_layers.get(MapRendererLayer.PATH)
+ ):
+ cached_layers[MapRendererLayer.PATH] = self.render_path(
+ map_data.path,
+ self.color_scheme.path,
+ self.color_scheme.mop_path,
+ (
+ int(image.size[0] * object_scale),
+ int(image.size[1] * object_scale),
+ ),
+ cached_layers.get(MapRendererLayer.PATH_MASK),
+ map_data.dimensions,
+ 0.375 * scale * object_scale,
+ object_scale,
+ )
+ cached_layers[MapRendererLayer.PATH].thumbnail(image.size, Image.Resampling.BOX, reducing_gap=1.5)
+ _LOGGER.debug("Render PATH")
+ image = Image.alpha_composite(image, cached_layers[MapRendererLayer.PATH])
+ elif self._cache and cached_layers.get(MapRendererLayer.PATH):
+ del cached_layers[MapRendererLayer.PATH]
+
+ image = self.render_objects(cached_layers, map_data, robot_status, station_status, image, object_scale)
+
+ if segment_mask is not None:
+ image = Image.alpha_composite(
+ image,
+ self.render_blocked_segments(
+ map_data.blocked_segments,
+ map_data.segments,
+ image.size,
+ segment_mask,
+ map_data.dimensions,
+ map_data.rotation,
+ map_data.cleaning_map,
+ ),
+ )
if map_data.rotation == 90:
image = image.transpose(Image.ROTATE_90)
@@ -3539,37 +8290,240 @@ def render_map(self, map_data: MapData, robot_status: int = 0) -> bytes:
elif map_data.rotation == 270:
image = image.transpose(Image.ROTATE_270)
- _LOGGER.info("Render frame: %s:%s took: %.2f", map_data.map_id, map_data.frame_id, time.time() - now)
+ if info_text:
+ base_width = 490 # int(round(image.size[0] / 4 * 3))
+ if image.size[0] > base_width:
+ image = image.resize(
+ (
+ base_width,
+ int((float(image.size[1]) * float((base_width / float(image.size[0]))))),
+ ),
+ Image.Resampling.LANCZOS,
+ )
+
+ header_text = f"{time.strftime(('%Y.%m.%d %H:%M:%S' if bool(map_data.saved_map or map_data.recovery_map or map_data.wifi_map) else '%m/%d %H:%M'), time.localtime(map_data.last_updated))}"
+ if map_data.history_map:
+ if map_data.task_cruise_points is None:
+ if map_data.startup_method is not None:
+ header_text = f"{header_text} | {map_data.startup_method.name.replace('_', ' ').title().replace('App', 'APP')}"
+
+ if map_data.second_cleaning:
+ header_text = f"{header_text} | Second Cleaning"
+ elif map_data.cleanup_method is not None:
+ header_text = f"{header_text} | {map_data.cleanup_method.name.replace('_', ' ').title()}"
+ elif map_data.recovery_map and map_data.recovery_map_type is not RecoveryMapType.UNKNOWN:
+ header_text = f"{header_text} | {map_data.recovery_map_type.name.replace('_', ' ').title()}"
+
+ image_width = image.size[0]
+ min_width = base_width # int(160 * scale)
+ if image_width < min_width:
+ image_width = min_width
+
+ text_draw = ImageDraw.Draw(image, "RGBA")
+ text_size = int(image_width * 0.035)
+ if self._light_font_file is None:
+ self._light_font_file = zlib.decompress(base64.b64decode(MAP_FONT_LIGHT), zlib.MAX_WBITS | 32)
+
+ text_font = ImageFont.truetype(BytesIO(self._light_font_file), text_size)
+ if map_data.history_map:
+ value_font = ImageFont.truetype(BytesIO(self._light_font_file), int(text_size * 1.8))
+ name_font = ImageFont.truetype(BytesIO(self._light_font_file), int(text_size * 0.8))
+ left, top, width, height = text_draw.textbbox((0, 0), header_text, font=text_font)
+ max_width = image_width * 0.9
+ if width > max_width:
+ lines = textwrap.wrap(header_text, width=int(max_width / (text_size / 2)))
+ else:
+ lines = [header_text]
+
+ if map_data.history_map and not map_data.task_cruise_points:
+ header_text = ""
+ if map_data.mop_wash_count:
+ header_text = f"Self-Cleaned"
+ if map_data.mop_wash_count > 1:
+ header_text = f"{header_text} {map_data.mop_wash_count}x"
+
+ if map_data.dust_collection_count:
+ if len(header_text):
+ header_text = f"{header_text} | "
+ header_text = f"{header_text}Auto-Emptied"
+ if map_data.dust_collection_count > 1:
+ header_text = f"{header_text} {map_data.dust_collection_count}x"
+
+ if len(header_text):
+ lines.append(header_text)
+
+ max_width = 0
+ header_height = int(text_size * 5) if map_data.history_map else text_size
+ total_height = header_height
+
+ line_sizes = []
+ for line in lines:
+ left, top, width, height = text_draw.textbbox((0, 0), line, font=text_font)
+ line_sizes.append((width, height))
+ max_width = max(max_width, width)
+ total_height = total_height + height
+
+ padding = int((min_width - image.size[0]) / 2)
+ if padding < 0:
+ padding = 0
+ image = ImageOps.expand(
+ image,
+ border=(
+ padding,
+ int(total_height) + int(padding / 2),
+ padding,
+ int(padding / 2),
+ ),
+ fill=bg_color,
+ )
+ image_width = image.size[0]
+ text_draw = ImageDraw.Draw(image, "RGBA")
+
+ text_color = (120, 120, 120, 255)
+ value_color = (0, 0, 0, 255)
+ if self.color_scheme.dark or self.color_scheme.invert:
+ text_color = (135, 135, 135, 255)
+ value_color = (255, 255, 255, 255)
+
+ if map_data.history_map:
+ cruising_map = bool(map_data.task_cruise_points is not None)
+ map_type = "Cruising" if cruising_map else "Cleaning"
+ header_lines = [
+ (str(map_data.cleaning_time), f"{map_type} Time", "min"),
+ (
+ "Interrupted" if map_data.completed == False else "Completed",
+ f"{map_type} Status",
+ "",
+ ),
+ ]
+
+ if not cruising_map:
+ header_lines.append((str(map_data.cleaned_area), f"{map_type} Area", "m²"))
+
+ for i in range(len(header_lines)):
+ value = header_lines[i][0]
+ name = header_lines[i][1]
+ unit = header_lines[i][2]
+ left, top, value_width, value_height = text_draw.textbbox((0, 0), value, font=value_font)
+ left, top, unit_width, unit_height = text_draw.textbbox((0, 0), unit, font=name_font)
+ left, top, name_width, name_height = text_draw.textbbox((0, 0), name, font=name_font)
+ y = text_size
+ x = int(image_width * 0.06)
+ pos = []
+ if len(header_lines) == 3:
+ if i == 0:
+ value_x = x + name_width / 2
+ t1 = value_width / 2
+ t2 = unit_width / 2
+ t3 = text_size / 4
+ pos.extend(
+ [
+ (value_x - t1 - t2 - t3, y),
+ (x, y + (text_size * 2)),
+ (
+ value_x - t2 + t1 + t3,
+ y + value_height - unit_height,
+ ),
+ ]
+ )
+ elif i == 1:
+ pos.extend(
+ [
+ (image_width - x - value_width, text_size),
+ (
+ image_width - x - name_width - ((value_width - name_width) / 2),
+ y + (text_size * 2),
+ ),
+ ]
+ )
+ elif i == 2:
+ t1 = text_size / 2
+ pos.extend(
+ [
+ (
+ ((image_width - value_width - unit_width - t1) / 2),
+ y,
+ ),
+ (
+ (image_width - name_width) / 2,
+ y + (text_size * 2),
+ ),
+ (
+ ((image_width - unit_width + value_width + t1) / 2),
+ y + value_height - unit_height,
+ ),
+ ]
+ )
+ elif len(header_lines) == 2:
+ if i == 0:
+ t1 = text_size / 2
+ pos.extend(
+ [
+ (
+ ((image_width - value_width - unit_width - t1) / 2) - (image_width / 4),
+ y,
+ ),
+ (
+ ((image_width - name_width) / 2) - (image_width / 4),
+ y + (text_size * 2),
+ ),
+ (
+ ((image_width - unit_width + value_width + t1) / 2) - (image_width / 4),
+ y + value_height - unit_height,
+ ),
+ ]
+ )
+ elif i == 1:
+ pos.extend(
+ [
+ (
+ ((image_width - value_width) / 2) + (image_width / 4),
+ y,
+ ),
+ (
+ ((image_width - name_width) / 2) + (image_width / 4),
+ y + (text_size * 2),
+ ),
+ ]
+ )
- self._map_data = map_data
- self._robot_status = robot_status
- self._image = image
+ for k in range(len(pos)):
+ style = (value_color, value_font) if k == 0 else (text_color, name_font)
+ text_draw.text(pos[k], header_lines[i][k], fill=style[0], font=style[1])
+
+ x = (image_width - max_width) / 2
+ line_y = header_height
+ for i in range(len(lines)):
+ line_x = x + (max_width - line_sizes[i][0]) / 2
+ text_draw.text((line_x, line_y), lines[i], fill=text_color, font=text_font)
+ line_y = line_y + line_sizes[i][1]
+
+ _LOGGER.info(
+ "Render frame: %s:%s took: %.2f",
+ map_data.map_id,
+ map_data.frame_id,
+ time.time() - now,
+ )
+
+ if self._cache:
+ self._map_data = map_data
+ self._robot_status = robot_status
+ self._station_status = station_status
+ self._image = image
except Exception:
_LOGGER.error("Map render Failed: %s", traceback.format_exc())
self.render_complete = True
- return self._to_buffer(self._image)
-
- def render_objects(
- self,
- map_data,
- robot_status,
- map_image,
- scale,
- ):
- if self._map_data is None or not self._layers.get(MapRendererLayer.OBJECTS):
- self._layers[MapRendererLayer.OBJECTS] = Image.new(
- "RGBA",
- [int(map_image.size[0] * scale), int(map_image.size[1] * scale)],
- (255, 255, 255, 0),
- )
- layer = self._layers[MapRendererLayer.OBJECTS]
- layer.paste((255, 255, 255, 0), [0, 0, layer.size[0], layer.size[1]])
+ return self._to_buffer(self._image if self._cache else image)
- line_width = 3
- border_width = 2
+ def render_objects(self, cached_layers, map_data, robot_status, station_status, map_image, scale):
+ layer_size = (int(map_image.size[0] * scale), int(map_image.size[1] * scale))
+ line_width = 3 if map_data.dimensions.scale > 2 else 1
+ border_width = 2 if map_data.dimensions.scale > 2 else 1
+ changes = []
+ layers = []
- if map_data.rotation == 0 or map_data.rotation == 180:
+ if map_data.rotation == 0 or map_data.rotation == 180 or self._square:
width = (map_data.dimensions.width) + (
(
map_data.dimensions.padding[0]
@@ -3580,7 +8534,7 @@ def render_objects(
/ map_data.dimensions.scale
)
robot_icon_size = width * 0.037
- icon_size = width * 0.03
+ icon_size = width * (0.022 if self._square else 0.027)
else:
height = (map_data.dimensions.height) + (
(
@@ -3592,165 +8546,431 @@ def render_objects(
/ map_data.dimensions.scale
)
robot_icon_size = height * 0.037
- icon_size = height * 0.03
+ icon_size = height * 0.027
robot_icon_size = max(7, min(14, robot_icon_size))
- icon_size = max(5, min(10, icon_size))
+ icon_size = max(3, min(12, icon_size))
+ segment_icon_size = icon_size
- if map_data.path and self.config.path:
- if (
- self._map_data is None
- or self._map_data.path != map_data.path
- or not self._layers.get(MapRendererLayer.PATH)
- ):
- self._layers[MapRendererLayer.PATH] = self.render_path(
- map_data.path,
- self.color_scheme.path,
- layer,
- map_data.dimensions,
- line_width,
- scale,
- )
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.PATH])
+ if map_data.dimensions.scale <= 2:
+ robot_icon_size = robot_icon_size * 0.7
+ icon_size = icon_size * 1.3
- if map_data.no_mopping_areas and self.config.no_mop:
+ layer = MapRendererLayer.NO_MOP
+ if (
+ (not map_data.saved_map or map_data.recovery_map)
+ and map_data.no_mopping_areas
+ and self.config.no_mop
+ and (not robot_status or robot_status < 100)
+ ):
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.no_mopping_areas != map_data.no_mopping_areas
- or not self._layers.get(MapRendererLayer.NO_MOP)
+ or (not robot_status or self._robot_status < 100) != (not robot_status or robot_status < 100)
+ or not cached_layers.get(layer)
):
- self._layers[MapRendererLayer.NO_MOP] = self.render_areas(
+ changes.append(layer)
+ cached_layers[layer] = self.render_areas(
map_data.no_mopping_areas,
self.color_scheme.no_mop_outline,
self.color_scheme.no_mop,
- layer,
+ layer_size,
map_data.dimensions,
border_width,
scale,
)
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.NO_MOP])
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- if map_data.no_go_areas and self.config.no_go:
+ layer = MapRendererLayer.NO_GO
+ if (not map_data.saved_map or map_data.recovery_map) and map_data.no_go_areas and self.config.no_go:
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.no_go_areas != map_data.no_go_areas
- or not self._layers.get(MapRendererLayer.NO_GO)
+ or not cached_layers.get(layer)
):
- self._layers[MapRendererLayer.NO_GO] = self.render_areas(
+ changes.append(layer)
+ cached_layers[layer] = self.render_areas(
map_data.no_go_areas,
self.color_scheme.no_go_outline,
self.color_scheme.no_go,
- layer,
+ layer_size,
map_data.dimensions,
border_width,
scale,
)
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.NO_GO])
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- if map_data.walls and self.config.virtual_wall:
+ layer = MapRendererLayer.WALL
+ if (not map_data.saved_map or map_data.recovery_map) and map_data.virtual_walls and self.config.virtual_wall:
+ layers.append(layer)
if (
- self._map_data is None
- or self._map_data.walls != map_data.walls
- or not self._layers.get(MapRendererLayer.WALL)
+ not self._cache
+ or self._map_data is None
+ or self._map_data.virtual_walls != map_data.virtual_walls
+ or not cached_layers.get(layer)
):
- self._layers[MapRendererLayer.WALL] = self.render_walls(
- map_data.walls,
+ changes.append(layer)
+ cached_layers[layer] = self.render_walls(
+ map_data.virtual_walls,
self.color_scheme.virtual_wall,
- layer,
+ layer_size,
map_data.dimensions,
line_width,
scale,
)
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.WALL])
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- if map_data.active_areas and self.config.active_area:
+ layer = MapRendererLayer.VIRTUAL_THRESHOLD
+ if map_data.virtual_thresholds and self.config.pathway:
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
+ or self._map_data.virtual_thresholds != map_data.virtual_thresholds
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_walls(
+ map_data.virtual_thresholds,
+ self.color_scheme.virtual_threshold,
+ layer_size,
+ map_data.dimensions,
+ line_width,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.PASSABLE_THRESHOLD
+ if map_data.passable_thresholds and self.config.pathway:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.passable_thresholds != map_data.passable_thresholds
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_thresholds(
+ map_data.passable_thresholds,
+ self.color_scheme.passable_threshold_outline,
+ self.color_scheme.passable_threshold,
+ layer_size,
+ map_data.dimensions,
+ line_width,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.IMPASSABLE_THRESHOLD
+ if map_data.impassable_thresholds and self.config.pathway:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.impassable_thresholds != map_data.impassable_thresholds
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_thresholds(
+ map_data.impassable_thresholds,
+ self.color_scheme.impassable_threshold_outline,
+ self.color_scheme.impassable_threshold,
+ layer_size,
+ map_data.dimensions,
+ line_width,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.RAMP
+ if map_data.ramps and self.config.ramp:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.ramps != map_data.ramps
+ or self._map_data.rotation != map_data.rotation
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_ramps(
+ map_data.ramps,
+ self.color_scheme.ramp_outline,
+ self.color_scheme.ramp,
+ layer_size,
+ map_data.dimensions,
+ line_width,
+ scale,
+ map_data.rotation,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.CURTAIN
+ if map_data.curtains and self.config.curtain:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.curtains != map_data.curtains
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_curtains(
+ map_data.curtains,
+ self.color_scheme.curtain,
+ layer_size,
+ map_data.dimensions,
+ line_width,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.LOW_LYING_AREA
+ if map_data.low_lying_areas and self.config.low_lying_area:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.low_lying_areas != map_data.low_lying_areas
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_low_lying_areas(
+ map_data.low_lying_areas,
+ layer_size,
+ map_data.dimensions,
+ line_width,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.FURNITURES
+ if map_data.furnitures and self.config.furniture:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.furnitures != map_data.furnitures
+ or self._map_data.rotation != map_data.rotation
+ or not cached_layers.get(layer)
+ ):
+ if layer not in cached_layers:
+ cached_layers[MapRendererLayer.FURNITURE] = {}
+ else:
+ for k in list(cached_layers[MapRendererLayer.FURNITURE].keys()).copy():
+ if k not in map_data.furnitures:
+ del cached_layers[MapRendererLayer.FURNITURE][k]
+
+ changed = False
+ for k, v in map_data.furnitures.items():
+ if (
+ not self._cache
+ or self._map_data is None
+ or k not in cached_layers[MapRendererLayer.FURNITURE]
+ or not self._map_data.furnitures
+ or k not in self._map_data.furnitures
+ or self._map_data.furnitures[k] != v
+ or self._map_data.rotation != map_data.rotation
+ or self._map_data.hidden_segments != map_data.hidden_segments
+ ):
+ changed = True
+ cached_layers[MapRendererLayer.FURNITURE][k] = self.render_furniture(
+ v,
+ map_data.furniture_version,
+ map_data.hidden_segments,
+ layer_size,
+ map_data.dimensions,
+ int((icon_size * 1.2) * map_data.dimensions.scale),
+ map_data.rotation,
+ scale,
+ )
+
+ if changed:
+ changes.append(layer)
+ DreameVacuumMapRenderer._combine_layers(
+ cached_layers, layer_size, layer, MapRendererLayer.FURNITURE
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.ACTIVE_AREA
+ if not map_data.saved_map and map_data.active_areas and self.config.active_area:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
or self._map_data.active_areas != map_data.active_areas
- or not self._layers.get(MapRendererLayer.ACTIVE_AREA)
+ or not cached_layers.get(layer)
):
- self._layers[MapRendererLayer.ACTIVE_AREA] = self.render_areas(
+ changes.append(layer)
+ cached_layers[layer] = self.render_areas(
map_data.active_areas,
self.color_scheme.active_area_outline,
self.color_scheme.active_area,
- layer,
+ layer_size,
map_data.dimensions,
border_width,
scale,
)
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.ACTIVE_AREA])
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- if map_data.active_points and self.config.active_point:
+ layer = MapRendererLayer.ACTIVE_POINT
+ if not map_data.saved_map and map_data.active_points and self.config.active_point:
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.active_points != map_data.active_points
- or not self._layers.get(MapRendererLayer.ACTIVE_POINT)
+ or not cached_layers.get(layer)
):
- self._layers[MapRendererLayer.ACTIVE_POINT] = self.render_points(
+ changes.append(layer)
+ cached_layers[layer] = self.render_points(
map_data.active_points,
self.color_scheme.active_point_outline,
self.color_scheme.active_point,
- layer,
+ layer_size,
map_data.dimensions,
border_width,
scale,
)
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.ACTIVE_POINT])
-
- if map_data.segments and (
- self.config.icon
- or self.config.name
- or self.config.order
- or self.config.suction_level
- or self.config.water_volume
- or self.config.cleaning_times
- or self.config.cleaning_mode
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.SEGMENTS
+ if (
+ map_data.segments
+ and not (map_data.history_map and map_data.task_cruise_points)
+ and not map_data.zone_cleaning
+ and (
+ self.config.icon
+ or self.config.name
+ or self.config.order
+ or self.config.suction_level
+ or self.config.water_volume
+ or self.config.cleaning_times
+ or self.config.cleaning_mode
+ or self.config.mopping_mode
+ )
):
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.segments != map_data.segments
or self._map_data.rotation != map_data.rotation
- or bool(self._map_data.cleanset) != bool(map_data.cleanset)
- or not self._layers.get(MapRendererLayer.SEGMENTS)
+ or (not self._map_data.cleaning_map and self._map_data.active_segments != map_data.active_segments)
+ or (not self._map_data.cleaning_map and self._map_data.hidden_segments != map_data.hidden_segments)
+ or (self._map_data.cleaning_map and self._map_data.blocked_segments != map_data.blocked_segments)
+ or bool((not map_data.saved_map or map_data.recovery_map) and self._map_data.cleanset)
+ != bool((not map_data.saved_map or map_data.recovery_map) and map_data.cleanset)
+ or not cached_layers.get(layer)
):
- if MapRendererLayer.SEGMENTS not in self._layers:
- self._layers[MapRendererLayer.SEGMENTS] = {}
+ if MapRendererLayer.SEGMENT not in cached_layers:
+ cached_layers[MapRendererLayer.SEGMENT] = {}
else:
- for k in list(self._layers[MapRendererLayer.SEGMENTS].keys()).copy():
+ for k in list(cached_layers[MapRendererLayer.SEGMENT].keys()).copy():
if k not in map_data.segments:
- del self._layers[MapRendererLayer.SEGMENTS][k]
+ del cached_layers[MapRendererLayer.SEGMENT][k]
- for k, v in map_data.segments.items():
+ changed = False
+ for k in sorted(map_data.segments.keys()):
+ v = map_data.segments[k]
if (
- self._map_data is None
- or k not in self._layers[MapRendererLayer.SEGMENTS]
+ not self._cache
+ or self._map_data is None
+ or k not in cached_layers[MapRendererLayer.SEGMENT]
or not self._map_data.segments
or k not in self._map_data.segments
or self._map_data.segments[k] != v
or self._map_data.rotation != map_data.rotation
- or bool(self._map_data.cleanset) != bool(map_data.cleanset)
+ or bool((not map_data.saved_map or map_data.recovery_map) and self._map_data.cleanset)
+ != bool((not map_data.saved_map or map_data.recovery_map) and map_data.cleanset)
+ or bool(
+ (
+ (not map_data.active_segments or k in map_data.active_segments)
+ and (not map_data.hidden_segments or k not in map_data.hidden_segments)
+ and not map_data.cleaning_map
+ )
+ )
+ != bool(
+ (
+ (not self._map_data.active_segments or k in self._map_data.active_segments)
+ and (not self._map_data.hidden_segments or k not in self._map_data.hidden_segments)
+ and not self._map_data.cleaning_map
+ )
+ )
+ or bool(
+ (map_data.cleaning_map and (map_data.blocked_segments and k in map_data.blocked_segments))
+ )
+ != bool(
+ (
+ self._map_data.cleaning_map
+ and self._map_data.blocked_segments
+ and k in self._map_data.blocked_segments
+ )
+ ),
):
- self._layers[MapRendererLayer.SEGMENTS][k] = self.render_segment(
+ changed = True
+ cached_layers[MapRendererLayer.SEGMENT][k] = self.render_segment(
v,
- bool(map_data.cleanset),
- layer,
+ bool((not map_data.saved_map or map_data.recovery_map) and map_data.cleanset),
+ bool((not map_data.saved_map or map_data.recovery_map) and map_data.sequence),
+ layer_size,
map_data.dimensions,
- int(icon_size * map_data.dimensions.scale),
+ int(segment_icon_size * map_data.dimensions.scale),
map_data.rotation,
scale,
+ (
+ (not map_data.active_segments or k in map_data.active_segments)
+ and (not map_data.hidden_segments or k not in map_data.hidden_segments)
+ and not map_data.cleaning_map
+ ),
+ (map_data.cleaning_map and map_data.blocked_segments and k in map_data.blocked_segments),
)
- if self._layers[MapRendererLayer.SEGMENTS]:
- for k, v in sorted(self._layers[MapRendererLayer.SEGMENTS].items(), reverse=True):
- layer = Image.alpha_composite(layer, v)
+ if changed:
+ changes.append(layer)
+ DreameVacuumMapRenderer._combine_layers(cached_layers, layer_size, layer, MapRendererLayer.SEGMENT)
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+ layer = MapRendererLayer.CHARGER
if map_data.charger_position and self.config.charger:
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.charger_position != map_data.charger_position
or self._map_data.rotation != map_data.rotation
- or bool(self._robot_status > 5) != bool(robot_status > 5)
- or not self._layers.get(MapRendererLayer.CHARGER)
+ or self._station_status != station_status
+ or not cached_layers.get(layer)
):
# def correct_charger_position(chargerPos, pixel_type, width, height, x, y, gridWidth, borderValue):
# newChargerPos = copy.deepcopy(chargerPos)
@@ -3871,42 +9091,56 @@ def render_objects(
# return newChargerPos
charger_position = map_data.charger_position
- if self._robot_shape != 1 and self.icon_set == 2:
+ offset = 0
+ if self._robot_type != RobotType.VSLAM and self.icon_set == 2:
offset = int(robot_icon_size * 21.42)
+ elif self._robot_type == RobotType.VSLAM and self.icon_set == 3:
+ offset = int(-robot_icon_size * 18)
+
+ if offset:
charger_position = Point(
charger_position.x - offset * math.cos(charger_position.a * math.pi / 180),
charger_position.y - offset * math.sin(charger_position.a * math.pi / 180),
charger_position.a,
)
- self._layers[MapRendererLayer.CHARGER] = self.render_charger(
+ changes.append(layer)
+ cached_layers[layer] = self.render_charger(
charger_position,
- robot_status,
- layer,
+ station_status,
+ layer_size,
map_data.dimensions,
- int((robot_icon_size * map_data.dimensions.scale) * 1.2),
+ int((robot_icon_size * (map_data.dimensions.scale if map_data.dimensions.scale > 2 else 3)) * 1.2),
map_data.rotation,
scale,
)
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.CHARGER])
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- if map_data.robot_position and self.config.robot:
+ layer = MapRendererLayer.ROBOT
+ if not map_data.saved_map and map_data.robot_position and self.config.robot:
+ layers.append(layer)
if (
- self._map_data is None
+ not self._cache
+ or self._map_data is None
or self._map_data.robot_position != map_data.robot_position
or self._map_data.charger_position != map_data.charger_position
or self._map_data.rotation != map_data.rotation
or self._robot_status != robot_status
+ or self._station_status != station_status
or self._map_data.docked != map_data.docked
- or not self._layers.get(MapRendererLayer.ROBOT)
+ or not cached_layers.get(layer)
):
robot_position = map_data.robot_position
- if map_data.docked:
+ if map_data.docked and map_data.charger_position:
# Calculate charger angle
charger_angle = map_data.charger_position.a
- if self._robot_shape != 1:
- offset = int(robot_icon_size * 21.42)
+ if self._robot_type != RobotType.VSLAM:
+ offset = int(
+ robot_icon_size * (15 if self._robot_type == RobotType.SWEEPING_AND_MOPPING else 21.42)
+ )
if self.icon_set != 2:
if charger_angle > -45 and charger_angle < 45:
@@ -3945,66 +9179,236 @@ def render_objects(
robot_position = Point(
map_data.charger_position.x + offset * math.cos(charger_angle * math.pi / 180),
map_data.charger_position.y + offset * math.sin(charger_angle * math.pi / 180),
- charger_angle + 180 if self._robot_shape != 2 else charger_angle,
+ (
+ charger_angle + 180
+ if self._robot_type != RobotType.MOPPING
+ and self._robot_type != RobotType.SWEEPING_AND_MOPPING
+ else charger_angle
+ ),
+ )
+
+ changes.append(layer)
+ cached_layers[layer] = self.render_vacuum(
+ robot_position,
+ robot_status,
+ layer_size,
+ map_data.dimensions,
+ int(robot_icon_size * (map_data.dimensions.scale if map_data.dimensions.scale > 2 else 3)),
+ map_data.rotation,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.ROUTER
+ if map_data.router_position and map_data.wifi_map:
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.router_position != map_data.router_position
+ or self._map_data.rotation != map_data.rotation
+ or not cached_layers.get(layer)
+ ):
+ changes.append(layer)
+ cached_layers[layer] = self.render_router(
+ map_data.router_position,
+ layer_size,
+ map_data.dimensions,
+ int((robot_icon_size * 1.25) * map_data.dimensions.scale),
+ map_data.rotation,
+ scale,
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
+
+ layer = MapRendererLayer.OBSTACLES
+ if not map_data.saved_map and map_data.obstacles and (self.config.obstacle or self.config.pet):
+ layers.append(layer)
+ if (
+ not self._cache
+ or self._map_data is None
+ or self._map_data.obstacles != map_data.obstacles
+ or self._map_data.rotation != map_data.rotation
+ or not cached_layers.get(layer)
+ ):
+ if MapRendererLayer.OBSTACLE not in cached_layers:
+ cached_layers[MapRendererLayer.OBSTACLE] = {}
+ else:
+ for k in list(cached_layers[MapRendererLayer.OBSTACLE].keys()).copy():
+ if k not in map_data.obstacles:
+ del cached_layers[MapRendererLayer.OBSTACLE][k]
+
+ changed = False
+ for k, v in map_data.obstacles.items():
+ if (
+ not self.config.obstacle
+ and v.type != ObstacleType.PET
+ and v.type != ObstacleType.LIQUID_STAIN
+ and v.type != ObstacleType.DRIED_STAIN
+ and v.type != ObstacleType.UNCLEANABLE_STAIN
+ and v.type != ObstacleType.DETECTED_STAIN
+ and v.type != ObstacleType.CLEANED_STAIN
+ and v.type != ObstacleType.SKIPPED_UNCLEANABLE_STAIN
+ and v.type != ObstacleType.CLEANED_DRIED_STAIN
+ and v.type != ObstacleType.LARGE_PARTICLES
+ and v.type != ObstacleType.CLEANED_LARGE_PARTICLES
+ ):
+ continue
+ if (
+ not self.config.stain
+ and v.type != ObstacleType.LIQUID_STAIN
+ and v.type != ObstacleType.DRIED_STAIN
+ and v.type != ObstacleType.UNCLEANABLE_STAIN
+ and v.type != ObstacleType.DETECTED_STAIN
+ and v.type != ObstacleType.CLEANED_STAIN
+ and v.type != ObstacleType.SKIPPED_UNCLEANABLE_STAIN
+ and v.type != ObstacleType.CLEANED_DRIED_STAIN
+ ):
+ continue
+ elif not self.config.pet and (
+ v.type == ObstacleType.PET
+ or v.type == ObstacleType.FOOD_BOWL
+ or v.type == ObstacleType.PET_BED
+ ):
+ continue
+ elif (
+ v.type == ObstacleType.BLOCKED_ROOM and not map_data.history_map and not map_data.cleaning_map
+ ):
+ continue
+
+ if (
+ not self._cache
+ or self._map_data is None
+ or k not in cached_layers[MapRendererLayer.OBSTACLE]
+ or not self._map_data.obstacles
+ or k not in self._map_data.obstacles
+ or self._map_data.obstacles[k] != v
+ or self._map_data.rotation != map_data.rotation
+ ):
+ obstacle_image = self.render_obstacle(
+ v,
+ layer_size,
+ map_data.dimensions,
+ int((icon_size * 1.2) * map_data.dimensions.scale),
+ map_data.rotation,
+ scale,
+ )
+ if obstacle_image:
+ changed = True
+ cached_layers[MapRendererLayer.OBSTACLE][k] = obstacle_image
+ elif k in cached_layers[MapRendererLayer.OBSTACLE]:
+ del cached_layers[MapRendererLayer.OBSTACLE][k]
+
+ if changed:
+ changes.append(layer)
+ DreameVacuumMapRenderer._combine_layers(
+ cached_layers, layer_size, layer, MapRendererLayer.OBSTACLE
)
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- self._layers[MapRendererLayer.ROBOT] = self.render_vacuum(
- robot_position,
- robot_status,
- layer,
- map_data.dimensions,
- int(robot_icon_size * map_data.dimensions.scale),
- map_data.rotation,
- scale,
- )
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.ROBOT])
-
- if map_data.obstacles and self.config.obstacle:
+ layer = MapRendererLayer.CRUISE_POINTS
+ if not map_data.saved_map and map_data.active_cruise_points: # and self.config.cruise_point:
+ layers.append(layer)
if (
- self._map_data is None
- or self._map_data.obstacles != map_data.obstacles
+ not self._cache
+ or self._map_data is None
+ or self._map_data.active_cruise_points != map_data.active_cruise_points
or self._map_data.rotation != map_data.rotation
- or not self._layers.get(MapRendererLayer.OBSTACLES)
+ or not cached_layers.get(layer)
):
- self._layers[MapRendererLayer.OBSTACLES] = self.render_obstacles(
- map_data.obstacles,
- layer,
- map_data.dimensions,
- int((icon_size * 2) * map_data.dimensions.scale),
- map_data.rotation,
- scale,
- )
+ if MapRendererLayer.CRUISE_POINT not in cached_layers:
+ cached_layers[MapRendererLayer.CRUISE_POINT] = {}
+ else:
+ for k in list(cached_layers[MapRendererLayer.CRUISE_POINT].keys()).copy():
+ if k not in map_data.active_cruise_points:
+ del cached_layers[MapRendererLayer.CRUISE_POINT][k]
+
+ changed = False
+ for k, v in map_data.active_cruise_points.items():
+ if (
+ self._map_data is None
+ or k not in cached_layers[MapRendererLayer.CRUISE_POINT]
+ or not self._map_data.active_cruise_points
+ or k not in self._map_data.active_cruise_points
+ or self._map_data.active_cruise_points[k] != v
+ or self._map_data.rotation != map_data.rotation
+ ):
+ changed = True
+ cached_layers[MapRendererLayer.CRUISE_POINT][k] = self.render_cruise_point(
+ k,
+ v,
+ layer_size,
+ map_data.dimensions,
+ int(round(icon_size * 1.25 * map_data.dimensions.scale)),
+ map_data.rotation,
+ scale,
+ )
+
+ if changed:
+ changes.append(layer)
+ DreameVacuumMapRenderer._combine_layers(
+ cached_layers, layer_size, layer, MapRendererLayer.CRUISE_POINT
+ )
+ elif self._cache and cached_layers.get(layer):
+ changes.append(layer)
+ del cached_layers[layer]
- layer = Image.alpha_composite(layer, self._layers[MapRendererLayer.OBSTACLES])
+ if changes or not self._cache:
+ cached_layers[MapRendererLayer.OBJECTS] = Image.new(
+ "RGBA",
+ [layer_size[0], layer_size[1]],
+ (255, 255, 255, 0),
+ )
+ for l in layers:
+ if cached_layers.get(l):
+ if l in changes:
+ _LOGGER.debug("Render %s", l.name)
+ cached_layers[MapRendererLayer.OBJECTS] = Image.alpha_composite(
+ cached_layers[MapRendererLayer.OBJECTS], cached_layers[l]
+ )
- if layer.size != map_image.size:
- layer.thumbnail(map_image.size, Image.Resampling.BOX, reducing_gap=1.5)
+ if layer_size != map_image.size:
+ cached_layers[MapRendererLayer.OBJECTS].thumbnail(
+ map_image.size, Image.Resampling.BOX, reducing_gap=1.5
+ )
+ else:
+ if not cached_layers.get(MapRendererLayer.OBJECTS):
+ return map_image
return Image.alpha_composite(
map_image,
- layer,
+ cached_layers[MapRendererLayer.OBJECTS],
)
- def render_areas(self, areas, color, fill, layer, dimensions, width, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_areas(self, areas, color, fill, layer_size, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
draw = ImageDraw.Draw(new_layer, "RGBA")
for area in areas:
p = area.to_img(dimensions)
- coords = [
- p.x0 * scale,
- p.y0 * scale,
- p.x1 * scale,
- p.y1 * scale,
- p.x2 * scale,
- p.y2 * scale,
- p.x3 * scale,
- p.y3 * scale,
- ]
- draw.polygon(coords, fill, color, width=(width * scale))
+ draw.polygon(
+ [
+ p.x0 * scale,
+ p.y0 * scale,
+ p.x1 * scale,
+ p.y1 * scale,
+ p.x2 * scale,
+ p.y2 * scale,
+ p.x3 * scale,
+ p.y3 * scale,
+ ],
+ fill,
+ color,
+ width=(width * scale),
+ )
return new_layer
- def render_points(self, points, color, fill, layer, dimensions, width, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_points(self, points, color, fill, layer_size, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
draw = ImageDraw.Draw(new_layer, "RGBA")
size = 15 * dimensions.grid_size
for point in points:
@@ -4033,8 +9437,8 @@ def render_points(self, points, color, fill, layer, dimensions, width, scale):
draw.polygon(coords, fill, color, width=(width * scale))
return new_layer
- def render_walls(self, walls, color, layer, dimensions, width, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_walls(self, walls, color, layer_size, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
draw = ImageDraw.Draw(new_layer, "RGBA")
for wall in walls:
p = wall.to_img(dimensions)
@@ -4045,8 +9449,174 @@ def render_walls(self, walls, color, layer, dimensions, width, scale):
)
return new_layer
- def render_path(self, path, color, layer, dimensions, width, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_thresholds(self, thresholds, color, fill, layer_size, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ for wall in thresholds:
+ p = wall.to_img(dimensions)
+
+ thickness = width * 8
+ w = -(p.y1 - p.y0)
+ h = p.x1 - p.x0
+ t = math.sqrt(w * w + h * h)
+ x = w / t * thickness / 2
+ y = h / t * thickness / 2
+
+ draw.polygon(
+ [
+ (p.x0 - x) * scale,
+ (p.y0 - y) * scale,
+ (p.x1 - x) * scale,
+ (p.y1 - y) * scale,
+ (p.x1 + x) * scale,
+ (p.y1 + y) * scale,
+ (p.x0 + x) * scale,
+ (p.y0 + y) * scale,
+ ],
+ fill,
+ color,
+ width=(width * scale),
+ )
+
+ thickness = thickness - width
+ x = w / t * thickness / 2
+ y = h / t * thickness / 2
+
+ coords = [
+ (p.x0 - x) * scale,
+ (p.y0 - y) * scale,
+ (p.x1 - x) * scale,
+ (p.y1 - y) * scale,
+ (p.x1 + x) * scale,
+ (p.y1 + y) * scale,
+ (p.x0 + x) * scale,
+ (p.y0 + y) * scale,
+ ]
+
+ bp = DreameVacuumMapRenderer._coords_on_line(coords[0], coords[1], coords[2], coords[3], thickness * scale)
+ tp = DreameVacuumMapRenderer._coords_on_line(coords[6], coords[7], coords[4], coords[5], thickness * scale)
+
+ for i in range(len(tp) - 1):
+ draw.line(
+ [tp[i][0], tp[i][1], bp[i + 1][0], bp[i + 1][1]], color, width=(width * scale), joint="curve"
+ )
+ return new_layer
+
+ def render_curtains(self, curtains, color, layer_size, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ for wall in curtains:
+ p = wall.to_img(dimensions)
+
+ w = -(p.y1 - p.y0)
+ h = p.x1 - p.x0
+ t = math.sqrt(w * w + h * h)
+ x = w / t * 5
+ y = h / t * 5
+
+ coords = [
+ (p.x0 - x) * scale,
+ (p.y0 - y) * scale,
+ (p.x1 - x) * scale,
+ (p.y1 - y) * scale,
+ (p.x1 + x) * scale,
+ (p.y1 + y) * scale,
+ (p.x0 + x) * scale,
+ (p.y0 + y) * scale,
+ ]
+
+ t = int(
+ math.floor(
+ math.sqrt((wall.x0 - wall.x1) * (wall.x0 - wall.x1) + (wall.y0 - wall.y1) * (wall.y0 - wall.y1))
+ / 150
+ )
+ )
+ tp = DreameVacuumMapRenderer._coords_on_line(coords[6], coords[7], coords[4], coords[5], 0, t + 1)
+ bp = DreameVacuumMapRenderer._coords_on_line(coords[0], coords[1], coords[2], coords[3], 0, t + 1)
+
+ path = []
+ for i in range(0, len(tp) - 1, 2):
+ path.extend([tp[i][0], tp[i][1], bp[i + 1][0], bp[i + 1][1]])
+ draw.line(path, color, width=(width * scale), joint="curve")
+
+ return new_layer
+
+ def render_ramps(self, ramps, color, fill, layer_size, dimensions, width, scale, rotation):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ for area in ramps:
+ p = area.to_img(dimensions)
+ draw.polygon(
+ [
+ p.x0 * scale,
+ p.y0 * scale,
+ p.x1 * scale,
+ p.y1 * scale,
+ p.x2 * scale,
+ p.y2 * scale,
+ p.x3 * scale,
+ p.y3 * scale,
+ ],
+ fill,
+ color,
+ width=(width * scale),
+ )
+
+ p0 = Point(area.x0, area.y0).to_img(dimensions)
+ p1 = Point(area.x2, area.y2).to_img(dimensions)
+
+ x_coords = sorted([p0.x, p1.x])
+ y_coords = sorted([p0.y, p1.y])
+ min_x = x_coords[0]
+ min_y = y_coords[0]
+ max_x = x_coords[1]
+ max_y = y_coords[1]
+ w = max_x - min_x
+ h = max_y - min_y
+
+ m = min(w, h)
+ s = width
+ size = 8.165 * dimensions.scale
+
+ if m < size:
+ s /= 2
+ size = m * 0.6
+
+ sx = int(w / size)
+ sy = int(h / size)
+ rw = size * 0.6
+ rh = rw / 2
+ xx = (w - sx * rw) / (sx + 1)
+ yy = (h - sy * rh) / (sy + 1)
+
+ arrow_image = Image.new("RGBA", (int(w * scale), int(h * scale)), (255, 255, 255, 0))
+ arrow_draw = ImageDraw.Draw(arrow_image, "RGBA")
+
+ for k in range(sx):
+ for j in range(sy):
+ x = xx * (k + 1) + rw * k
+ y = h - yy * (j + 1) - rh * j
+ arrow_draw.line(
+ [x * scale, y * scale, (x + rh) * scale, (y - rh) * scale, (x + (rh * 2)) * scale, y * scale],
+ width=int(s * scale),
+ fill=color,
+ joint="curve",
+ )
+
+ arrow_image = arrow_image.rotate(area.angle, expand=1)
+ new_layer.paste(
+ arrow_image,
+ (
+ int(((min_x + (w / 2)) * scale) - (arrow_image.size[0] / 2)),
+ int(((min_y + (h / 2)) * scale) - (arrow_image.size[1] / 2)),
+ ),
+ arrow_image,
+ )
+
+ return new_layer
+
+ def render_path(self, path, color, mop_color, layer_size, mask, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
draw = ImageDraw.Draw(new_layer, "RGBA")
sweep = []
mop = []
@@ -4055,13 +9625,13 @@ def render_path(self, path, color, layer, dimensions, width, scale):
path_type = ""
for point in path:
- p = point.to_img(dimensions)
+ p = point.to_img(dimensions, True)
if point.path_type == PathType.LINE:
l = [p.x * scale, p.y * scale]
- if path_type == PathType.SWEEP_AND_MOP or path_type == PathType.SWEEP:
+ if path_type == PathType.SWEEP_AND_MOP or (path_type == PathType.SWEEP or self._low_memory):
sweep_path.extend(l)
- if path_type == PathType.SWEEP_AND_MOP or path_type == PathType.MOP:
+ if not self._low_memory and (path_type == PathType.SWEEP_AND_MOP or path_type == PathType.MOP):
mop_path.extend(l)
else:
if mop_path:
@@ -4071,12 +9641,12 @@ def render_path(self, path, color, layer, dimensions, width, scale):
sweep.append(sweep_path)
path_type = point.path_type
- if path_type == PathType.SWEEP_AND_MOP or path_type == PathType.SWEEP:
+ if path_type == PathType.SWEEP_AND_MOP or (path_type == PathType.SWEEP or self._low_memory):
sweep_path = [p.x * scale, p.y * scale]
else:
sweep_path = []
- if path_type == PathType.SWEEP_AND_MOP or path_type == PathType.MOP:
+ if not self._low_memory and (path_type == PathType.SWEEP_AND_MOP or path_type == PathType.MOP):
mop_path = [p.x * scale, p.y * scale]
else:
mop_path = []
@@ -4087,20 +9657,27 @@ def render_path(self, path, color, layer, dimensions, width, scale):
if mop_path:
mop.append(mop_path)
+ if mop and mask:
+ mop_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ mop_draw = ImageDraw.Draw(mop_layer, "RGBA")
+
for path in mop:
- size = width * scale * 12
- draw.line(
+ size = width * scale * 10.5
+ (mop_draw if mask else draw).line(
path,
- width=int(size),
- fill=(color[0], color[1], color[2], 100),
+ width=int(round(size)),
+ fill=mop_color,
joint="curve",
)
+ if mop and mask:
+ new_layer.paste(mop_layer, (0, 0), mask=mask)
+
for path in sweep:
size = width * scale
draw.line(
path,
- width=int(size),
+ width=int(round(size)),
fill=color,
joint="curve",
)
@@ -4126,28 +9703,36 @@ def render_path(self, path, color, layer, dimensions, width, scale):
return new_layer
- def render_charger(self, charger_position, robot_status, layer, dimensions, size, map_rotation, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_charger(
+ self,
+ charger_position,
+ station_status,
+ layer_size,
+ dimensions,
+ size,
+ map_rotation,
+ scale,
+ ):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
icon_size = int(size * scale)
+ if self.icon_set == 3:
+ icon_size = int(icon_size * 1.2)
+ elif self.icon_set == 2:
+ icon_size = int(icon_size * 1.5)
+ elif self._robot_type == RobotType.VSLAM:
+ icon_size = int(icon_size * 1.5)
+
if self._charger_icon is None:
if self.icon_set == 3:
charger_image = MAP_CHARGER_IMAGE_MATERIAL
- icon_size = int(icon_size * 1.2)
elif self.icon_set == 2:
charger_image = MAP_CHARGER_IMAGE_MIJIA
- icon_size = int(icon_size * 1.5)
else:
- if self._robot_shape == 1:
+ if self._robot_type == RobotType.VSLAM:
charger_image = MAP_CHARGER_VSLAM_IMAGE_DREAME
- icon_size = int(icon_size * 1.5)
else:
charger_image = MAP_CHARGER_IMAGE_DREAME
-
- self._charger_icon = (
- Image.open(BytesIO(base64.b64decode(charger_image)))
- .convert("RGBA")
- .resize((icon_size, icon_size), resample=Image.Resampling.NEAREST)
- )
+ self._charger_icon = Image.open(BytesIO(base64.b64decode(charger_image))).convert("RGBA")
if self.icon_set == 3:
self._charger_icon = DreameVacuumMapRenderer._set_icon_color(
@@ -4160,10 +9745,13 @@ def render_charger(self, charger_position, robot_status, layer, dimensions, size
enhancer = ImageEnhance.Brightness(self._charger_icon)
self._charger_icon = enhancer.enhance(0.7)
- charger_icon = self._charger_icon.rotate(
+ charger_icon = self._charger_icon.resize((icon_size, icon_size), resample=Image.Resampling.NEAREST).rotate(
(
charger_position.a
- if self._robot_shape == 1 or self.icon_set == 2 or self.icon_set == 3
+ if self._robot_type == RobotType.VSLAM
+ or self.icon_set == 0
+ or self.icon_set == 2
+ or self.icon_set == 3
else (-map_rotation)
),
expand=1,
@@ -4172,27 +9760,105 @@ def render_charger(self, charger_position, robot_status, layer, dimensions, size
point = charger_position.to_img(dimensions)
new_layer.paste(
charger_icon,
- (int((point.x * scale) - (charger_icon.size[0] / 2)), int((point.y * scale) - (charger_icon.size[1] / 2))),
+ (
+ int((point.x * scale) - (charger_icon.size[0] / 2)),
+ int((point.y * scale) - (charger_icon.size[1] / 2)),
+ ),
charger_icon,
)
- if robot_status > 5:
- if self._robot_washing_icon is None:
- self._robot_washing_icon = (
- Image.open(BytesIO(base64.b64decode(MAP_ROBOT_WASHING_IMAGE)))
- .convert("RGBA")
- .resize((int(icon_size * 1.25), int(icon_size * 1.25)), resample=Image.Resampling.NEAREST)
- .rotate(-map_rotation)
- )
- enhancer = ImageEnhance.Brightness(self._robot_washing_icon)
- if self.color_scheme.dark:
- self._robot_washing_icon = enhancer.enhance(0.65)
+ if station_status > 0 and not self._low_memory:
+ hot_washing = False
+ if station_status >= 10:
+ hot_washing = True
+ station_status = station_status - 10
+
+ if station_status == 1:
+ if self._robot_emptying_icon is None:
+ self._robot_emptying_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_EMPTYING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ (int(icon_size * 1.25), int(icon_size * 1.25)),
+ resample=Image.Resampling.NEAREST,
+ )
+ .rotate(-map_rotation, expand=1)
+ )
+ offset = icon_size * 1.2
+ icon = self._robot_emptying_icon
+ elif station_status < 4:
+ if not hot_washing and self._robot_washing_icon is None:
+ self._robot_washing_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_WASHING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ (int(icon_size * 1.25), int(icon_size * 1.25)),
+ resample=Image.Resampling.NEAREST,
+ )
+ .rotate(-map_rotation, expand=1)
+ )
+ enhancer = ImageEnhance.Brightness(self._robot_washing_icon)
+ if self.color_scheme.dark:
+ self._robot_washing_icon = enhancer.enhance(0.65)
+
+ if hot_washing and self._robot_hot_washing_icon is None:
+ self._robot_hot_washing_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_HOT_WASHING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ (int(icon_size * 1.25), int(icon_size * 1.25)),
+ resample=Image.Resampling.NEAREST,
+ )
+ .rotate(-map_rotation, expand=1)
+ )
+ enhancer = ImageEnhance.Brightness(self._robot_hot_washing_icon)
+ if self.color_scheme.dark:
+ self._robot_hot_washing_icon = enhancer.enhance(0.65)
+
+ offset = icon_size * 1.5
+ icon = self._robot_hot_washing_icon if hot_washing else self._robot_washing_icon
+ else:
+ offset = icon_size * 1.2
+
+ if station_status == 5 or station_status == 6:
+ if self._robot_dust_bag_drying_icon is None:
+ self._robot_dust_bag_drying_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_DUST_BAG_DRYING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ (int(icon_size * 1.25), int(icon_size * 1.25)),
+ resample=Image.Resampling.NEAREST,
+ )
+ .rotate(-map_rotation, expand=1)
+ )
+
+ icon = self._robot_dust_bag_drying_icon
+ else:
+ if not hot_washing and self._robot_drying_icon is None:
+ self._robot_drying_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_DRYING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ (int(icon_size * 1.25), int(icon_size * 1.25)),
+ resample=Image.Resampling.NEAREST,
+ )
+ .rotate(-map_rotation, expand=1)
+ )
- icon = self._robot_washing_icon
+ if hot_washing and self._robot_hot_drying_icon is None:
+ self._robot_hot_drying_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_HOT_DRYING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ (int(icon_size * 1.25), int(icon_size * 1.25)),
+ resample=Image.Resampling.NEAREST,
+ )
+ .rotate(-map_rotation, expand=1)
+ )
+ icon = self._robot_hot_drying_icon if hot_washing else self._robot_drying_icon
icon_x = point.x * scale
icon_y = point.y * scale
- offset = icon_size * 1.5
if map_rotation == 90:
icon_x = icon_x + offset
elif map_rotation == 180:
@@ -4202,30 +9868,41 @@ def render_charger(self, charger_position, robot_status, layer, dimensions, size
else:
icon_y = icon_y - offset
- new_layer.paste(
- icon,
- (int(icon_x - (icon.size[0] / 2)), int(icon_y - (icon.size[1] / 2))),
- icon,
- )
+ new_layer.paste(icon, (int(icon_x - (icon.size[0] / 2)), int(icon_y - (icon.size[1] / 2))))
+
return new_layer
- def render_vacuum(self, robot_position, robot_status, layer, dimensions, size, map_rotation, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_vacuum(
+ self,
+ robot_position,
+ robot_status,
+ layer_size,
+ dimensions,
+ size,
+ map_rotation,
+ scale,
+ ):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
icon_size = int(size * scale)
+ robot_icon_size = (
+ int(icon_size * 1.4)
+ if self.icon_set == 2 or (self._robot_type == RobotType.VSLAM and self.icon_set == 3)
+ else icon_size
+ )
if self._robot_icon is None:
- robot_icon_size = icon_size
if self.icon_set == 2:
- robot_icon_size = int(icon_size * 1.4)
- if self._robot_shape == 2:
+ if self._robot_type == RobotType.MOPPING:
robot_image = MAP_ROBOT_MOP_IMAGE_MIJIA
- elif self._robot_shape == 1:
+ elif self._robot_type == RobotType.VSLAM:
robot_image = MAP_ROBOT_VSLAM_IMAGE_MIJIA
else:
robot_image = MAP_ROBOT_LIDAR_IMAGE_MIJIA
else:
- if self._robot_shape == 2:
+ if self._robot_type == RobotType.MOPPING:
robot_image = MAP_ROBOT_MOP_IMAGE_DREAME
- elif self._robot_shape == 1:
+ elif self._robot_type == RobotType.SWEEPING_AND_MOPPING:
+ robot_image = MAP_ROBOT_LIDAR_IMAGE_DREAME_LIGHT
+ elif self._robot_type == RobotType.VSLAM:
if self.icon_set == 3:
robot_image = MAP_ROBOT_VSLAM_IMAGE_DREAME_LIGHT
else:
@@ -4236,81 +9913,104 @@ def render_vacuum(self, robot_position, robot_status, layer, dimensions, size, m
else:
robot_image = MAP_ROBOT_LIDAR_IMAGE_DREAME_DARK
- self._robot_icon = (
- Image.open(BytesIO(base64.b64decode(robot_image)))
- .convert("RGBA")
- .resize((robot_icon_size, robot_icon_size), resample=Image.Resampling.NEAREST)
- )
+ self._robot_icon = Image.open(BytesIO(base64.b64decode(robot_image))).convert("RGBA")
- if self._robot_shape != 2 and self.icon_set != 2 and self.icon_set != 3:
+ if (
+ self._robot_type != RobotType.MOPPING
+ and self._robot_type != RobotType.SWEEPING_AND_MOPPING
+ and self.icon_set != 2
+ and self.icon_set != 3
+ ):
enhancer = ImageEnhance.Brightness(self._robot_icon)
if self.color_scheme.dark:
self._robot_icon = enhancer.enhance(1.5)
else:
self._robot_icon = enhancer.enhance(0.9)
- icon = self._robot_icon.rotate(robot_position.a)
+ icon = self._robot_icon.resize(
+ (robot_icon_size, robot_icon_size),
+ resample=Image.Resampling.NEAREST,
+ ).rotate(robot_position.a, expand=1)
point = robot_position.to_img(dimensions)
- status_icon = None
- if robot_status == 1:
- if self._robot_cleaning_icon is None:
- self._robot_cleaning_icon = (
- Image.open(BytesIO(base64.b64decode(MAP_ROBOT_CLEANING_IMAGE)))
- .convert("RGBA")
- .resize(((int(icon_size * 1.25), int(icon_size * 1.25))), resample=Image.Resampling.NEAREST)
- )
- status_icon = self._robot_cleaning_icon
-
- if self.config.cleaning_direction:
- if self._robot_cleaning_direction_icon is None:
- self._robot_cleaning_direction_icon = (
- Image.open(BytesIO(base64.b64decode(MAP_ROBOT_CLEANING_DIRECTION_IMAGE)))
+ if not self._low_memory:
+ status_icon = None
+ has_warning = False
+ if robot_status >= 100:
+ robot_status = robot_status - 100
+ if robot_status >= 10:
+ has_warning = True
+ robot_status = robot_status - 10
+
+ if robot_status == 1:
+ if self._robot_cleaning_icon is None:
+ self._robot_cleaning_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_CLEANING_IMAGE)))
.convert("RGBA")
- .resize(((int(icon_size * 1.5), int(icon_size * 1.5))), resample=Image.Resampling.NEAREST)
+ .resize(
+ ((int(icon_size * 1.25), int(icon_size * 1.25))),
+ resample=Image.Resampling.NEAREST,
+ )
)
+ status_icon = self._robot_cleaning_icon
+
+ if self.config.cleaning_direction:
+ if self._robot_cleaning_direction_icon is None:
+ self._robot_cleaning_direction_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_CLEANING_DIRECTION_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ ((int(icon_size * 1.5), int(icon_size * 1.5))),
+ )
+ )
+
+ ico = self._robot_cleaning_direction_icon.rotate(robot_position.a, expand=1)
- ico = self._robot_cleaning_direction_icon.rotate(robot_position.a, expand=1)
+ offset = int(icon_size * 0.3)
+ x = point.x + offset * math.cos(-robot_position.a * math.pi / 180)
+ y = point.y + offset * math.sin(-robot_position.a * math.pi / 180)
+ new_layer.paste(
+ ico,
+ (
+ int(x * scale - (ico.size[0] / 2)),
+ int(y * scale - (ico.size[1] / 2)),
+ ),
+ )
+ elif robot_status == 2:
+ if self._robot_charging_icon is None:
+ self._robot_charging_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_CHARGING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ ((int(icon_size * 1.3), int(icon_size * 1.3))),
+ resample=Image.Resampling.NEAREST,
+ )
+ )
+ status_icon = self._robot_charging_icon
+ elif has_warning:
+ if self._robot_warning_icon is None:
+ self._robot_warning_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_ROBOT_WARNING_IMAGE)))
+ .convert("RGBA")
+ .resize(
+ ((int(icon_size * 1.3), int(icon_size * 1.3))),
+ resample=Image.Resampling.NEAREST,
+ )
+ )
+ status_icon = self._robot_warning_icon
- offset = int(icon_size / 2)
- x = point.x + offset * math.cos(-robot_position.a * math.pi / 180)
- y = point.y + offset * math.sin(-robot_position.a * math.pi / 180)
+ if status_icon:
+ mask = Image.new("L", status_icon.size, 0)
+ draw = ImageDraw.Draw(mask)
+ draw.ellipse((0, 0, status_icon.size[0], status_icon.size[1]), fill=255)
new_layer.paste(
- ico,
+ status_icon,
(
- int(x * scale - (ico.size[0] / 2)),
- int(y * scale - (ico.size[1] / 2)),
+ int(point.x * scale - (status_icon.size[0] / 2)),
+ int(point.y * scale - (status_icon.size[1] / 2)),
),
+ mask,
)
- elif robot_status == 2:
- if self._robot_charging_icon is None:
- self._robot_charging_icon = (
- Image.open(BytesIO(base64.b64decode(MAP_ROBOT_CHARGING_IMAGE)))
- .convert("RGBA")
- .resize(((int(icon_size * 1.3), int(icon_size * 1.3))), resample=Image.Resampling.NEAREST)
- )
- status_icon = self._robot_charging_icon
- elif robot_status == 3 or robot_status == 5 or robot_status == 6:
- if self._robot_warning_icon is None:
- self._robot_warning_icon = (
- Image.open(BytesIO(base64.b64decode(MAP_ROBOT_WARNING_IMAGE)))
- .convert("RGBA")
- .resize(((int(icon_size * 1.3), int(icon_size * 1.3))), resample=Image.Resampling.NEAREST)
- )
- status_icon = self._robot_warning_icon
-
- if status_icon:
- mask = Image.new("L", status_icon.size, 0)
- draw = ImageDraw.Draw(mask)
- draw.ellipse((0, 0, status_icon.size[0], status_icon.size[1]), fill=255)
- new_layer.paste(
- status_icon,
- (
- int(point.x * scale - (status_icon.size[0] / 2)),
- int(point.y * scale - (status_icon.size[1] / 2)),
- ),
- mask,
- )
new_layer.paste(
icon,
@@ -4321,7 +10021,7 @@ def render_vacuum(self, robot_position, robot_status, layer, dimensions, size, m
icon,
)
- if robot_status == 4 or robot_status == 5:
+ if not self._low_memory and robot_status == 3:
if self._robot_sleeping_icon is None:
sleeping_icon = (
Image.open(BytesIO(base64.b64decode(MAP_ROBOT_SLEEPING_IMAGE)))
@@ -4334,10 +10034,12 @@ def render_vacuum(self, robot_position, robot_status, layer, dimensions, size, m
self._robot_sleeping_icon = [
sleeping_icon.resize(
- ((int(icon_size * 0.3), int(icon_size * 0.3))), resample=Image.Resampling.NEAREST
+ ((int(icon_size * 0.3), int(icon_size * 0.3))),
+ resample=Image.Resampling.NEAREST,
),
sleeping_icon.resize(
- ((int(icon_size * 0.35), int(icon_size * 0.35))), resample=Image.Resampling.NEAREST
+ ((int(icon_size * 0.35), int(icon_size * 0.35))),
+ resample=Image.Resampling.NEAREST,
),
]
@@ -4369,36 +10071,88 @@ def render_vacuum(self, robot_position, robot_status, layer, dimensions, size, m
)
return new_layer
- def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
+ def render_segment(
+ self,
+ segment,
+ cleanset,
+ sequence,
+ layer_size,
+ dimensions,
+ size,
+ rotation,
+ scale,
+ active,
+ blocked,
+ ):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
draw = ImageDraw.Draw(new_layer, "RGBA")
if segment.x is not None and segment.y is not None:
+ active = active and not blocked
text = None
+ if segment.type not in self._segment_icons:
+ icon_set = SEGMENT_ICONS_DREAME
+ if self.icon_set == 1:
+ icon_set = SEGMENT_ICONS_DREAME_OLD
+ elif self.icon_set == 2:
+ icon_set = SEGMENT_ICONS_MIJIA
+ elif self.icon_set == 3:
+ icon_set = SEGMENT_ICONS_MATERIAL
+
+ if segment.type in icon_set:
+ self._segment_icons[segment.type] = Image.open(
+ BytesIO(base64.b64decode(icon_set[segment.type]))
+ ).convert("RGBA")
+ if self.color_scheme.invert and not (self.config.name_background and self.icon_set != 2):
+ enhancer = ImageEnhance.Brightness(self._segment_icons[segment.type])
+ self._segment_icons[segment.type] = enhancer.enhance(0.1)
+
icon = self._segment_icons.get(segment.type) if self.config.icon else None
- if segment.type == 0 or icon is None:
+ if segment.type == 0 or self.config.name or icon is None:
text = (
segment.name
- if (self._robot_shape != 1 or icon is not None) or segment.custom_name is not None
- else segment.letter if self.icon_set != 2 else None
+ if (self._robot_type != RobotType.VSLAM or icon is not None)
+ or (segment.custom_name is not None and segment.type == 0)
+ or self.icon_set == 2
+ else segment.letter
)
elif segment.index > 0:
text = str(segment.index)
text_font = None
order_font = None
- if text and self.config.name:
+ render_font = text and (self.config.name or segment.type == 0 or segment.index > 0)
+ if self._font_file is None and (render_font or (segment.order and self.config.order and sequence)):
+ self._font_file = zlib.decompress(base64.b64decode(MAP_FONT), zlib.MAX_WBITS | 32)
+
+ if render_font and self._font_file:
text_font = ImageFont.truetype(
- BytesIO(self.font_file),
+ BytesIO(self._font_file),
int((size * 1.9)) if segment.index or icon is None else int((size * 1.7)),
)
- if segment.order and self.config.order:
- order_font = ImageFont.truetype(BytesIO(self.font_file), int((size * 2.1)))
+ if active and segment.order and self.config.order and sequence:
+ order_font = ImageFont.truetype(BytesIO(self._font_file), int((size * 2.1)))
p = Point(segment.x, segment.y).to_img(dimensions)
x = p.x
y = p.y
+ if blocked:
+ offset = size * 1.5
+ x_offset = 0
+ y_offset = -offset
+ if rotation == 90:
+ y_offset = 0
+ x_offset = offset
+ elif rotation == 180:
+ y_offset = offset
+ elif rotation == 270:
+ y_offset = 0
+ x_offset = -offset
+
+ x = x + x_offset
+ y = y + y_offset
+
if self.config.name or self.config.icon:
if segment.type or text_font or not self.config.name:
icon_size = size * (1.75 if self.icon_set == 1 else 1.3)
@@ -4411,23 +10165,52 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
left, top, tw, th = draw.textbbox((0, 0), text, text_font)
ws = tw / 4
- if segment.index > 0 or icon is None:
+ if segment.index or icon is None:
icon_size = size * 1.35
padding = icon_size / 2
text_offset = (icon_size / 2) + 2
icon_offset = 2
- th = int(size * 2.3)
+ th = int(round(size * 2.3))
else:
icon_size = size * 1.15
padding = icon_size * 0.35
icon_offset = padding - 2
text_offset = icon_size / 2
- th = int(size * 1.9)
+ th = int(round(size * 1.9))
if icon is None:
text_offset = 0
padding = -(icon_size / 4)
+ name_background = self.config.icon or (self.config.name_background and self.config.name)
+
+ stroke_width = dimensions.scale
+ if blocked:
+ stroke_color = self.color_scheme.blocked_segment
+ text_color = (
+ stroke_color[0],
+ stroke_color[1],
+ stroke_color[2],
+ 255,
+ )
+ elif not name_background:
+ if self.color_scheme.dark:
+ text_color = (240, 240, 240, 255)
+ stroke_color = (0, 0, 0, 200)
+ else:
+ text_color = (15, 15, 15, 255)
+ stroke_color = (255, 255, 255, 200)
+ elif self.config.icon or self.config.name:
+ stroke_width = 1
+ if self.config.name_background and self.icon_set != 2 and self.color_scheme.invert:
+ text_color = (240, 240, 240, 255)
+ stroke_color = (240, 240, 240, 200)
+ else:
+ text_color = self.color_scheme.text
+ stroke_color = self.color_scheme.text_stroke
+
+ th = th + int(stroke_width * 2)
+
if rotation == 90 or rotation == 270:
y0 = y0 - ws - padding
y1 = y1 + ws + padding
@@ -4453,7 +10236,12 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
ty = (y - (th / 4)) * scale
x = x + ws + icon_offset
- if self.config.icon:
+ if (
+ name_background
+ # and not self.config.name_background
+ and active
+ and not blocked
+ ):
draw.rounded_rectangle(
[
int(x0 * scale),
@@ -4461,26 +10249,17 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
int(x1 * scale),
int(y1 * scale),
],
- fill=self.color_scheme.icon_background,
+ fill=(
+ self.color_scheme.segment[segment.color_index][1]
+ if name_background and self.config.name_background and self.icon_set != 2
+ else self.color_scheme.icon_background
+ ),
radius=((size * scale)),
)
icon_text = Image.new("RGBA", (tw, th), (255, 255, 255, 0))
draw_text = ImageDraw.Draw(icon_text, "RGBA")
- if self.config.icon:
- stroke_width = 1
- text_color = self.color_scheme.text
- stroke_color = self.color_scheme.text_stroke
- else:
- stroke_width = 4
- if self.color_scheme.dark:
- text_color = (240, 240, 240, 255)
- stroke_color = (0, 0, 0, 210)
- else:
- text_color = (15, 15, 15, 255)
- stroke_color = (255, 255, 255, 210)
-
draw_text.text(
(0, 0),
text,
@@ -4491,24 +10270,48 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
)
icon_text = icon_text.rotate(-rotation, expand=1)
new_layer.paste(icon_text, (int(tx), int(ty)), icon_text)
- elif icon is not None:
+ if self.icon_set == 1:
+ icon_size *= 1.3
+ elif active: # and not self.config.name_background
draw.ellipse(
[x0 * scale, y0 * scale, x1 * scale, y1 * scale],
- fill=self.color_scheme.icon_background,
+ fill=(
+ self.color_scheme.segment[segment.color_index][1]
+ if self.config.name_background and self.icon_set != 2
+ else self.color_scheme.icon_background
+ ),
)
if icon is not None:
s = icon_size * scale
- icon = icon.resize((int(s), int(s))).rotate(-rotation, expand=1)
+ if blocked:
+ icon = DreameVacuumMapRenderer._set_icon_color(
+ icon,
+ s,
+ text_color,
+ )
+ else:
+ icon = icon.resize((int(s), int(s)))
+ icon = icon.rotate(-rotation, expand=1)
new_layer.paste(
- icon, (int(x * scale - (icon.size[0] / 2)), int(y * scale - (icon.size[1] / 2))), icon
+ icon,
+ (
+ int(x * scale - (icon.size[0] / 2)),
+ int(y * scale - (icon.size[1] / 2)),
+ ),
+ icon,
)
- custom = cleanset and (
- self.config.suction_level
- or self.config.water_volume
- or self.config.cleaning_times
- or self.config.cleaning_mode
+ custom = (
+ active
+ and not blocked
+ and cleanset
+ and (
+ self.config.suction_level
+ or self.config.water_volume
+ or self.config.cleaning_times
+ or self.config.cleaning_mode
+ )
)
if order_font or custom:
offset = size * 2.7
@@ -4538,6 +10341,7 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
icon_count = 5
else:
icon_count = 4
+
if not self.config.suction_level or segment.suction_level is None:
icon_count = icon_count - 1
if not self.config.water_volume or segment.water_volume is None:
@@ -4548,6 +10352,13 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
icon_count = icon_count - 1
if cleaning_mode == 0 or cleaning_mode == 1:
icon_count = icon_count - 1
+ if (
+ self.config.mopping_mode
+ and segment.custom_mopping_route is None
+ and segment.cleaning_route is not None
+ and cleaning_mode == 1
+ ):
+ icon_count = icon_count + 1
else:
icon_count = 1
@@ -4556,8 +10367,7 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
radius = size
arrow = int(round(radius * 0.6))
- s = int(round(radius * 0.25))
- margin = s if icon_count > 1 else 0
+ margin = int(round(size * 0.3)) if icon_count > 1 else 0
if custom:
radius = size - 2
@@ -4584,7 +10394,7 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
radius=((icon_h - (arrow * 2)) / 2),
)
- padding = s + arrow
+ padding = int(round((size * 0.3) + (size * 0.6)))
r = icon_h - (padding * 2)
ellipse_x1 = padding + margin
ellipse_x2 = ellipse_x1 + r
@@ -4620,11 +10430,38 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
s = icon_size * 0.85 * scale
ico = DreameVacuumMapRenderer._set_icon_color(
- self._cleaning_mode_icon[segment.cleaning_mode],
+ self._cleaning_mode_icon[segment.cleaning_mode],
+ s,
+ self.color_scheme.segment[segment.color_index][1],
+ )
+
+ icon_draw.ellipse(
+ [ellipse_x1, padding, ellipse_x2, (icon_h - padding)],
+ fill=self.color_scheme.settings_icon_background,
+ )
+ icon.paste(
+ ico,
+ (
+ int(2 + ellipse_x1 + ((ellipse_x2 - ellipse_x1) / 2) - ico.size[0] / 2),
+ int(((icon_h / 2) - ico.size[1] / 2)),
+ ),
+ ico,
+ )
+
+ ellipse_x1 = ellipse_x2 + (margin * 2)
+ ellipse_x2 = ellipse_x1 + r
+
+ if self.config.suction_level and segment.suction_level is not None and cleaning_mode != 1:
+ if self.icon_set == 2:
+ s = icon_size * 1.2 * scale
+ else:
+ s = icon_size * 0.85 * scale
+
+ ico = DreameVacuumMapRenderer._set_icon_color(
+ self._suction_level_icon[segment.suction_level],
s,
self.color_scheme.segment[segment.color_index][1],
)
-
icon_draw.ellipse(
[ellipse_x1, padding, ellipse_x2, (icon_h - padding)],
fill=self.color_scheme.settings_icon_background,
@@ -4641,17 +10478,30 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
ellipse_x1 = ellipse_x2 + (margin * 2)
ellipse_x2 = ellipse_x1 + r
- if self.config.suction_level and segment.suction_level is not None and cleaning_mode != 1:
- if self.icon_set == 2:
- s = icon_size * 1.2 * scale
+ if self.config.water_volume and segment.water_volume is not None and cleaning_mode != 0:
+ water = segment.water_volume - 1
+ if self.config.mopping_mode and segment.custom_mopping_route is not None:
+ s = icon_size * 1.05 * scale
+ ico = self._custom_mopping_route_icon[(water * 3) + (segment.cleaning_route - 1)]
+ elif self.config.mopping_mode and segment.cleaning_route is not None:
+ if self.icon_set == 3:
+ s = icon_size * 0.95 * scale
+ else:
+ s = icon_size * scale
+ ico = self._mop_pad_humidity_icon[water]
else:
- s = icon_size * 0.85 * scale
+ if self.icon_set == 3:
+ s = icon_size * 0.95 * scale
+ elif self.icon_set == 2:
+ s = icon_size * 1.2 * scale
+ ico = self._water_volume_icon[water]
ico = DreameVacuumMapRenderer._set_icon_color(
- self._suction_level_icon[segment.suction_level],
+ ico,
s,
self.color_scheme.segment[segment.color_index][1],
)
+
icon_draw.ellipse(
[ellipse_x1, padding, ellipse_x2, (icon_h - padding)],
fill=self.color_scheme.settings_icon_background,
@@ -4668,20 +10518,21 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
ellipse_x1 = ellipse_x2 + (margin * 2)
ellipse_x2 = ellipse_x1 + r
- if self.config.water_volume and segment.water_volume is not None and cleaning_mode != 0:
+ if (
+ self.config.mopping_mode
+ and segment.custom_mopping_route is None
+ and segment.cleaning_route is not None
+ and cleaning_mode == 1
+ ):
if self.icon_set == 3:
- s = icon_size * 0.95 * scale
- elif self.icon_set == 2:
- s = icon_size * 1.2 * scale
- else:
s = icon_size * 0.85 * scale
-
+ else:
+ s = icon_size * 0.7 * scale
ico = DreameVacuumMapRenderer._set_icon_color(
- self._water_volume_icon[segment.water_volume - 1],
+ self._cleaning_route_icon[segment.cleaning_route - 1],
s,
self.color_scheme.segment[segment.color_index][1],
)
-
icon_draw.ellipse(
[ellipse_x1, padding, ellipse_x2, (icon_h - padding)],
fill=self.color_scheme.settings_icon_background,
@@ -4734,57 +10585,721 @@ def render_segment(self, segment, cleanset, layer, dimensions, size, rotation, s
)
return new_layer
- def render_obstacles(self, obstacles, layer, dimensions, size, rotation, scale):
- new_layer = Image.new("RGBA", layer.size, (255, 255, 255, 0))
- icon_size = size * scale * 0.85
- draw = ImageDraw.Draw(new_layer, "RGBA")
+ def render_obstacle(self, obstacle, layer_size, dimensions, size, rotation, scale):
+ if obstacle.ignore_status == 1:
+ if (
+ obstacle.type.value not in self._obstacle_hidden_icons
+ and obstacle.type.value in OBSTACLE_TYPE_TO_HIDDEN_ICON
+ ):
+ self._obstacle_hidden_icons[obstacle.type.value] = Image.open(
+ BytesIO(base64.b64decode(OBSTACLE_TYPE_TO_HIDDEN_ICON[obstacle.type.value]))
+ ).convert("RGBA")
+ icon = self._obstacle_hidden_icons.get(obstacle.type.value)
+ else:
+ if obstacle.type.value not in self._obstacle_icons and obstacle.type.value in OBSTACLE_TYPE_TO_ICON:
+ self._obstacle_icons[obstacle.type.value] = Image.open(
+ BytesIO(base64.b64decode(OBSTACLE_TYPE_TO_ICON[obstacle.type.value]))
+ ).convert("RGBA")
+ icon = self._obstacle_icons.get(obstacle.type.value)
+
+ if icon:
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ icon_size = size * scale * (1 if obstacle.ignore_status == 1 else 0.85)
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+
+ if obstacle.ignore_status != 2 and self._obstacle_background is None:
+ self._obstacle_background = Image.open(BytesIO(base64.b64decode(MAP_ICON_OBSTACLE_BG_DREAME))).convert(
+ "RGBA"
+ )
+ s = int(size * scale * 2)
+ self._obstacle_background.thumbnail((s, s), Image.Resampling.LANCZOS)
+ self._obstacle_background = self._obstacle_background.rotate(-rotation, expand=1)
+
+ if obstacle.ignore_status == 2 and self._obstacle_hidden_background is None:
+ self._obstacle_hidden_background = Image.open(
+ BytesIO(base64.b64decode(MAP_ICON_OBSTACLE_HIDDEN_BG_DREAME))
+ ).convert("RGBA")
+ s = int((size * 0.75) * scale * 2)
+ self._obstacle_hidden_background.thumbnail((s, s), Image.Resampling.LANCZOS)
+ self._obstacle_hidden_background = self._obstacle_hidden_background.rotate(-rotation, expand=1)
+
+ background_image = (
+ self._obstacle_hidden_background if obstacle.ignore_status == 2 else self._obstacle_background
+ )
+ bg_size = int((min(background_image.size[1], background_image.size[0]) / scale / 4) * 1.25)
+ offset = int(-(size * (0.15 if obstacle.ignore_status == 2 else 0.2)) * scale)
+
+ p = obstacle.to_img(dimensions)
+ x = p.x
+ y = p.y
+ # if self.icon_set != 2:
+ pos_offset = (
+ max(background_image.size[1], background_image.size[0])
+ * (1.35 if obstacle.ignore_status == 2 else 0.95)
+ / scale
+ / 2
+ )
+ # else:
+ # pos_offset = 0
+
+ if rotation == 90:
+ y_offset = 0
+ x_offset = offset
+ x = x + pos_offset
+ elif rotation == 180:
+ y_offset = offset
+ x_offset = 0
+ y = y + pos_offset
+ elif rotation == 270:
+ y_offset = 0
+ x_offset = -offset
+ x = x - pos_offset
+ else:
+ x_offset = 0
+ y_offset = -offset
+ y = y - pos_offset
+
+ new_layer.paste(
+ background_image,
+ (
+ int(round(x * scale - (background_image.size[0] / 2) + x_offset)),
+ int(round(y * scale - (background_image.size[1] / 2) + y_offset)),
+ ),
+ )
+
+ if obstacle.ignore_status == 2:
+ icon = DreameVacuumMapRenderer._set_icon_color(
+ icon,
+ icon_size,
+ (34, 109, 242, 240),
+ ).rotate(-rotation, expand=1)
+ else:
+ draw.ellipse(
+ [
+ (x - bg_size) * scale,
+ (y - bg_size) * scale,
+ (x + bg_size) * scale,
+ (y + bg_size) * scale,
+ ],
+ fill=(
+ (230, 143, 9, 255)
+ if obstacle.type == ObstacleType.BLOCKED_ROOM
+ else (
+ (212, 212, 212, 255)
+ if obstacle.ignore_status == 1
+ else (
+ (128, 128, 128, 255)
+ if self.icon_set != 2
+ and (
+ obstacle.type == ObstacleType.LIQUID_STAIN
+ or obstacle.type == ObstacleType.DRIED_STAIN
+ or obstacle.type == ObstacleType.UNCLEANABLE_STAIN
+ or obstacle.type == ObstacleType.DETECTED_STAIN
+ )
+ else (
+ (255, 140, 188, 255)
+ if self.icon_set != 2
+ and (
+ obstacle.type == ObstacleType.PET
+ or obstacle.type == ObstacleType.FOOD_BOWL
+ or obstacle.type == ObstacleType.PET_BED
+ )
+ else (
+ (97, 173, 31, 255)
+ if self.icon_set != 2
+ and (
+ obstacle.type == ObstacleType.CLEANED_LARGE_PARTICLES
+ or obstacle.type == ObstacleType.CLEANED_DRIED_STAIN
+ or obstacle.type == ObstacleType.SKIPPED_UNCLEANABLE_STAIN
+ or obstacle.type == ObstacleType.CLEANED_STAIN
+ )
+ else self.color_scheme.obstacle_bg
+ )
+ )
+ )
+ )
+ ),
+ )
+ icon = icon.resize((int(icon_size), int(icon_size))).rotate(-rotation, expand=1)
- if self._obstacle_background is None:
- self._obstacle_background = (
- Image.open(BytesIO(base64.b64decode(MAP_ICON_OBSTACLE_BG_DREAME))).convert("RGBA").rotate(-rotation)
+ new_layer.paste(
+ icon,
+ (
+ int(round(x * scale - (icon_size / 2))),
+ int(round(y * scale - (icon_size / 2))),
+ ),
+ icon,
)
- self._obstacle_background.thumbnail((size * scale * scale, size * scale * scale), Image.Resampling.LANCZOS)
- bg_size = int(round((size * scale * 0.5) / 2))
- offset = -8 * scale
+ return new_layer
+
+ def render_cruise_point(self, index, cruise_point, layer_size, dimensions, size, rotation, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ if cruise_point.type == 1 and self._cruise_path_point_background is None:
+ self._cruise_path_point_background = Image.open(
+ BytesIO(base64.b64decode(MAP_ICON_CRUISE_POINT_BG_DREAME))
+ ).convert("RGBA")
+ s = int(size * scale * 3)
+ self._cruise_path_point_background.thumbnail((s, s), Image.Resampling.LANCZOS)
+ self._cruise_path_point_background = self._cruise_path_point_background.rotate(-rotation, expand=1)
+
+ if cruise_point.type != 1 and self._cruise_point_background is None:
+ self._cruise_point_background = Image.open(
+ BytesIO(base64.b64decode(MAP_ICON_CRUISE_POINT_DREAME))
+ ).convert("RGBA")
+ s = int(round(size * scale * 2))
+ self._cruise_point_background.thumbnail((s, s), Image.Resampling.LANCZOS)
+ self._cruise_point_background = self._cruise_point_background.rotate(-rotation, expand=1)
+
+ background_image = (
+ self._cruise_point_background if cruise_point.type != 1 else self._cruise_path_point_background
+ )
+ bg_size = int(min(background_image.size[1], background_image.size[0]) / scale / 4)
+ offset = int(-bg_size * 1.25)
+
+ p = cruise_point.to_img(dimensions)
+ x = p.x
+ y = p.y
+ pos_offset = (
+ max(background_image.size[1], background_image.size[0])
+ * (1.75 if cruise_point.type != 1 else 1.20)
+ / scale
+ / 3
+ )
+
if rotation == 90:
y_offset = 0
x_offset = offset
+ x = x + pos_offset
elif rotation == 180:
y_offset = offset
x_offset = 0
+ y = y + pos_offset
elif rotation == 270:
y_offset = 0
x_offset = -offset
+ x = x - pos_offset
else:
x_offset = 0
y_offset = -offset
+ y = y - pos_offset
+
+ new_layer.paste(
+ background_image,
+ (
+ int(round(x * scale - (background_image.size[0] / 2) + x_offset)),
+ int(round(y * scale - (background_image.size[1] / 2) + y_offset)),
+ ),
+ )
+
+ if cruise_point.type == 1:
+ draw.ellipse(
+ [
+ (x - bg_size) * scale,
+ (y - bg_size) * scale,
+ (x + bg_size) * scale,
+ (y + bg_size) * scale,
+ ],
+ fill=(212, 212, 212, 255) if cruise_point.completed else (34, 109, 242, 255),
+ )
+
+ if cruise_point.type == 1:
+ text_box = Image.new("RGBA", (bg_size * 2 * scale, bg_size * 2 * scale), (255, 255, 255, 0))
+ text_box_draw = ImageDraw.Draw(text_box, "RGBA")
+
+ if self._font_file is None:
+ self._font_file = zlib.decompress(base64.b64decode(MAP_FONT), zlib.MAX_WBITS | 32)
+
+ font = ImageFont.truetype(BytesIO(self._font_file), int((bg_size * 1.5 * scale)))
+
+ text = str(index)
+ left, top, tw, th = text_box_draw.textbbox((0, 0), text, font)
+ text_box_draw.text(
+ (
+ (text_box.size[1] - tw) / 2,
+ (text_box.size[1] - th - int(round(size * 0.4))) / 2,
+ ),
+ text,
+ font=font,
+ fill=(255, 255, 255, 255),
+ stroke_width=1,
+ stroke_fill=(255, 255, 255, 100),
+ )
+ text_box = text_box.rotate(-rotation, expand=1)
+ new_layer.paste(
+ text_box,
+ (int(round((x - bg_size) * scale)), int(round((y - bg_size) * scale))),
+ text_box,
+ )
+
+ return new_layer
+
+ def render_furniture(
+ self, furniture, furniture_version, hidden_segments, layer_size, dimensions, size, rotation, scale
+ ):
+ draw_image = furniture.width and furniture.height
+ furniture_type = furniture.type.value
+ if hidden_segments and furniture.segment_id and furniture.segment_id in hidden_segments:
+ return None
+
+ if draw_image:
+ if furniture_version == 6:
+ furniture_images = FURNITURE_V3_TYPE_TO_IMAGE
+ elif furniture_version == 5:
+ furniture_images = FURNITURE_V2_TYPE_MIJIA_TO_IMAGE
+ elif furniture_version < 3:
+ furniture_images = FURNITURE_TYPE_TO_IMAGE
+ else:
+ furniture_images = FURNITURE_V2_TYPE_TO_IMAGE
- for obstacle in obstacles:
- icon = self._obstacle_icons.get(obstacle.obstacle_type.value)
- if icon:
- p = obstacle.to_img(dimensions)
+ if furniture_type not in self._furniture_images and furniture_type in furniture_images:
+ image = Image.open(BytesIO(base64.b64decode(furniture_images[furniture_type]))).convert("RGBA")
+ if furniture_version == 6:
+ self._furniture_images[furniture_type] = image
+ else:
+ img = np.array(image)
+ if self.icon_set != 2:
+ img[..., 3] = 235 * (img[..., 3] > 0)
+ self._furniture_images[furniture_type] = Image.fromarray(img)
+ icon = self._furniture_images.get(furniture_type)
+ else:
+ furniture_icons = FURNITURE_V2_TYPE_TO_ICON if furniture_version >= 3 else FURNITURE_TYPE_TO_ICON
+ if furniture_type not in self._furniture_icons and furniture_type in furniture_icons:
+ self._furniture_icons[furniture_type] = Image.open(
+ BytesIO(base64.b64decode(furniture_icons[furniture_type]))
+ ).convert("RGBA")
+ icon = self._furniture_icons.get(furniture_type)
+ if icon:
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ if draw_image:
+ w = (furniture.width / dimensions.grid_size) * dimensions.scale
+ h = (furniture.height / dimensions.grid_size) * dimensions.scale
+ p = Point(
+ furniture.x,
+ furniture.y,
+ ).to_img(dimensions)
x = p.x
y = p.y
+ img = icon.rotate(furniture.angle, expand=1)
+ if furniture_version >= 3:
+ img = img.resize(
+ (int(w * scale), int(h * scale)),
+ resample=Image.Resampling.LANCZOS,
+ )
+ else:
+ img.thumbnail((int(w * scale), int(h * scale)), Image.Resampling.LANCZOS)
+ img = img.rotate(-(furniture.angle * 2), expand=1)
+
new_layer.paste(
- self._obstacle_background,
+ img,
(
- int(round(x * scale - (self._obstacle_background.size[0] / 2) + x_offset)),
- int(round(y * scale - (self._obstacle_background.size[1] / 2) + y_offset)),
+ int((x * scale) - ((img.size[0]) / 2)),
+ int((y * scale) - ((img.size[1]) / 2)),
),
+ img,
+ )
+ else:
+ icon_size = size * scale * 1.15
+ if self._furniture_background is None:
+ self._furniture_background = Image.open(
+ BytesIO(base64.b64decode(MAP_ICON_OBSTACLE_BG_DREAME))
+ ).convert("RGBA")
+ s = int(size * scale * 2)
+ self._furniture_background.thumbnail((s, s), Image.Resampling.LANCZOS)
+ self._furniture_background = self._furniture_background.rotate(-rotation, expand=1)
+
+ offset = int(-(size * 0.2) * scale)
+
+ p = furniture.to_img(dimensions)
+ x = p.x
+ y = p.y
+ pos_offset = (
+ (self._furniture_background.size[1] * (1.15 if rotation == 90 or rotation == 270 else 0.9))
+ / scale
+ / 2
)
- draw.ellipse(
- [(x - bg_size) * scale, (y - bg_size) * scale, (x + bg_size) * scale, (y + bg_size) * scale],
- fill=self.color_scheme.segment[0][0],
+ if rotation == 90:
+ y_offset = 0
+ x_offset = offset
+ x = x + pos_offset
+ elif rotation == 180:
+ y_offset = offset
+ x_offset = 0
+ y = y + pos_offset
+ elif rotation == 270:
+ y_offset = 0
+ x_offset = -offset
+ x = x - pos_offset
+ else:
+ x_offset = 0
+ y_offset = -offset
+ y = y - pos_offset
+
+ new_layer.paste(
+ self._furniture_background,
+ (
+ int(round(x * scale - (self._furniture_background.size[0] / 2) + x_offset)),
+ int(round(y * scale - (self._furniture_background.size[1] / 2) + y_offset)),
+ ),
)
- icon = icon.resize((int(icon_size), int(icon_size))).rotate(-rotation)
+ icon = icon.resize((int(icon_size), int(icon_size))).rotate(-rotation, expand=1)
+
new_layer.paste(
- icon, (int(round(x * scale - (icon_size / 2))), int(round(y * scale - (icon_size / 2)))), icon
+ icon,
+ (
+ int(round(x * scale - (icon_size / 2))),
+ int(round(y * scale - (icon_size / 2))),
+ ),
+ icon,
+ )
+
+ return new_layer
+
+ def render_router(
+ self,
+ router_position,
+ layer_size,
+ dimensions,
+ size,
+ rotation,
+ scale,
+ ):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ icon_size = int(size * scale)
+ if self._wifi_icon is None:
+ self._wifi_icon = (
+ Image.open(BytesIO(base64.b64decode(MAP_WIFI_IMAGE_DREAME)))
+ .convert("RGBA")
+ .resize((icon_size, icon_size), resample=Image.Resampling.NEAREST)
+ )
+
+ point = router_position.to_img(dimensions)
+ bg_size = (size * 1.2) / 2
+ draw.ellipse(
+ [
+ int((point.x - bg_size) * scale),
+ int((point.y - bg_size) * scale),
+ int((point.x + bg_size) * scale),
+ int((point.y + bg_size) * scale),
+ ],
+ fill=(34, 98, 211, 255) if self.color_scheme.dark else (34, 109, 242, 255),
+ )
+ wifi_icon = self._wifi_icon.rotate(-rotation, expand=1)
+ new_layer.paste(
+ wifi_icon,
+ (
+ int((point.x * scale) - (wifi_icon.size[0] / 2)),
+ int((point.y * scale) - (wifi_icon.size[1] / 2)),
+ ),
+ wifi_icon,
+ )
+
+ return new_layer
+
+ def render_floor_material(self, image, floor_material, hidden_segments, pixel_type, color, dimensions, scale):
+ tile_w = 12
+ floor_w = 4
+ floor_h = 16
+
+ height = dimensions.height * scale
+ tiles = {}
+ for k, v in floor_material.items():
+ if v > 0 and v < 4:
+ if v not in tiles:
+ tiles[v] = [k]
+ else:
+ tiles[v].append(k)
+
+ if tiles:
+ color_map = {}
+ for floor_type, tile in tiles.items():
+ if tile:
+ if floor_type == 1:
+ w = math.floor(2 * dimensions.width / floor_h)
+ h = math.floor(dimensions.height / floor_w)
+ y_start = 1
+ x_start = 0
+ x_multiplier = floor_h / 2
+ y_multiplier = floor_w
+ elif floor_type == 2:
+ w = math.floor(dimensions.width / floor_w)
+ h = math.floor(2 * dimensions.height / floor_h)
+ y_start = 0
+ x_start = 1
+ x_multiplier = floor_w
+ y_multiplier = floor_h / 2
+ else:
+ w = math.floor(dimensions.width / tile_w)
+ h = math.floor(dimensions.height / tile_w)
+ y_start = 0
+ x_start = 0
+ x_multiplier = tile_w
+ y_multiplier = tile_w
+
+ for x in range(1, w + 1):
+ for y in range(y_start, dimensions.height):
+ xx = int(x * x_multiplier)
+ if xx < dimensions.width and (
+ floor_type != 1
+ or (
+ (math.floor((y - 1) / floor_w) % 2 == 0 and x % 2 == 0)
+ or (math.floor((y - 1) / floor_w) % 2 == 1 and x % 2 == 1)
+ )
+ ):
+ val = int(pixel_type[xx, y])
+ if val > 100 and val < 200:
+ val = val - 100
+ if not hidden_segments or val not in hidden_segments:
+ continue
+
+ if val > 0 and val < 63 and val in tile:
+ x_index = (xx * scale) + 1
+ y_index = (height - 1) - (y * scale) - 1
+
+ if val not in color_map:
+ cc = DreameVacuumMapRenderer._alpha_composite(color, image[y_index, x_index])
+ color_map[val] = cc
+ else:
+ cc = color_map[val]
+ image[y_index, x_index] = cc
+ y_index = y_index + 1
+ image[y_index, x_index] = cc
+
+ for x in range(x_start, dimensions.width):
+ for y in range(1, h + 1):
+ yy = int(y * y_multiplier)
+ if yy < dimensions.height and (
+ floor_type != 2
+ or (
+ (math.floor((x - 1) / floor_w) % 2 == 0 and y % 2 == 0)
+ or (math.floor((x - 1) / floor_w) % 2 == 1 and y % 2 == 1)
+ )
+ ):
+ val = int(pixel_type[x, yy])
+ if val > 100 and val < 200:
+ val = val - 100
+ if not hidden_segments or val not in hidden_segments:
+ continue
+
+ if val > 0 and val < 63 and val in tile:
+ x_index = x * scale
+ y_index = (height - 1) - ((yy * scale) + 1)
+ if val not in color_map:
+ cc = DreameVacuumMapRenderer._alpha_composite(color, image[y_index, x_index])
+ color_map[val] = cc
+ else:
+ cc = color_map[val]
+ image[y_index, x_index] = cc
+ x_index = x_index + 1
+ image[y_index, x_index] = cc
+ return image
+
+ def render_carpets(
+ self,
+ image,
+ pixel_type,
+ carpets,
+ deleted_carpets,
+ detected_carpets,
+ carpet_pixels,
+ segments,
+ hidden_segments,
+ color,
+ detected_color,
+ dimensions,
+ scale,
+ ):
+ carpet_data = {}
+ left = dimensions.left
+ top = dimensions.top
+ if left % dimensions.grid_size != 0 or top % dimensions.grid_size != 0:
+ left = left + (dimensions.offset)
+ top = top + (dimensions.offset)
+
+ if detected_carpets:
+ optimimized_carpet_pixels = None
+ for carpet in detected_carpets:
+ if not carpet.hidden:
+ x0, y0, x1, y1 = DreameVacuumMapRenderer._get_carpet_coords(carpet, dimensions)
+ for x in range(max(0, x0), min(x1, dimensions.width - 1)):
+ for y in range(max(y0, 0), min(y1, dimensions.height - 1)):
+ val = int(pixel_type[x, y])
+ if val > 100 and val < 200:
+ val = val - 100
+ if not hidden_segments or val not in hidden_segments:
+ continue
+ if not DreameVacuumMapRenderer._check_carpet(x, y, carpet, dimensions, val):
+ continue
+
+ if carpet.polygon and len(carpet.polygon) > 100 and carpet_pixels:
+ if optimimized_carpet_pixels is None:
+ optimimized_carpet_pixels = DreameVacuumMapRenderer._optimize_carpet_pixels(
+ carpet_pixels, dimensions, pixel_type
+ )
+ if (x, y) not in optimimized_carpet_pixels:
+ continue
+ carpet_data[(x, y)] = 1
+ elif carpet_pixels:
+ carpet_data = DreameVacuumMapRenderer._optimize_carpet_pixels(carpet_pixels, dimensions, pixel_type)
+
+ if deleted_carpets:
+ for carpet in deleted_carpets:
+ x0, y0, x1, y1 = DreameVacuumMapRenderer._get_carpet_coords(carpet, dimensions)
+ for x in range(x0, x1):
+ for y in range(y0, y1):
+ if (x, y) in carpet_data:
+ del carpet_data[(x, y)]
+
+ if segments:
+ for k in segments.keys():
+ segment = segments[k]
+ if segment.floor_material and segment.floor_material > 4 and segment.floor_material < 8:
+ x0 = int((segment.x0 - dimensions.left) / dimensions.grid_size) - 1
+ y0 = int((segment.y0 - dimensions.top) / dimensions.grid_size) - 1
+ x1 = int((segment.x1 - dimensions.left) / dimensions.grid_size) + 1
+ y1 = int((segment.y1 - dimensions.top) / dimensions.grid_size) + 1
+ for x in range(x0 - 1, x1 + 1):
+ for y in range(y0 - 1, y1 + 1):
+ if x < 0 or x >= dimensions.width or y < 0 or y >= dimensions.height:
+ continue
+ val = int(pixel_type[x, y])
+ if val > 100 and val < 200:
+ val = val - 100
+ if not hidden_segments or val not in hidden_segments:
+ continue
+ if val == int(k):
+ carpet_data[(x, y)] = 1
+
+ if carpets:
+ for carpet in carpets:
+ if not carpet.hidden:
+ x0, y0, x1, y1 = DreameVacuumMapRenderer._get_carpet_coords(carpet, dimensions)
+ for x in range(x0, x1):
+ for y in range(y0, y1):
+ if DreameVacuumMapRenderer._check_carpet(x, y, carpet, dimensions):
+ carpet_data[(x, y)] = 2
+
+ color_map = {}
+ for coord, px_type in carpet_data.items():
+ if px_type != 0:
+ x_index = coord[0] * scale
+ y_index = (dimensions.height - coord[1] - 1) * scale
+ render_color = detected_color if px_type == 1 else color
+ for i in range(2):
+ if (
+ y_index >= 0
+ and y_index < dimensions.height * scale
+ and x_index >= 0
+ and x_index < dimensions.width * scale
+ ):
+ val = f"{image[y_index, x_index]}{px_type}"
+ if val not in color_map:
+ cc = DreameVacuumMapRenderer._alpha_composite(render_color, image[y_index, x_index])
+ color_map[val] = cc
+ else:
+ cc = color_map[val]
+ image[y_index, x_index] = cc
+ x_index = x_index + 1
+ y_index = y_index + 1
+
+ return image
+
+ def render_blocked_segments(
+ self,
+ blocked_segments,
+ segments,
+ layer_size,
+ segment_mask,
+ dimensions,
+ rotation,
+ cleaning_map,
+ ):
+ mask_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ mask_layer.paste(segment_mask, (0, 0))
+
+ if self._map_problem_icon is None:
+ self._map_problem_icon = Image.open(BytesIO(base64.b64decode(MAP_ICON_PROBLEM))).convert("RGBA")
+
+ if rotation == 0 or rotation == 180 or self._square:
+ width = (dimensions.width) + (
+ (dimensions.padding[0] + dimensions.padding[2] - dimensions.crop[0] - dimensions.crop[2])
+ / dimensions.scale
+ )
+ icon_size = width * (0.06 if self._square else 0.07) * dimensions.scale
+ else:
+ height = (dimensions.height) + (
+ (dimensions.padding[1] + dimensions.padding[3] - dimensions.crop[1] - dimensions.crop[3])
+ / dimensions.scale
+ )
+ icon_size = height * 0.07 * dimensions.scale
+
+ if cleaning_map:
+ icon_size = int(icon_size * 0.7)
+
+ problem_icon = self._map_problem_icon.resize((int(icon_size), int(icon_size))).rotate(-rotation, expand=1)
+
+ mask_layer.paste(segment_mask, (0, 0))
+ for k in blocked_segments.keys():
+ if k in segments:
+ segment = segments[k]
+ p = Point(segment.x, segment.y).to_img(dimensions)
+ mask_layer.paste(
+ problem_icon,
+ (
+ int(p.x - (problem_icon.size[0] / 2)),
+ int(p.y - (problem_icon.size[1] / 2)),
+ ),
+ mask=problem_icon,
)
+ return mask_layer
+
+ def render_low_lying_areas(self, areas, layer_size, dimensions, width, scale):
+ new_layer = Image.new("RGBA", layer_size, (255, 255, 255, 0))
+ draw = ImageDraw.Draw(new_layer, "RGBA")
+ for area in areas:
+ if area.hidden:
+ continue
+ coords = []
+ for i in range(0, len(area.polygon), 2):
+ coords.extend(
+ [
+ (
+ ((area.polygon[i] - dimensions.left) / dimensions.grid_size) * dimensions.scale
+ + dimensions.padding[0]
+ - dimensions.crop[0]
+ )
+ * scale,
+ (
+ (
+ (
+ ((dimensions.height) * dimensions.grid_size - 1)
+ - (area.polygon[i + 1] - dimensions.top)
+ )
+ / dimensions.grid_size
+ )
+ * dimensions.scale
+ + dimensions.padding[1]
+ - dimensions.crop[1]
+ )
+ * scale,
+ ]
+ )
+ draw.polygon(
+ coords,
+ self.color_scheme.low_lying_area,
+ (
+ self.color_scheme.auto_low_lying_area_outline
+ if area.type == 0
+ else self.color_scheme.manual_low_lying_area_outline
+ ),
+ width=(width * scale),
+ )
return new_layer
@property
@@ -4793,12 +11308,23 @@ def calibration_points(self) -> dict[str, int]:
@property
def default_map_image(self) -> bytes:
+ if self._default_map_image is None:
+ default_map_image = Image.open(BytesIO(base64.b64decode(DEFAULT_MAP_IMAGE))).convert("RGBA")
+ self._default_map_image = ImageOps.expand(
+ default_map_image.resize(
+ (
+ int(default_map_image.size[0] * 0.8),
+ int(default_map_image.size[1] * 0.8),
+ )
+ ),
+ border=(50, 75, 50, 75),
+ )
return self._to_buffer(self._default_map_image)
@property
def disconnected_map_image(self) -> bytes:
if self._image:
- return self._to_buffer(self._image.filter(ImageFilter.GaussianBlur(13)))
+ return self._to_buffer(self._image.filter(ImageFilter.GaussianBlur(7 if self._low_resolution else 12)))
return self.default_map_image
@property
@@ -5517,7 +12043,11 @@ def _link_adjacent_areas(self, original_data, data, width, height, stroke):
if isCross:
horizontalLines.append(
CLine(
- x=[startX, lastX], y=j, ishorizontal=True, direction=direction, length=(lastX - startX)
+ x=[startX, lastX],
+ y=j,
+ ishorizontal=True,
+ direction=direction,
+ length=(lastX - startX),
)
)
startX = lastX
@@ -5543,7 +12073,7 @@ def _link_adjacent_areas(self, original_data, data, width, height, stroke):
):
if abs(line.x - nLine.x) <= 10:
_ys = self._check_intersect(line.y, nLine.y)
- if _ys != None:
+ if _ys is not None:
xs = [line.x + 1, nLine.x - 1]
if line.x > nLine.x:
xs = [nLine.x + 1, line.x - 1]
@@ -5555,7 +12085,7 @@ def _link_adjacent_areas(self, original_data, data, width, height, stroke):
):
if abs(line.y - nLine.y) <= 10:
_xs = self._check_intersect(line.x, nLine.x)
- if _xs != None:
+ if _xs is not None:
ys = [line.y + 1, nLine.y - 1]
if line.y > nLine.y:
ys = [nLine.y + 1, line.y - 1]
@@ -5730,7 +12260,12 @@ def _find_outline(self, data, width, height, stroke, first):
if isCross:
verticalLines.append(
- CLine(x=i, y=[startY, lastY], ishorizontal=False, length=(lastY - startY))
+ CLine(
+ x=i,
+ y=[startY, lastY],
+ ishorizontal=False,
+ length=(lastY - startY),
+ )
)
startY = lastY
continue
@@ -5768,7 +12303,12 @@ def _find_outline(self, data, width, height, stroke, first):
if isCross:
horizontalLines.append(
- CLine(x=[startX, lastX], y=j, ishorizontal=True, length=(lastX - startX))
+ CLine(
+ x=[startX, lastX],
+ y=j,
+ ishorizontal=True,
+ length=(lastX - startX),
+ )
)
startX = lastX
continue
@@ -5978,7 +12518,7 @@ def _calculate_charger_position(self, data, width, height, stroke, charger_posit
if lx >= cX and cY >= minY and cY <= maxY:
if lastX == None or lx < lastX:
lastX = lx
- if lastX != None:
+ if lastX is not None:
if lastX - cX <= 11:
charger_position.a = 180
charger_position.x = lastX + 0.5
@@ -5993,7 +12533,7 @@ def _calculate_charger_position(self, data, width, height, stroke, charger_posit
if lx <= cX and cY >= minY and cY <= maxY:
if lastX == None or lx > lastX:
lastX = lx
- if lastX != None:
+ if lastX is not None:
if cX - lastX <= 11:
charger_position.a = 360
charger_position.x = lastX + 0.5
@@ -6007,7 +12547,7 @@ def _calculate_charger_position(self, data, width, height, stroke, charger_posit
if ly >= cY and cX >= minX and cX <= maxX:
if lastY == None or ly < lastY:
lastY = ly
- if lastY != None:
+ if lastY is not None:
if lastY - cY <= 11:
charger_position.a = 270
charger_position.y = lastY + 0.5
@@ -6021,7 +12561,7 @@ def _calculate_charger_position(self, data, width, height, stroke, charger_posit
if ly <= cY and cX >= minX and cX <= maxX:
if lastY == None or ly > lastY:
lastY = ly
- if lastY != None:
+ if lastY is not None:
if cY - lastY <= 11:
charger_position.a = 90
charger_position.y = lastY + 0.5
@@ -6127,98 +12667,43 @@ def _merge_saved_map_data(self, map_data, saved_map_data, original_data=None):
map_data.optimized_dimensions = MapImageDimensions(top, left, height, width, map_data.dimensions.grid_size)
def optimize(self, map_data, saved_map_data=None, js_optimizer=True):
- if map_data.saved_map:
- return map_data
+ if map_data.need_optimization:
+ if map_data.saved_map:
+ map_data.need_optimization = False
+ return map_data
- try:
- now = time.time()
-
- if js_optimizer:
- if self._js_optimizer == None:
- self._js_optimizer = MiniRacer()
- self._js_optimizer.eval(base64.b64decode(MAP_OPTIMIZER_JS).decode("utf-8"))
-
- data = map_data.pixel_type.tolist()
- data_size = [
- map_data.dimensions.left,
- map_data.dimensions.top,
- map_data.dimensions.width,
- map_data.dimensions.height,
- map_data.dimensions.grid_size,
- ]
- saved_data = saved_map_data.pixel_type.tolist() if saved_map_data else None
- saved_data_size = (
- [
- saved_map_data.dimensions.left,
- saved_map_data.dimensions.top,
- saved_map_data.dimensions.width,
- saved_map_data.dimensions.height,
- saved_map_data.dimensions.grid_size,
- ]
- if saved_map_data
- else None
- )
- charger_position = None
- if map_data.charger_position:
- left = map_data.dimensions.left
- top = map_data.dimensions.top
+ if map_data.wifi_map:
+ return DreameVacuumMapDecoder.optimize_wifi_map(map_data)
- if saved_map_data:
- if saved_map_data.dimensions.left < left:
- left = saved_map_data.dimensions.left
+ try:
+ now = time.time()
- if saved_map_data.dimensions.top < top:
- top = saved_map_data.dimensions.top
+ if js_optimizer:
+ if self._js_optimizer == None:
+ self._js_optimizer = MiniRacer()
+ self._js_optimizer.eval(base64.b64decode(MAP_OPTIMIZER_JS).decode("utf-8"))
- charger_position = [
- (map_data.charger_position.x - left) / map_data.dimensions.grid_size,
- (map_data.charger_position.y - top) / map_data.dimensions.grid_size,
- map_data.charger_position.a,
+ data = map_data.pixel_type.tolist()
+ data_size = [
+ map_data.dimensions.left,
+ map_data.dimensions.top,
+ map_data.dimensions.width,
+ map_data.dimensions.height,
+ map_data.dimensions.grid_size,
]
-
- result = self._js_optimizer.call(
- "optimize", data, data_size, saved_data, saved_data_size, charger_position
- )
- if result and result[0]:
- map_data.optimized_pixel_type = np.array(result[0], dtype=np.uint8)
-
- dimensions = result[1]
- map_data.optimized_dimensions = MapImageDimensions(
- dimensions[1], dimensions[0], dimensions[3], dimensions[2], map_data.dimensions.grid_size
+ saved_data = saved_map_data.pixel_type.tolist() if saved_map_data else None
+ saved_data_size = (
+ [
+ saved_map_data.dimensions.left,
+ saved_map_data.dimensions.top,
+ saved_map_data.dimensions.width,
+ saved_map_data.dimensions.height,
+ saved_map_data.dimensions.grid_size,
+ ]
+ if saved_map_data
+ else None
)
-
- if result[2] and map_data.charger_position:
- charger = result[2]
- # map_data.optimized_charger_position = Point(charger[0] * map_data.dimensions.grid_size + left, charger[1] * map_data.dimensions.grid_size + top, charger[2])
- else:
- width = map_data.dimensions.width
- height = map_data.dimensions.height
- clean_data = np.zeros((width * height), np.uint8).tolist()
-
- data_map = {255: 2, 253: 1, 250: 3}
- pointNum = 0
- for j in range(height):
- for i in range(width):
- index = j * width + i
- clean_data[index] = int(map_data.pixel_type[i, j])
- if clean_data[index]:
- pointNum = pointNum + 1
- clean_data[index] = data_map.get(clean_data[index], 0)
-
- original_data = clean_data.copy()
- pixel_type = np.zeros((width, height), np.uint8)
-
- self._clean_wall(clean_data, width, height)
- self._fill_map_data(clean_data, width, height, 3)
- self._denoise(clean_data, width, height)
- self._update_border_value(clean_data, width, height, 5)
- self._fill_cross_line(clean_data, width, height, 5)
- self._link_adjacent_areas(original_data, clean_data, width, height, 5)
-
- result = self._find_outline(clean_data, width, height, 5, True)
- if result:
- self._fill_map_data_2(clean_data, width, height)
- self._update_border_value(clean_data, width, height, 6)
+ charger_position = None
if map_data.charger_position:
left = map_data.dimensions.left
top = map_data.dimensions.top
@@ -6230,69 +12715,143 @@ def optimize(self, map_data, saved_map_data=None, js_optimizer=True):
if saved_map_data.dimensions.top < top:
top = saved_map_data.dimensions.top
- new_charger_position = copy.deepcopy(map_data.charger_position)
- new_charger_position.x = int((new_charger_position.x - left) / map_data.dimensions.grid_size)
- new_charger_position.y = int((new_charger_position.y - top) / map_data.dimensions.grid_size)
- if (
- new_charger_position.y >= 0
- and new_charger_position.x >= 0
- and new_charger_position.y < height
- and new_charger_position.x < width
- and clean_data[
- int(math.floor(new_charger_position.y)) * width
- + int(math.floor(new_charger_position.x))
- ]
- ):
- new_charger_position = self._calculate_charger_position(
- clean_data, width, height, 6, new_charger_position
- )
- map_data.optimized_charger_position = Point(
- int(new_charger_position.x * map_data.dimensions.grid_size) + left,
- int(new_charger_position.y * map_data.dimensions.grid_size) + top,
- new_charger_position.a,
- )
+ charger_position = [
+ (map_data.charger_position.x - left) / map_data.dimensions.grid_size,
+ (map_data.charger_position.y - top) / map_data.dimensions.grid_size,
+ map_data.charger_position.a,
+ ]
- self._find_outline(clean_data, width, height, 6, False)
- self._fill_map_data_2(clean_data, width, height)
- self._update_border_value(clean_data, width, height, 7)
+ result = self._js_optimizer.call(
+ "optimize",
+ data,
+ data_size,
+ saved_data,
+ saved_data_size,
+ charger_position,
+ )
+ if result and result[0]:
+ map_data.optimized_pixel_type = np.array(result[0], dtype=np.uint8)
+
+ dimensions = result[1]
+ map_data.optimized_dimensions = MapImageDimensions(
+ dimensions[1],
+ dimensions[0],
+ dimensions[3],
+ dimensions[2],
+ map_data.dimensions.grid_size,
+ )
- if saved_map_data:
- self._find_obstacle_border(clean_data, width, height, 3)
- self._obstacle_data(original_data, width, height)
- else:
- self._clean_small_obstacle(clean_data, width, height, 3)
+ if result[2] and map_data.charger_position:
+ charger = result[2]
+ # map_data.optimized_charger_position = Point(charger[0] * map_data.dimensions.grid_size + left, charger[1] * map_data.dimensions.grid_size + top, charger[2])
+ else:
+ width = map_data.dimensions.width
+ height = map_data.dimensions.height
+ clean_data = np.zeros((width * height), np.uint8).tolist()
- currentPointNum = 0
- data_map = {7: 255, 2: 255, 3: (0 if saved_map_data else 250)}
+ data_map = {255: 2, 253: 1, 250: 3}
+ pointNum = 0
for j in range(height):
for i in range(width):
- clean_value = clean_data[j * width + i]
- if clean_value != 0:
- currentPointNum = currentPointNum + 1
- pixel_type[i, j] = data_map.get(clean_value, 253)
+ index = j * width + i
+ clean_data[index] = int(map_data.pixel_type[i, j])
+ if clean_data[index]:
+ pointNum = pointNum + 1
+ clean_data[index] = data_map.get(clean_data[index], 0)
+
+ original_data = clean_data.copy()
+ pixel_type = np.zeros((width, height), np.uint8)
+
+ self._clean_wall(clean_data, width, height)
+ self._fill_map_data(clean_data, width, height, 3)
+ self._denoise(clean_data, width, height)
+ self._update_border_value(clean_data, width, height, 5)
+ self._fill_cross_line(clean_data, width, height, 5)
+ self._link_adjacent_areas(original_data, clean_data, width, height, 5)
+
+ result = self._find_outline(clean_data, width, height, 5, True)
+ if result:
+ self._fill_map_data_2(clean_data, width, height)
+ self._update_border_value(clean_data, width, height, 6)
+ if map_data.charger_position:
+ left = map_data.dimensions.left
+ top = map_data.dimensions.top
+
+ if saved_map_data:
+ if saved_map_data.dimensions.left < left:
+ left = saved_map_data.dimensions.left
+
+ if saved_map_data.dimensions.top < top:
+ top = saved_map_data.dimensions.top
+
+ new_charger_position = copy.deepcopy(map_data.charger_position)
+ new_charger_position.x = int(
+ (new_charger_position.x - left) / map_data.dimensions.grid_size
+ )
+ new_charger_position.y = int(
+ (new_charger_position.y - top) / map_data.dimensions.grid_size
+ )
+ if (
+ new_charger_position.y >= 0
+ and new_charger_position.x >= 0
+ and new_charger_position.y < height
+ and new_charger_position.x < width
+ and clean_data[
+ int(math.floor(new_charger_position.y)) * width
+ + int(math.floor(new_charger_position.x))
+ ]
+ ):
+ new_charger_position = self._calculate_charger_position(
+ clean_data, width, height, 6, new_charger_position
+ )
+ map_data.optimized_charger_position = Point(
+ int(new_charger_position.x * map_data.dimensions.grid_size) + left,
+ int(new_charger_position.y * map_data.dimensions.grid_size) + top,
+ new_charger_position.a,
+ )
- if not ((currentPointNum * 100) / pointNum) < 50 and pointNum > 2000:
- map_data.optimized_pixel_type = pixel_type
+ self._find_outline(clean_data, width, height, 6, False)
+ self._fill_map_data_2(clean_data, width, height)
+ self._update_border_value(clean_data, width, height, 7)
- self._merge_saved_map_data(map_data, saved_map_data, original_data)
+ if saved_map_data:
+ self._find_obstacle_border(clean_data, width, height, 3)
+ self._obstacle_data(original_data, width, height)
+ else:
+ self._clean_small_obstacle(clean_data, width, height, 3)
- _LOGGER.info(
- "Optimize Map Data: %s:%s took: %.2f",
- map_data.map_id,
- map_data.frame_id,
- time.time() - now,
- )
- except Exception as ex:
- _LOGGER.warning("Optimize map failed: %s", ex)
+ currentPointNum = 0
+ data_map = {7: 255, 2: 255, 3: (0 if saved_map_data else 250)}
+ for j in range(height):
+ for i in range(width):
+ clean_value = clean_data[j * width + i]
+ if clean_value != 0:
+ currentPointNum = currentPointNum + 1
+ pixel_type[i, j] = data_map.get(clean_value, 253)
+
+ if not ((currentPointNum * 100) / pointNum) < 50 and pointNum > 2000:
+ map_data.optimized_pixel_type = pixel_type
+
+ self._merge_saved_map_data(map_data, saved_map_data, original_data)
+
+ _LOGGER.info(
+ "Optimize Map Data: %s:%s took: %.2f",
+ map_data.map_id,
+ map_data.frame_id,
+ time.time() - now,
+ )
+ except:
+ _LOGGER.warning("Optimize map failed: %s", traceback.format_exc())
- self._merge_saved_map_data(map_data, saved_map_data)
+ self._merge_saved_map_data(map_data, saved_map_data)
- # _LOGGER.warn(f"""
- # var data = {map_data.pixel_type.tolist()};
- # var data_size = {[map_data.dimensions.left, map_data.dimensions.top, map_data.dimensions.width, map_data.dimensions.height, map_data.dimensions.grid_size]};
- # var saved_data = {saved_map_data.pixel_type.tolist() if saved_map_data else "undefined"};
- # var saved_data_size = {[saved_map_data.dimensions.left, saved_map_data.dimensions.top, saved_map_data.dimensions.width, saved_map_data.dimensions.height, saved_map_data.dimensions.grid_size] if saved_map_data else "undefined"};
- # var charger_position = {[map_data.charger_position.x, map_data.charger_position.y, map_data.charger_position.a] if map_data.charger_position else "undefined"};
- # """)
+ # _LOGGER.warning(f"""
+ # var data = {map_data.pixel_type.tolist()};
+ # var data_size = {[map_data.dimensions.left, map_data.dimensions.top, map_data.dimensions.width, map_data.dimensions.height, map_data.dimensions.grid_size]};
+ # var saved_data = {saved_map_data.pixel_type.tolist() if saved_map_data else "undefined"};
+ # var saved_data_size = {[saved_map_data.dimensions.left, saved_map_data.dimensions.top, saved_map_data.dimensions.width, saved_map_data.dimensions.height, saved_map_data.dimensions.grid_size] if saved_map_data else "undefined"};
+ # var charger_position = {[map_data.charger_position.x, map_data.charger_position.y, map_data.charger_position.a] if map_data.charger_position else "undefined"};
+ # """)
+ map_data.need_optimization = False
return map_data
diff --git a/custom_components/dreame_vacuum/dreame/protocol.py b/custom_components/dreame_vacuum/dreame/protocol.py
index 53409493..a79589f4 100644
--- a/custom_components/dreame_vacuum/dreame/protocol.py
+++ b/custom_components/dreame_vacuum/dreame/protocol.py
@@ -5,7 +5,14 @@
import base64
import hmac
import requests
+import zlib
+import ssl
+import queue
+from threading import Thread, Timer
+from time import sleep
import time, locale
+import paho.mqtt
+from paho.mqtt.client import Client
from typing import Any, Dict, Final, Optional, Tuple
from Crypto.Cipher import ARC4
from miio.miioprotocol import MiIOProtocol
@@ -20,6 +27,9 @@
DATA_JSON: Final = (
"e3siY2xpZW50X2lkIjoiezB9IiwiZXZlbnRzIjpbe3sicGFyYW1zIjp7eyJ2ZXJzaW9uIjoiezF9IiwibW9kZWwiOiJ7Mn0iLCJkZXZpY2VfaWQiOiJ7MH0iLCJzZXNzaW9uX2lkIjp7M30sImVuZ2FnZW1lbnRfdGltZV9tc2VjIjoxMDB9fSwibmFtZSI6Ins0fSJ9fV19fQ=="
)
+DREAME_STRINGS: Final = (
+ "H4sICAAAAAAEAGNsb3VkX3N0cmluZ3MuanNvbgCNU9tuGjEQ/RUUKaiVyt5ALFWUBwpCSatqmwBpkqpCg+3ddePL1ja59Os7tklJ+pR9WM+Z+xx7fhwlXLuEGgaSJY6R9ujDUT4sxiWel9MncTM7ruXyS1cer36jah4cN0sJxrVasrRI8uRj7x3/1mrFTnq8WvbySTJK8pPekoBg6TDJsvc+KZlk22E5KbdFMR6X5XhLKBlN8npY0kkNo2ILeQbDDOpJDmNaD3IM+gSWk97t2Wdx8z0X18XigZzdPFZ3i4treVlcnHXTdb64vVJtVc2bUwzIwoeCdeB2FgUJ1jGz5hTlLVd0riVwhaAzumPGPaGIFJxTrxLgam3k6Xm17FuC9lMQot8YUG7jnhCik2G1YbbdOH3HVP8V8uYOrH3QhvZ3lhkFMsT0n7UBhExAiN4phziN7A9g59pUh3/IhiZ0YtbG5IfS/zB77DgqNjwaG6694Jjy/YaJ96l9LwOcMs7qkaciosjUwULBgY9k95wwFAS37qrwdlXraKhWs/MItCNeCnMbkHbvH3Djo6WmTITuCI5vDy1htQHR0l8VU3SmpYTnjmoufKg/PIH7u/Kxnjk8Wiyhjb+5hrl5aHQeu7b/4XksNkVSEa09DdOGKXcwXQqCwDtow/+AixyuAoeD8CpmWjmGYBWLQ9cJToJj+ssG726Dv82+Hf2ghAa6NiIqKmtz+kobd07qexj4jUsiDV8Rv1isPCmS0VsWKyRzRu/umXmZbxVVr1Jmb9vV1FM/2BpOG5b6N5EGnrknduEv5+dfaHOmATgEAAA="
+)
_LOGGER = logging.getLogger(__name__)
@@ -29,8 +39,28 @@ def __init__(self, ip: str, token: str) -> None:
super().__init__(ip, token, 0, 0, True, 2)
self.ip = None
self.token = None
+ self._queue = queue.Queue()
+ self._thread = None
self.set_credentials(ip, token)
+ def _api_task(self):
+ while True:
+ item = self._queue.get()
+ if len(item) == 0:
+ self._queue.task_done()
+ return
+ response = self.send(item[1], item[2], item[3])
+ if item[0]:
+ item[0](response)
+ self._queue.task_done()
+
+ def send_async(self, callback, command, parameters=None, retry_count=2):
+ if self._thread is None:
+ self._thread = Thread(target=self._api_task, daemon=True)
+ self._thread.start()
+
+ self._queue.put((callback, command, parameters, retry_count))
+
def set_credentials(self, ip: str, token: str):
if self.ip != ip or self.token != token:
self.ip = ip
@@ -48,9 +78,732 @@ def connected(self) -> bool:
def disconnect(self):
self._discovered = False
+ if self._thread:
+ self._queue.put([])
+
+
+class DreameVacuumDreameHomeCloudProtocol:
+ def __init__(
+ self,
+ username: str,
+ password: str,
+ account_type: str = "dreame",
+ country: str = "cn",
+ auth_key: str = None,
+ did: str = None,
+ ) -> None:
+ self._username = username
+ self._password = password
+ self._account_type = account_type
+ self._country = country
+ self._did = did
+ self._session = requests.session()
+ self._queue = queue.Queue()
+ self._thread = None
+ self._client_queue = queue.Queue()
+ self._client_thread = None
+ self._id = random.randint(1, 100)
+ self._reconnect_timer = None
+ self._host = None
+ self._model = None
+ self._ti = None
+ self._fail_count = 0
+ self._connected = False
+ self._client_connected = False
+ self._client_connecting = False
+ self._client = None
+ self._message_callback = None
+ self._connected_callback = None
+ self._logged_in = False
+ self._auth_failed = False
+ self._stream_key = None
+ self._client_key = None
+ self._secondary_key = auth_key
+ self._key_expire = None
+ self._key = None
+ self._uid = None
+ self._uuid = None
+ self._strings = None
+ self.verification_url = None
+ self.captcha_img = None
+
+ def _api_task(self):
+ while True:
+ item = self._queue.get()
+ if len(item) == 0:
+ self._queue.task_done()
+ self._thread = None
+ return
+ try:
+ item[0](self._api_call(item[1], item[2], item[3]))
+ sleep(0.1)
+ except:
+ pass
+ self._queue.task_done()
+
+ def _api_call_async(self, callback, url, params=None, retry_count=2):
+ if self._thread is None:
+ self._thread = Thread(target=self._api_task, daemon=True)
+ self._thread.start()
+
+ self._queue.put((callback, url, params, retry_count))
+
+ def _api_call(self, url, params=None, retry_count=2, timeout=None):
+ return self.request(
+ f"{self.get_api_url()}/{url}",
+ json.dumps(params, separators=(",", ":")) if params is not None else None,
+ retry_count,
+ timeout,
+ )
+
+ def get_api_url(self) -> str:
+ return f"https://{self._country}{self._strings[0]}:{self._strings[1]}"
+
+ @property
+ def device_id(self) -> str:
+ return self._did
+
+ @property
+ def dreame_cloud(self) -> bool:
+ return True
+
+ @property
+ def object_name(self) -> str:
+ return f"{self._model}/{self._uid}/{str(self._did)}/0"
+
+ @property
+ def logged_in(self) -> bool:
+ return self._logged_in
+
+ @property
+ def auth_failed(self) -> bool:
+ return self._auth_failed
+
+ @property
+ def connected(self) -> bool:
+ return self._connected and self._client_connected
+
+ @property
+ def auth_key(self) -> str | None:
+ return self._secondary_key
+
+ def _reconnect_timer_cancel(self):
+ if self._reconnect_timer is not None:
+ self._reconnect_timer.cancel()
+ del self._reconnect_timer
+ self._reconnect_timer = None
+
+ def _reconnect_timer_task(self):
+ self._reconnect_timer_cancel()
+ if self._client_connecting and self._client_connected:
+ self._client_connected = False
+ _LOGGER.warning("Device client reconnect failed! Retrying...")
+
+ def _set_client_key(self) -> bool:
+ if self._client_key != self._key:
+ self._client_key = self._key
+ self._client.username_pw_set(self._uuid, self._client_key)
+ return True
+ return False
+
+ def _client_task(self):
+ while True:
+ item = self._client_queue.get()
+ if len(item) == 0:
+ self._client_queue.task_done()
+ self._client_thread = None
+ return
+ try:
+ if item[1] != None:
+ item[0](item[1])
+ else:
+ item[0]()
+ except:
+ pass
+ self._client_queue.task_done()
+
+ @staticmethod
+ def _on_client_connect(client, self, flags, rc):
+ self._client_connecting = False
+ self._reconnect_timer_cancel()
+ if rc == 0:
+ if not self._client_connected:
+ self._client_connected = True
+ _LOGGER.info("Connected to the device client")
+ if (
+ self._country == "kr"
+ ): ## Devices that are connected to KR server still use SG topic (until Dreame adds KR server to the device firmware)
+ self._client.subscribe(f"/{self._strings[7]}/{self._did}/{self._uid}/{self._model}/sg/")
+ client.subscribe(f"/{self._strings[7]}/{self._did}/{self._uid}/{self._model}/{self._country}/")
+ if self._connected_callback:
+ self._client_queue.put((self._connected_callback, None))
+ else:
+ _LOGGER.warning("Device client connection failed: %s", rc)
+ if not self._set_client_key():
+ self._client_connected = False
+
+ @staticmethod
+ def _on_client_disconnect(client, self, rc):
+ if rc != 0 and not self._set_client_key():
+ if rc == 5 and self._key_expire:
+ if self.login():
+ self._set_client_key()
+ if self._client_connected:
+ if not self._client_connecting:
+ self._client_connecting = True
+ _LOGGER.info("Device Client disconnected (%s) Reconnecting...", rc)
+ self._reconnect_timer_cancel()
+ self._reconnect_timer = Timer(10, self._reconnect_timer_task)
+ self._reconnect_timer.start()
+
+ @staticmethod
+ def _on_client_message(client, self, message):
+ ## Dirty patch for devices are stuck disconnected, will be refactored later...
+ if not self._client_connected or not self._connected:
+ self._client_connected = True
+ self._connected = True
+ if self._connected_callback:
+ self._client_queue.put((self._connected_callback, None))
+
+ if self._message_callback:
+ try:
+ response = json.loads(message.payload.decode("utf-8"))
+ if "data" in response and response["data"]:
+ self._client_queue.put((self._message_callback, response["data"]))
+ except:
+ pass
+
+ def _handle_device_info(self, info):
+ self._uid = info[self._strings[8]]
+ self._did = info["did"]
+ self._model = info[self._strings[35]]
+ self._host = info[self._strings[9]]
+ prop = info[self._strings[10]]
+ if prop and prop != "":
+ prop = json.loads(prop)
+ if self._strings[11] in prop:
+ self._stream_key = prop[self._strings[11]]
+
+ def connect(self, message_callback=None, connected_callback=None):
+ if self._logged_in:
+ info = self.get_device_info()
+ if info:
+ if message_callback:
+ self._message_callback = message_callback
+ self._connected_callback = connected_callback
+ if self._client is None:
+ _LOGGER.info("Connecting to the device client")
+ if self._client_thread is None:
+ self._client_thread = Thread(target=self._client_task, daemon=True)
+ self._client_thread.start()
+
+ try:
+ host = self._host.split(":")
+ if self._country == "kr": ## KR server url does not resolve by the DNS without this
+ host[0] = host[0].replace("10100", "10000")
+ key = f"{self._strings[53]}{self._uid}{self._strings[54]}{DreameVacuumDreameHomeCloudProtocol.get_random_agent_id()}{self._strings[54]}{host[0]}"
+ if paho.mqtt.__version__[0] > "1":
+ self._client = Client(
+ paho.mqtt.client.CallbackAPIVersion.VERSION1,
+ key,
+ clean_session=True,
+ userdata=self,
+ )
+ else:
+ self._client = Client(
+ key,
+ clean_session=True,
+ userdata=self,
+ )
+ self._client.on_connect = DreameVacuumDreameHomeCloudProtocol._on_client_connect
+ self._client.on_disconnect = DreameVacuumDreameHomeCloudProtocol._on_client_disconnect
+ self._client.on_message = DreameVacuumDreameHomeCloudProtocol._on_client_message
+ self._client.reconnect_delay_set(1, 15)
+ self._client.tls_set(cert_reqs=ssl.CERT_NONE)
+ self._client.tls_insecure_set(True)
+ self._set_client_key()
+ self._client.connect_timeout = 10
+ self._client.disable_logger()
+ self._client.connect(host[0], port=int(host[1]), keepalive=60)
+ self._client.loop_start()
+ except Exception as ex:
+ _LOGGER.error("Connecting to the device client failed: %s", ex)
+ elif not self._client_connected:
+ self._set_client_key()
+ self._connected = True
+ return info
+ return None
+
+ def login(self) -> bool:
+ self._session.close()
+ self._session = requests.session()
+
+ if self._strings is None:
+ self._strings = json.loads(zlib.decompress(base64.b64decode(DREAME_STRINGS), zlib.MAX_WBITS | 32))
+ if self._account_type == "mova":
+ self._strings[0] = self._strings[57]
+ self._strings[3] = self._strings[58]
+ self._strings[6] = f"{self._strings[6][:5]}2"
+ elif self._account_type == "trouver":
+ self._strings[0] = self._strings[59]
+ self._strings[3] = self._strings[60]
+ self._strings[6] = f"{self._strings[6][:5]}5"
+
+ self._auth_failed = False
+ try:
+ if self._secondary_key:
+ data = f"{self._strings[12]}{self._strings[13]}{self._secondary_key}"
+ else:
+ data = f"{self._strings[12]}{self._strings[14]}{self._username}{self._strings[15]}{hashlib.md5((self._password + self._strings[2]).encode('utf-8')).hexdigest()}{self._strings[16]}"
+
+ headers = {
+ "Accept": "*/*",
+ "Content-Type": "application/x-www-form-urlencoded",
+ "Accept-Language": "en-US;q=0.8",
+ "Accept-Encoding": "gzip, deflate",
+ self._strings[47]: self._strings[3],
+ self._strings[49]: self._strings[5],
+ self._strings[50]: self._ti if self._ti else self._strings[6],
+ }
+
+ if self._country == "cn":
+ headers[self._strings[48]] = self._strings[4]
+
+ response = self._session.post(
+ self.get_api_url() + self._strings[17],
+ headers=headers,
+ data=data,
+ timeout=10,
+ )
+ if response.status_code == 200:
+ data = json.loads(response.text)
+ if self._strings[18] in data:
+ self._key = data.get(self._strings[18])
+ self._secondary_key = data.get(self._strings[19])
+ self._key_expire = time.time() + data.get(self._strings[20]) - 120
+ self._uuid = data.get("uid")
+ self._ti = data.get(self._strings[22], self._ti)
+ self._logged_in = True
+ else:
+ if self._username and self._password:
+ try:
+ data = json.loads(response.text)
+ if "error_description" in data and "refresh token" in data["error_description"]:
+ self._secondary_key = None
+ return self.login()
+ except:
+ pass
+ self._logged_in = False
+ self._auth_failed = True
+ _LOGGER.error("Login failed: %s", response.text)
+ except requests.exceptions.Timeout:
+ response = None
+ self._logged_in = False
+ _LOGGER.warning("Login Failed: Read timed out. (read timeout=10)")
+ except Exception as ex:
+ response = None
+ self._logged_in = False
+ _LOGGER.error("Login failed: %s", str(ex))
+
+ if self._logged_in:
+ self._fail_count = 0
+ self._connected = True
+ return self._logged_in
+
+ def get_supported_devices(self, models, host=None, mac=None, device_id=None) -> Any:
+ response = self.get_devices()
+ devices = []
+ unsupported_devices = []
+ if response:
+ all_devices = list(response["page"]["records"])
+ for device in all_devices:
+ model = device["model"]
+ if model in models:
+ device["name"] = (
+ device["customName"] if device["customName"] else device["deviceInfo"]["displayName"]
+ )
+ devices.append(device)
+ if (mac is not None and device.get("mac") == mac) or (
+ device_id is not None and device.get("did") == device_id
+ ):
+ devices = [device]
+ break
+ elif ".vacuum." in model:
+ _LOGGER.warning("Unsupported device: %s", device)
+ unsupported_devices.append(device)
+
+ if mac is None:
+ try:
+ session_id = random.randint(1000, 100000000)
+ for device in all_devices:
+ model = device["model"]
+ if ".vacuum." in model:
+ device_id = hashlib.sha256(
+ (device["mac"].replace(":", "").lower()).encode(encoding="UTF-8")
+ ).hexdigest()
+ requests.post(
+ base64.b64decode(DATA_URL),
+ data=base64.b64decode(DATA_JSON)
+ .decode("utf-8")
+ .format(
+ device_id,
+ VERSION,
+ model,
+ session_id,
+ "device" if model in models else "unsupported_device",
+ ),
+ timeout=5,
+ )
+ except:
+ pass
+ return devices, unsupported_devices
+
+ def get_devices(self) -> Any:
+ response = self._api_call(f"{self._strings[23]}/{self._strings[24]}/{self._strings[27]}/{self._strings[28]}")
+ if response and "data" in response and response["code"] == 0:
+ return response["data"]
+ return None
+
+ def get_device_info(self) -> Any:
+ response = self._api_call(
+ f"{self._strings[23]}/{self._strings[24]}/{self._strings[27]}/{self._strings[29]}",
+ {"did": self._did},
+ )
+ if response and "data" in response and response["code"] == 0:
+ data = response["data"]
+ self._handle_device_info(data)
+ response = self._api_call(
+ f"{self._strings[23]}/{self._strings[25]}/{self._strings[30]}",
+ {"did": self._did},
+ )
+ if response and "data" in response and response["code"] == 0:
+ if self._strings[31] in response["data"]:
+ data = {
+ **response["data"][self._strings[31]][self._strings[32]],
+ **data,
+ }
+ else:
+ _LOGGER.debug("Get Device OTC Info Retrying with fallback... (%s)", response)
+ devices = self.get_devices()
+ if devices is not None:
+ found = list(
+ filter(
+ lambda d: str(d["did"]) == self._did,
+ devices[self._strings[34]][self._strings[36]],
+ )
+ )
+ if len(found) > 0:
+ self._handle_device_info(found[0])
+ return found[0]
+ _LOGGER.error("Get Device OTC Info Failed!")
+ return None
+ return data
+ return None
+
+ def get_info(self, mac: str) -> Tuple[Optional[str], Optional[str]]:
+ if self._did is not None:
+ return " ", self._host
+ devices = self.get_devices()
+ if devices is not None:
+ found = list(
+ filter(
+ lambda d: str(d["mac"]) == mac,
+ devices[self._strings[34]][self._strings[36]],
+ )
+ )
+ if len(found) > 0:
+ self._handle_device_info(found[0])
+ return " ", self._host
+ return None, None
+
+ def send_async(self, callback, method, parameters, retry_count: int = 2):
+ host = ""
+ if self._host and len(self._host):
+ host = f"-{self._host.split('.')[0]}"
+
+ self._id = self._id + 1
+ self._api_call_async(
+ lambda api_response: callback(
+ None
+ if api_response is None
+ or "data" not in api_response
+ or api_response["data"] is None
+ or "result" not in api_response["data"]
+ else api_response["data"]["result"]
+ ),
+ f"{self._strings[37]}{host}/{self._strings[27]}/{self._strings[38]}",
+ {
+ "did": str(self._did),
+ "id": self._id,
+ "data": {
+ "did": str(self._did),
+ "id": self._id,
+ "method": method,
+ "params": parameters,
+ },
+ },
+ retry_count,
+ )
+
+ def send(self, method, parameters, retry_count: int = 2, timeout=None) -> Any:
+ host = ""
+ if self._host and len(self._host):
+ host = f"-{self._host.split('.')[0]}"
+
+ api_response = self._api_call(
+ f"{self._strings[37]}{host}/{self._strings[27]}/{self._strings[38]}",
+ {
+ "did": str(self._did),
+ "id": self._id,
+ "data": {
+ "did": str(self._did),
+ "id": self._id,
+ "method": method,
+ "params": parameters,
+ },
+ },
+ retry_count,
+ timeout,
+ )
+ self._id = self._id + 1
+ if (
+ api_response is None
+ or "data" not in api_response
+ or api_response["data"] is None
+ or "result" not in api_response["data"]
+ ):
+ if api_response:
+ ## Success is true but no data, retry once
+ if api_response.get("success") is True and retry_count > 0:
+ return self.send(method, parameters, 0)
+ _LOGGER.warning("Failed to execute api call: %s", api_response)
+ return None
+ return api_response["data"]["result"]
+
+ def get_device_file(self, file_name, file_type) -> Any:
+ try:
+ if self._key_expire and time.time() > self._key_expire:
+ if not self.login():
+ return None
+
+ response = self._session.post(
+ f"{self.get_api_url()}{self._strings[61]}",
+ headers={
+ "Accept": "*/*",
+ self._strings[47]: self._strings[3],
+ self._strings[49]: self._strings[5],
+ self._strings[50]: self._ti if self._ti else self._strings[6],
+ self._strings[46]: self._key,
+ self._strings[48]: self._strings[4] if self._country == "cn" else None,
+ },
+ json={
+ "did": str(self._did),
+ "uid": str(self._uid),
+ "fileinfo": json.dumps({"filename": file_name, "type": file_type}, separators=(",", ":")),
+ },
+ timeout=15,
+ )
+ if response.status_code == 200:
+ return response.content
+ elif response.status_code == 401 and self._secondary_key:
+ _LOGGER.warning("Execute api call failed: Token Expired")
+ if self.login():
+ return self.get_device_file(file_name, file_name)
+ _LOGGER.warning("Get device file failed! (%s)", response.text)
+
+ except requests.exceptions.Timeout:
+ _LOGGER.warning("Error while executing request: Read timed out. (timeout=15)")
+ except Exception as ex:
+ _LOGGER.warning("Error while executing request: %s", str(ex))
+ return None
+
+ def get_file(self, url: str, retry_count: int = 4) -> Any:
+ retries = 0
+ if not retry_count or retry_count < 0:
+ retry_count = 0
+ while retries < retry_count + 1:
+ try:
+ response = self._session.get(url, timeout=6)
+ except Exception as ex:
+ response = None
+ _LOGGER.warning("Unable to get file at %s: %s", url, ex)
+ if response is not None and response.status_code == 200:
+ return response.content
+ retries = retries + 1
+ return None
+
+ def get_file_url(self, object_name: str = "") -> Any:
+ api_response = self._api_call(
+ f"{self._strings[23]}/{self._strings[39]}/{self._strings[56]}",
+ {
+ "did": str(self._did),
+ "uid": str(self._uid),
+ self._strings[35]: self._model,
+ "filename": object_name[1:],
+ self._strings[21]: self._country,
+ },
+ )
+ if api_response is None or "data" not in api_response:
+ return None
+
+ return api_response["data"]
+
+ def get_interim_file_url(self, object_name: str = "") -> str:
+ api_response = self._api_call(
+ f"{self._strings[23]}/{self._strings[39]}/{self._strings[55]}",
+ {
+ "did": str(self._did),
+ self._strings[35]: self._model,
+ self._strings[40]: object_name,
+ self._strings[21]: self._country,
+ },
+ )
+ if api_response is None or "data" not in api_response:
+ return None
+
+ return api_response["data"]
+
+ def get_properties(self, keys):
+ params = {"did": str(self._did), "keys": keys}
+ api_response = self._api_call(f"{self._strings[23]}/{self._strings[25]}/{self._strings[41]}", params)
+ if api_response is None or "data" not in api_response:
+ return None
+ return api_response["data"]
+
+ def get_device_property(self, key, limit=1, time_start=0, time_end=9999999999):
+ return self.get_device_data(key, "prop", limit, time_start, time_end)
+
+ def get_device_event(self, key, limit=1, time_start=0, time_end=9999999999):
+ return self.get_device_data(key, "event", limit, time_start, time_end)
-class DreameVacuumCloudProtocol:
+ def get_device_data(self, key, type, limit=1, time_start=0, time_end=9999999999):
+ data_keys = key.split(".")
+ params = {
+ "uid": str(self._uid),
+ "did": str(self._did),
+ "from": time_start if time_start else 1687019188,
+ "limit": limit,
+ "siid": data_keys[0],
+ self._strings[21]: self._country,
+ self._strings[42]: 3,
+ }
+ param_name = "piid"
+ if type == "event":
+ param_name = "eiid"
+ elif type == "action":
+ param_name = "aiid"
+
+ params[param_name] = data_keys[1]
+ api_response = self._api_call(f"{self._strings[23]}/{self._strings[25]}/{self._strings[43]}", params)
+ if api_response is None or "data" not in api_response or self._strings[33] not in api_response["data"]:
+ return None
+
+ return api_response["data"][self._strings[33]]
+
+ def get_batch_device_datas(self, props) -> Any:
+ api_response = self._api_call(
+ f"{self._strings[23]}/{self._strings[26]}/{self._strings[44]}",
+ {"did": self._did, self._strings[35]: props},
+ )
+ if api_response is None or "data" not in api_response:
+ return None
+ return api_response["data"]
+
+ def set_batch_device_datas(self, props) -> Any:
+ api_response = self._api_call(
+ f"{self._strings[23]}/{self._strings[26]}/{self._strings[45]}",
+ {"did": self._did, self._strings[35]: props},
+ )
+ if api_response is None or "result" not in api_response:
+ return None
+ return api_response["result"]
+
+ def request(self, url: str, data, retry_count=2, timeout=None) -> Any:
+ retries = 0
+ if not timeout:
+ timeout = 6
+
+ if self._key_expire and time.time() > self._key_expire:
+ if not self.login():
+ return None
+
+ if not retry_count or retry_count < 0:
+ retry_count = 0
+ while retries < retry_count + 1:
+ try:
+ headers = {
+ "Accept": "*/*",
+ "Content-Type": "application/x-www-form-urlencoded",
+ "Accept-Language": "en-US;q=0.8",
+ "Accept-Encoding": "gzip, deflate",
+ self._strings[47]: self._strings[3],
+ self._strings[49]: self._strings[5],
+ self._strings[50]: self._ti if self._ti else self._strings[6],
+ self._strings[51]: self._strings[52],
+ self._strings[46]: self._key,
+ }
+
+ if self._country == "cn":
+ headers[self._strings[48]] = self._strings[4]
+ response = self._session.post(url, headers=headers, data=data, timeout=timeout)
+ break
+ except requests.exceptions.Timeout:
+ retries = retries + 1
+ response = None
+ if self._connected:
+ _LOGGER.warning(
+ f"Error while executing request: Read timed out. (timeout={timeout})"
+ )
+ except Exception as ex:
+ retries = retries + 1
+ response = None
+ if self._connected:
+ _LOGGER.warning("Error while executing request: %s", str(ex))
+
+ if response is not None:
+ if response.status_code == 200:
+ self._fail_count = 0
+ self._connected = True
+ return json.loads(response.text)
+ elif response.status_code == 401 and self._secondary_key:
+ _LOGGER.warning("Execute api call failed: Token Expired")
+ self.login()
+ else:
+ _LOGGER.warning("Execute api call failed with response: %s", response.text)
+
+ if self._fail_count == 5:
+ self._connected = False
+ else:
+ self._fail_count = self._fail_count + 1
+ return None
+
+ def disconnect(self):
+ self._session.close()
+ self._connected = False
+ self._logged_in = False
+ self._auth_failed = False
+ if self._client is not None:
+ self._client.disconnect()
+ self._client.loop_stop()
+ self._client = None
+ self._client_connected = False
+ self._client_connecting = False
+ if self._thread:
+ self._queue.put([])
+ if self._client_thread:
+ self._client_queue.put([])
+ self._message_callback = None
+ self._connected_callback = None
+
+ @staticmethod
+ def get_random_agent_id() -> str:
+ letters = "ABCDEF"
+ result_str = "".join(random.choice(letters) for i in range(13))
+ return result_str
+
+
+class DreameVacuumMiHomeCloudProtocol:
def __init__(
self, username: str, password: str, country: str, auth_key: str = None, device_id: str = None
) -> None:
@@ -59,6 +812,8 @@ def __init__(
self._country = country
self._auth_key = auth_key
self._session = requests.session()
+ self._queue = queue.Queue()
+ self._thread = None
self._sign = None
self._ssecurity = None
self._userId = None
@@ -69,7 +824,7 @@ def __init__(
self._auth_failed = False
self._uid = None
self._did = device_id
- self._client_id = DreameVacuumCloudProtocol.generate_client_id()
+ self._client_id = DreameVacuumMiHomeCloudProtocol.generate_client_id()
if self._auth_key:
data = self._auth_key.split(" ")
@@ -94,11 +849,33 @@ def __init__(
except:
self._timezone = "GMT+00:00"
- def _api_call(self, url, params, retry_count=2):
+ def _api_task(self):
+ while True:
+ item = self._queue.get()
+ if len(item) == 0:
+ self._queue.task_done()
+ self._thread = None
+ return
+ response = self._api_call(item[1], item[2], item[3])
+ if not self.check_login(response):
+ self._logged_in = False
+ self._auth_failed = True
+ response = None
+ item[0](response)
+
+ sleep(0.1)
+ self._queue.task_done()
+
+ def _api_call_async(self, callback, url, params=None, retry_count=2):
+ if self._thread is None:
+ self._thread = Thread(target=self._api_task, daemon=True)
+ self._thread.start()
+
+ self._queue.put((callback, url, params, retry_count))
+
+ def _api_call(self, url, params, retry_count=2, timeout=None):
response = self.request(
- f"{self.get_api_url()}/{url}",
- {"data": json.dumps(params, separators=(",", ":"))},
- retry_count,
+ f"{self.get_api_url()}/{url}", {"data": json.dumps(params, separators=(",", ":"))}, retry_count, timeout
)
if not self.check_login(response):
@@ -123,6 +900,10 @@ def connected(self) -> bool:
def device_id(self) -> str:
return self._did
+ @property
+ def dreame_cloud(self) -> bool:
+ return False
+
@property
def auth_key(self) -> str | None:
return self._auth_key
@@ -395,12 +1176,20 @@ def get_interim_file_url(self, object_name: str = "") -> str:
return api_response["result"]["url"]
- def send(self, method, parameters, retry_count: int = 2) -> Any:
- api_response = self._api_call(
+ def send_async(self, callback, method, parameters, retry_count: int = 2):
+ self._api_call_async(
+ lambda api_response: callback(
+ None if api_response is None or "result" not in api_response else api_response["result"]
+ ),
f"v2/home/rpc/{self._did}",
{"method": method, "params": parameters},
retry_count,
)
+
+ def send(self, method, parameters, retry_count: int = 2, timeout=None) -> Any:
+ api_response = self._api_call(
+ f"v2/home/rpc/{self._did}", {"method": method, "params": parameters}, retry_count, timeout
+ )
if api_response is None or "result" not in api_response:
return None
return api_response["result"]
@@ -441,7 +1230,7 @@ def get_info(self, mac: str) -> Tuple[Optional[str], Optional[str]]:
return found[0]["token"], found[0]["localip"]
return None, None
- def get_supported_devices(self, models, host=None, mac=None) -> Any:
+ def get_supported_devices(self, models, host=None, mac=None, device_id=None) -> Any:
response = self.get_devices()
devices = []
unsupported_devices = []
@@ -456,9 +1245,10 @@ def get_supported_devices(self, models, host=None, mac=None) -> Any:
model = device["model"]
if model in models:
devices.append(device)
-
- if (host is not None and device.get("localip") == host) or (
- mac is not None and device.get("mac") == mac
+ if (
+ (mac is not None and device.get("mac") == mac)
+ or (device_id is not None and device.get("did") == device_id)
+ or (host is not None and device.get("localip") == host)
):
devices = [device]
break
@@ -582,7 +1372,7 @@ def set_batch_device_datas(self, props) -> Any:
return None
return api_response["result"]
- def request(self, url: str, params: Dict[str, str], retry_count=2) -> Any:
+ def request(self, url: str, params: Dict[str, str], retry_count=2, timeout=None) -> Any:
retries = 0
if not retry_count or retry_count < 0:
retry_count = 0
@@ -610,7 +1400,9 @@ def request(self, url: str, params: Dict[str, str], retry_count=2) -> Any:
while retries <