python-roborock 2.27.0__tar.gz → 2.28.0__tar.gz

{python_roborock-2.27.0 → python_roborock-2.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.27.0
+Version: 2.28.0
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only

{python_roborock-2.27.0 → python_roborock-2.28.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.27.0"
+version = "2.28.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.27.0 → python_roborock-2.28.0}/roborock/code_mappings.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from collections import namedtuple
 from enum import Enum, IntEnum
 
 _LOGGER = logging.getLogger(__name__)
@@ -50,6 +51,68 @@ class RoborockEnum(IntEnum):
         return cls.as_dict().items()
 
 
+ProductInfo = namedtuple("ProductInfo", ["nickname", "short_models"])
+
+
+class RoborockProductNickname(Enum):
+    # Coral Series
+    CORAL = ProductInfo(nickname="Coral", short_models=("a20", "a21"))
+    CORALPRO = ProductInfo(nickname="CoralPro", short_models=("a143", "a144"))
+
+    # Pearl Series
+    PEARL = ProductInfo(nickname="Pearl", short_models=("a74", "a75"))
+    PEARLC = ProductInfo(nickname="PearlC", short_models=("a103", "a104"))
+    PEARLE = ProductInfo(nickname="PearlE", short_models=("a167", "a168"))
+    PEARLELITE = ProductInfo(nickname="PearlELite", short_models=("a169", "a170"))
+    PEARLPLUS = ProductInfo(nickname="PearlPlus", short_models=("a86", "a87"))
+    PEARLPLUSS = ProductInfo(nickname="PearlPlusS", short_models=("a116", "a117", "a136"))
+    PEARLS = ProductInfo(nickname="PearlS", short_models=("a100", "a101"))
+    PEARLSLITE = ProductInfo(nickname="PearlSLite", short_models=("a122", "a123"))
+
+    # Ruby Series
+    RUBYPLUS = ProductInfo(nickname="RubyPlus", short_models=("t4", "s4"))
+    RUBYSC = ProductInfo(nickname="RubySC", short_models=("p5", "a08"))
+    RUBYSE = ProductInfo(nickname="RubySE", short_models=("a19",))
+    RUBYSLITE = ProductInfo(nickname="RubySLite", short_models=("p6", "s5e", "a05"))
+
+    # Tanos Series
+    TANOS = ProductInfo(nickname="Tanos", short_models=("t6", "s6"))
+    TANOSE = ProductInfo(nickname="TanosE", short_models=("t7", "a11"))
+    TANOSS = ProductInfo(nickname="TanosS", short_models=("a14", "a15"))
+    TANOSSC = ProductInfo(nickname="TanosSC", short_models=("a39", "a40"))
+    TANOSSE = ProductInfo(nickname="TanosSE", short_models=("a33", "a34"))
+    TANOSSMAX = ProductInfo(nickname="TanosSMax", short_models=("a52",))
+    TANOSSLITE = ProductInfo(nickname="TanosSLite", short_models=("a37", "a38"))
+    TANOSSPLUS = ProductInfo(nickname="TanosSPlus", short_models=("a23", "a24"))
+    TANOSV = ProductInfo(nickname="TanosV", short_models=("t7p", "a09", "a10"))
+
+    # Topaz Series
+    TOPAZS = ProductInfo(nickname="TopazS", short_models=("a29", "a30", "a76"))
+    TOPAZSC = ProductInfo(nickname="TopazSC", short_models=("a64", "a65"))
+    TOPAZSPLUS = ProductInfo(nickname="TopazSPlus", short_models=("a46", "a47", "a66"))
+    TOPAZSPOWER = ProductInfo(nickname="TopazSPower", short_models=("a62",))
+    TOPAZSV = ProductInfo(nickname="TopazSV", short_models=("a26", "a27"))
+
+    # Ultron Series
+    ULTRON = ProductInfo(nickname="Ultron", short_models=("a50", "a51"))
+    ULTRONE = ProductInfo(nickname="UltronE", short_models=("a72", "a84"))
+    ULTRONLITE = ProductInfo(nickname="UltronLite", short_models=("a73", "a85"))
+    ULTRONSC = ProductInfo(nickname="UltronSC", short_models=("a94", "a95"))
+    ULTRONSE = ProductInfo(nickname="UltronSE", short_models=("a124", "a125", "a139", "a140"))
+    ULTRONSPLUS = ProductInfo(nickname="UltronSPlus", short_models=("a68", "a69", "a70"))
+    ULTRONSV = ProductInfo(nickname="UltronSV", short_models=("a96", "a97"))
+
+    # Verdelite Series
+    VERDELITE = ProductInfo(nickname="Verdelite", short_models=("a146", "a147"))
+
+    # Vivian Series
+    VIVIAN = ProductInfo(nickname="Vivian", short_models=("a134", "a135", "a155", "a156"))
+    VIVIANC = ProductInfo(nickname="VivianC", short_models=("a158", "a159"))
+
+
+SHORT_MODEL_TO_ENUM = {model: product for product in RoborockProductNickname for model in product.value.short_models}
+
+
 class RoborockStateCode(RoborockEnum):
     unknown = 0
     starting = 1

{python_roborock-2.27.0 → python_roborock-2.28.0}/roborock/containers.py

@@ -11,6 +11,7 @@ from functools import cached_property
 from typing import Any, NamedTuple, get_args, get_origin
 
 from .code_mappings import (
+    SHORT_MODEL_TO_ENUM,
     RoborockCategory,
     RoborockCleanType,
     RoborockDockDustCollectionModeCode,
@@ -53,6 +54,7 @@ from .code_mappings import (
     RoborockMopModeS8ProUltra,
     RoborockMopModeSaros10,
     RoborockMopModeSaros10R,
+    RoborockProductNickname,
     RoborockStartType,
     RoborockStateCode,
 )
@@ -87,6 +89,7 @@ from .const import (
     STRAINER_REPLACE_TIME,
     ROBOROCK_G20S_Ultra,
 )
+from .device_features import DeviceFeatures
 from .exceptions import RoborockException
 
 _LOGGER = logging.getLogger(__name__)
@@ -306,144 +309,6 @@ class HomeDataDevice(RoborockBase):
     silent_ota_switch: bool | None = None
     setting: Any | None = None
     f: bool | None = None
-    device_features: DeviceFeatures | None = None
-
-    # seemingly not just str like I thought - example: '0000000000002000' and '0000000000002F63'
-
-    # def __post_init__(self):
-    #     if self.feature_set is not None and self.new_feature_set is not None and self.new_feature_set != "":
-    #         self.device_features = build_device_features(self.feature_set, self.new_feature_set)
-
-
-@dataclass
-class DeviceFeatures(RoborockBase):
-    map_carpet_add_supported: bool
-    show_clean_finish_reason_supported: bool
-    resegment_supported: bool
-    video_monitor_supported: bool
-    any_state_transit_goto_supported: bool
-    fw_filter_obstacle_supported: bool
-    video_setting_supported: bool
-    ignore_unknown_map_object_supported: bool
-    set_child_supported: bool
-    carpet_supported: bool
-    mop_path_supported: bool
-    multi_map_segment_timer_supported: bool
-    custom_water_box_distance_supported: bool
-    wash_then_charge_cmd_supported: bool
-    room_name_supported: bool
-    current_map_restore_enabled: bool
-    photo_upload_supported: bool
-    shake_mop_set_supported: bool
-    map_beautify_internal_debug_supported: bool
-    new_data_for_clean_history: bool
-    new_data_for_clean_history_detail: bool
-    flow_led_setting_supported: bool
-    dust_collection_setting_supported: bool
-    rpc_retry_supported: bool
-    avoid_collision_supported: bool
-    support_set_switch_map_mode: bool
-    support_smart_scene: bool
-    support_floor_edit: bool
-    support_furniture: bool
-    support_room_tag: bool
-    support_quick_map_builder: bool
-    support_smart_global_clean_with_custom_mode: bool
-    record_allowed: bool
-    careful_slow_map_supported: bool
-    egg_mode_supported: bool
-    unsave_map_reason_supported: bool
-    carpet_show_on_map: bool
-    supported_valley_electricity: bool
-    drying_supported: bool
-    download_test_voice_supported: bool
-    support_backup_map: bool
-    support_custom_mode_in_cleaning: bool
-    support_remote_control_in_call: bool
-    support_set_volume_in_call: bool
-    support_clean_estimate: bool
-    support_custom_dnd: bool
-    carpet_deep_clean_supported: bool
-    stuck_zone_supported: bool
-    custom_door_sill_supported: bool
-    clean_route_fast_mode_supported: bool
-    cliff_zone_supported: bool
-    smart_door_sill_supported: bool
-    support_floor_direction: bool
-    wifi_manage_supported: bool
-    back_charge_auto_wash_supported: bool
-    support_incremental_map: bool
-    offline_map_supported: bool
-
-
-def build_device_features(feature_set: str, new_feature_set: str) -> DeviceFeatures:
-    new_feature_set_int = int(new_feature_set)
-    feature_set_int = int(feature_set)
-    new_feature_set_divided = int(new_feature_set_int / (2**32))
-    # Convert last 8 digits of new feature set into hexadecimal number
-    converted_new_feature_set = int("0x" + new_feature_set[-8:], 16)
-    new_feature_set_mod_8: bool = len(new_feature_set) % 8 == 0
-    return DeviceFeatures(
-        map_carpet_add_supported=bool(1073741824 & new_feature_set_int),
-        show_clean_finish_reason_supported=bool(1 & new_feature_set_int),
-        resegment_supported=bool(4 & new_feature_set_int),
-        video_monitor_supported=bool(8 & new_feature_set_int),
-        any_state_transit_goto_supported=bool(16 & new_feature_set_int),
-        fw_filter_obstacle_supported=bool(32 & new_feature_set_int),
-        video_setting_supported=bool(64 & new_feature_set_int),
-        ignore_unknown_map_object_supported=bool(128 & new_feature_set_int),
-        set_child_supported=bool(256 & new_feature_set_int),
-        carpet_supported=bool(512 & new_feature_set_int),
-        mop_path_supported=bool(2048 & new_feature_set_int),
-        multi_map_segment_timer_supported=bool(feature_set_int and 4096 & new_feature_set_int),
-        custom_water_box_distance_supported=bool(new_feature_set_int and 2147483648 & new_feature_set_int),
-        wash_then_charge_cmd_supported=bool((new_feature_set_divided >> 5) & 1),
-        room_name_supported=bool(16384 & new_feature_set_int),
-        current_map_restore_enabled=bool(8192 & new_feature_set_int),
-        photo_upload_supported=bool(65536 & new_feature_set_int),
-        shake_mop_set_supported=bool(262144 & new_feature_set_int),
-        map_beautify_internal_debug_supported=bool(2097152 & new_feature_set_int),
-        new_data_for_clean_history=bool(4194304 & new_feature_set_int),
-        new_data_for_clean_history_detail=bool(8388608 & new_feature_set_int),
-        flow_led_setting_supported=bool(16777216 & new_feature_set_int),
-        dust_collection_setting_supported=bool(33554432 & new_feature_set_int),
-        rpc_retry_supported=bool(67108864 & new_feature_set_int),
-        avoid_collision_supported=bool(134217728 & new_feature_set_int),
-        support_set_switch_map_mode=bool(268435456 & new_feature_set_int),
-        support_smart_scene=bool(new_feature_set_divided & 2),
-        support_floor_edit=bool(new_feature_set_divided & 8),
-        support_furniture=bool((new_feature_set_divided >> 4) & 1),
-        support_room_tag=bool((new_feature_set_divided >> 6) & 1),
-        support_quick_map_builder=bool((new_feature_set_divided >> 7) & 1),
-        support_smart_global_clean_with_custom_mode=bool((new_feature_set_divided >> 8) & 1),
-        record_allowed=bool(1024 & new_feature_set_int),
-        careful_slow_map_supported=bool((new_feature_set_divided >> 9) & 1),
-        egg_mode_supported=bool((new_feature_set_divided >> 10) & 1),
-        unsave_map_reason_supported=bool((new_feature_set_divided >> 14) & 1),
-        carpet_show_on_map=bool((new_feature_set_divided >> 12) & 1),
-        supported_valley_electricity=bool((new_feature_set_divided >> 13) & 1),
-        # This one could actually be incorrect
-        # ((t.robotNewFeatures / 2 ** 32) >> 15) & 1 && (module422.DMM.isTopazSV_CE || 'cn' == t.deviceLocation));
-        drying_supported=bool((new_feature_set_divided >> 15) & 1),
-        download_test_voice_supported=bool((new_feature_set_divided >> 16) & 1),
-        support_backup_map=bool((new_feature_set_divided >> 17) & 1),
-        support_custom_mode_in_cleaning=bool((new_feature_set_divided >> 18) & 1),
-        support_remote_control_in_call=bool((new_feature_set_divided >> 19) & 1),
-        support_set_volume_in_call=new_feature_set_mod_8 and bool(1 & converted_new_feature_set),
-        support_clean_estimate=new_feature_set_mod_8 and bool(2 & converted_new_feature_set),
-        support_custom_dnd=new_feature_set_mod_8 and bool(4 & converted_new_feature_set),
-        carpet_deep_clean_supported=bool(8 & converted_new_feature_set),
-        stuck_zone_supported=new_feature_set_mod_8 and bool(16 & converted_new_feature_set),
-        custom_door_sill_supported=new_feature_set_mod_8 and bool(32 & converted_new_feature_set),
-        clean_route_fast_mode_supported=bool(256 & converted_new_feature_set),
-        cliff_zone_supported=new_feature_set_mod_8 and bool(512 & converted_new_feature_set),
-        smart_door_sill_supported=new_feature_set_mod_8 and bool(1024 & converted_new_feature_set),
-        support_floor_direction=new_feature_set_mod_8 and bool(2048 & converted_new_feature_set),
-        wifi_manage_supported=bool(128 & converted_new_feature_set),
-        back_charge_auto_wash_supported=bool(4096 & converted_new_feature_set),
-        support_incremental_map=bool(8192 & converted_new_feature_set),
-        offline_map_supported=bool(16384 & converted_new_feature_set),
-    )
 
 
 @dataclass
@@ -890,6 +755,11 @@ class DeviceData(RoborockBase):
     device: HomeDataDevice
     model: str
     host: str | None = None
+    product_nickname: RoborockProductNickname | None = None
+    device_features: DeviceFeatures | None = None
+
+    def __post_init__(self):
+        self.product_nickname = SHORT_MODEL_TO_ENUM.get(self.model.split(".")[-1], RoborockProductNickname.PEARLPLUS)
 
 
 @dataclass

python_roborock-2.28.0/roborock/device_features.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from enum import IntEnum
+from typing import Any
+
+from roborock import RoborockProductNickname
+
+
+class NewFeatureStrBit(IntEnum):
+    TWO_KEY_REAL_TIME_VIDEO = 32
+    TWO_KEY_RTV_IN_CHARGING = 33
+    DIRTY_REPLENISH_CLEAN = 34
+    AUTO_DELIVERY_FIELD_IN_GLOBAL_STATUS = 35
+    AVOID_COLLISION_MODE = 36
+    VOICE_CONTROL = 37
+    NEW_ENDPOINT = 38
+    PUMPING_WATER = 39
+    CORNER_MOP_STRETCH = 40
+    HOT_WASH_TOWEL = 41
+    FLOOR_DIR_CLEAN_ANY_TIME = 42
+    PET_SUPPLIES_DEEP_CLEAN = 43
+    MOP_SHAKE_WATER_MAX = 45
+    EXACT_CUSTOM_MODE = 47
+    VIDEO_PATROL = 48
+    CARPET_CUSTOM_CLEAN = 49
+    PET_SNAPSHOT = 50
+    CUSTOM_CLEAN_MODE_COUNT = 51
+    NEW_AI_RECOGNITION = 52
+    AUTO_COLLECTION_2 = 53
+    RIGHT_BRUSH_STRETCH = 54
+    SMART_CLEAN_MODE_SET = 55
+    DIRTY_OBJECT_DETECT = 56
+    NO_NEED_CARPET_PRESS_SET = 57
+    VOICE_CONTROL_LED = 58
+    WATER_LEAK_CHECK = 60
+    MIN_BATTERY_15_TO_CLEAN_TASK = 62
+    GAP_DEEP_CLEAN = 63
+    OBJECT_DETECT_CHECK = 64
+    IDENTIFY_ROOM = 66
+    MATTER = 67
+    WORKDAY_HOLIDAY = 69
+    CLEAN_DIRECT_STATUS = 70
+    MAP_ERASER = 71
+    OPTIMIZE_BATTERY = 72
+    ACTIVATE_VIDEO_CHARGING_AND_STANDBY = 73
+    CARPET_LONG_HAIRED = 75
+    CLEAN_HISTORY_TIME_LINE = 76
+    MAX_ZONE_OPENED = 77
+    EXHIBITION_FUNCTION = 78
+    LDS_LIFTING = 79
+    AUTO_TEAR_DOWN_MOP = 80
+    SMALL_SIDE_MOP = 81
+    SUPPORT_SIDE_BRUSH_UP_DOWN = 82
+    DRY_INTERVAL_TIMER = 83
+    UVC_STERILIZE = 84
+    MIDWAY_BACK_TO_DOCK = 85
+    SUPPORT_MAIN_BRUSH_UP_DOWN = 86
+    EGG_DANCE_MODE = 87
+
+
+@dataclass
+class DeviceFeatures:
+    """Represents the features supported by a Roborock device."""
+
+    # Features from robot_new_features (lower 32 bits)
+    is_show_clean_finish_reason_supported: bool = field(metadata={"robot_new_features": 1})
+    is_re_segment_supported: bool = field(metadata={"robot_new_features": 4})
+    is_video_monitor_supported: bool = field(metadata={"robot_new_features": 8})
+    is_any_state_transit_goto_supported: bool = field(metadata={"robot_new_features": 16})
+    is_fw_filter_obstacle_supported: bool = field(metadata={"robot_new_features": 32})
+    is_video_setting_supported: bool = field(metadata={"robot_new_features": 64})
+    is_ignore_unknown_map_object_supported: bool = field(metadata={"robot_new_features": 128})
+    is_set_child_supported: bool = field(metadata={"robot_new_features": 256})
+    is_carpet_supported: bool = field(metadata={"robot_new_features": 512})
+    is_record_allowed: bool = field(metadata={"robot_new_features": 1024})
+    is_mop_path_supported: bool = field(metadata={"robot_new_features": 2048})
+    is_multi_map_segment_timer_supported: bool = field(metadata={"robot_new_features": 4096})
+    is_current_map_restore_enabled: bool = field(metadata={"robot_new_features": 8192})
+    is_room_name_supported: bool = field(metadata={"robot_new_features": 16384})
+    is_shake_mop_set_supported: bool = field(metadata={"robot_new_features": 262144})
+    is_map_beautify_internal_debug_supported: bool = field(metadata={"robot_new_features": 2097152})
+    is_new_data_for_clean_history: bool = field(metadata={"robot_new_features": 4194304})
+    is_new_data_for_clean_history_detail: bool = field(metadata={"robot_new_features": 8388608})
+    is_flow_led_setting_supported: bool = field(metadata={"robot_new_features": 16777216})
+    is_dust_collection_setting_supported: bool = field(metadata={"robot_new_features": 33554432})
+    is_rpc_retry_supported: bool = field(metadata={"robot_new_features": 67108864})
+    is_avoid_collision_supported: bool = field(metadata={"robot_new_features": 134217728})
+    is_support_set_switch_map_mode: bool = field(metadata={"robot_new_features": 268435456})
+    is_map_carpet_add_support: bool = field(metadata={"robot_new_features": 1073741824})
+    is_custom_water_box_distance_supported: bool = field(metadata={"robot_new_features": 2147483648})
+
+    # Features from robot_new_features (upper 32 bits)
+    is_support_smart_scene: bool = field(metadata={"upper_32_bits": 1})
+    is_support_floor_edit: bool = field(metadata={"upper_32_bits": 3})
+    is_support_furniture: bool = field(metadata={"upper_32_bits": 4})
+    is_wash_then_charge_cmd_supported: bool = field(metadata={"upper_32_bits": 5})
+    is_support_room_tag: bool = field(metadata={"upper_32_bits": 6})
+    is_support_quick_map_builder: bool = field(metadata={"upper_32_bits": 7})
+    is_support_smart_global_clean_with_custom_mode: bool = field(metadata={"upper_32_bits": 8})
+    is_careful_slow_mop_supported: bool = field(metadata={"upper_32_bits": 9})
+    is_egg_mode_supported_from_new_features: bool = field(metadata={"upper_32_bits": 10})
+    is_carpet_show_on_map: bool = field(metadata={"upper_32_bits": 12})
+    is_supported_valley_electricity: bool = field(metadata={"upper_32_bits": 13})
+    is_unsave_map_reason_supported: bool = field(metadata={"upper_32_bits": 14})
+    is_supported_drying: bool = field(metadata={"upper_32_bits": 15})
+    is_supported_download_test_voice: bool = field(metadata={"upper_32_bits": 16})
+    is_support_backup_map: bool = field(metadata={"upper_32_bits": 17})
+    is_support_custom_mode_in_cleaning: bool = field(metadata={"upper_32_bits": 18})
+    is_support_remote_control_in_call: bool = field(metadata={"upper_32_bits": 19})
+
+    # Features from new_feature_info_str (masking last 8 chars / 32 bits)
+    is_support_set_volume_in_call: bool = field(metadata={"new_feature_str_mask": (1, 8)})
+    is_support_clean_estimate: bool = field(metadata={"new_feature_str_mask": (2, 8)})
+    is_support_custom_dnd: bool = field(metadata={"new_feature_str_mask": (4, 8)})
+    is_carpet_deep_clean_supported: bool = field(metadata={"new_feature_str_mask": (8, 8)})
+    is_support_stuck_zone: bool = field(metadata={"new_feature_str_mask": (16, 8)})
+    is_support_custom_door_sill: bool = field(metadata={"new_feature_str_mask": (32, 8)})
+    is_wifi_manage_supported: bool = field(metadata={"new_feature_str_mask": (128, 8)})
+    is_clean_route_fast_mode_supported: bool = field(metadata={"new_feature_str_mask": (256, 8)})
+    is_support_cliff_zone: bool = field(metadata={"new_feature_str_mask": (512, 8)})
+    is_support_smart_door_sill: bool = field(metadata={"new_feature_str_mask": (1024, 8)})
+    is_support_floor_direction: bool = field(metadata={"new_feature_str_mask": (2048, 8)})
+    is_back_charge_auto_wash_supported: bool = field(metadata={"new_feature_str_mask": (4096, 8)})
+    is_support_incremental_map: bool = field(metadata={"new_feature_str_mask": (4194304, 8)})
+    is_offline_map_supported: bool = field(metadata={"new_feature_str_mask": (16384, 8)})
+    is_super_deep_wash_supported: bool = field(metadata={"new_feature_str_mask": (32768, 8)})
+    is_ces2022_supported: bool = field(metadata={"new_feature_str_mask": (65536, 8)})
+    is_dss_believable: bool = field(metadata={"new_feature_str_mask": (131072, 8)})
+    is_main_brush_up_down_supported_from_str: bool = field(metadata={"new_feature_str_mask": (262144, 8)})
+    is_goto_pure_clean_path_supported: bool = field(metadata={"new_feature_str_mask": (524288, 8)})
+    is_water_up_down_drain_supported: bool = field(metadata={"new_feature_str_mask": (1048576, 8)})
+    is_setting_carpet_first_supported: bool = field(metadata={"new_feature_str_mask": (8388608, 8)})
+    is_clean_route_deep_slow_plus_supported: bool = field(metadata={"new_feature_str_mask": (16777216, 8)})
+    is_dynamically_skip_clean_zone_supported: bool = field(metadata={"new_feature_str_mask": (33554432, 8)})
+    is_dynamically_add_clean_zones_supported: bool = field(metadata={"new_feature_str_mask": (67108864, 8)})
+    is_left_water_drain_supported: bool = field(metadata={"new_feature_str_mask": (134217728, 8)})
+    is_clean_count_setting_supported: bool = field(metadata={"new_feature_str_mask": (1073741824, 8)})
+    is_corner_clean_mode_supported: bool = field(metadata={"new_feature_str_mask": (2147483648, 8)})
+
+    # Features from new_feature_info_str (by bit index)
+    is_two_key_real_time_video_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.TWO_KEY_REAL_TIME_VIDEO}
+    )
+    is_two_key_rtv_in_charging_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.TWO_KEY_RTV_IN_CHARGING}
+    )
+    is_dirty_replenish_clean_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.DIRTY_REPLENISH_CLEAN}
+    )
+    is_auto_delivery_field_in_global_status_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.AUTO_DELIVERY_FIELD_IN_GLOBAL_STATUS}
+    )
+    is_avoid_collision_mode_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.AVOID_COLLISION_MODE}
+    )
+    is_voice_control_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.VOICE_CONTROL})
+    is_new_endpoint_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.NEW_ENDPOINT})
+    is_pumping_water_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.PUMPING_WATER})
+    is_corner_mop_stretch_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.CORNER_MOP_STRETCH})
+    is_hot_wash_towel_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.HOT_WASH_TOWEL})
+    is_floor_dir_clean_any_time_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.FLOOR_DIR_CLEAN_ANY_TIME}
+    )
+    is_pet_supplies_deep_clean_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.PET_SUPPLIES_DEEP_CLEAN}
+    )
+    is_mop_shake_water_max_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.MOP_SHAKE_WATER_MAX}
+    )
+    is_exact_custom_mode_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.EXACT_CUSTOM_MODE})
+    is_video_patrol_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.VIDEO_PATROL})
+    is_carpet_custom_clean_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.CARPET_CUSTOM_CLEAN}
+    )
+    is_pet_snapshot_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.PET_SNAPSHOT})
+    is_custom_clean_mode_count_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.CUSTOM_CLEAN_MODE_COUNT}
+    )
+    is_new_ai_recognition_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.NEW_AI_RECOGNITION})
+    is_auto_collection_2_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.AUTO_COLLECTION_2})
+    is_right_brush_stretch_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.RIGHT_BRUSH_STRETCH}
+    )
+    is_smart_clean_mode_set_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.SMART_CLEAN_MODE_SET}
+    )
+    is_dirty_object_detect_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.DIRTY_OBJECT_DETECT}
+    )
+    is_no_need_carpet_press_set_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.NO_NEED_CARPET_PRESS_SET}
+    )
+    is_voice_control_led_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.VOICE_CONTROL_LED})
+    is_water_leak_check_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.WATER_LEAK_CHECK})
+    is_min_battery_15_to_clean_task_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.MIN_BATTERY_15_TO_CLEAN_TASK}
+    )
+    is_gap_deep_clean_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.GAP_DEEP_CLEAN})
+    is_object_detect_check_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.OBJECT_DETECT_CHECK}
+    )
+    is_identify_room_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.IDENTIFY_ROOM})
+    is_matter_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.MATTER})
+    is_workday_holiday_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.WORKDAY_HOLIDAY})
+    is_clean_direct_status_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.CLEAN_DIRECT_STATUS}
+    )
+    is_map_eraser_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.MAP_ERASER})
+    is_optimize_battery_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.OPTIMIZE_BATTERY})
+    is_activate_video_charging_and_standby_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.ACTIVATE_VIDEO_CHARGING_AND_STANDBY}
+    )
+    is_carpet_long_haired_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.CARPET_LONG_HAIRED})
+    is_clean_history_time_line_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.CLEAN_HISTORY_TIME_LINE}
+    )
+    is_max_zone_opened_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.MAX_ZONE_OPENED})
+    is_exhibition_function_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.EXHIBITION_FUNCTION}
+    )
+    is_lds_lifting_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.LDS_LIFTING})
+    is_auto_tear_down_mop_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.AUTO_TEAR_DOWN_MOP})
+    is_small_side_mop_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.SMALL_SIDE_MOP})
+    is_support_side_brush_up_down_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.SUPPORT_SIDE_BRUSH_UP_DOWN}
+    )
+    is_dry_interval_timer_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.DRY_INTERVAL_TIMER})
+    is_uvc_sterilize_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.UVC_STERILIZE})
+    is_midway_back_to_dock_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.MIDWAY_BACK_TO_DOCK}
+    )
+    is_support_main_brush_up_down_supported: bool = field(
+        metadata={"new_feature_str_bit": NewFeatureStrBit.SUPPORT_MAIN_BRUSH_UP_DOWN}
+    )
+    is_egg_dance_mode_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.EGG_DANCE_MODE})
+
+    # Features from feature_info list
+    is_led_status_switch_supported: bool = field(metadata={"robot_features": 119})
+    is_multi_floor_supported: bool = field(metadata={"robot_features": 120})
+    is_support_fetch_timer_summary: bool = field(metadata={"robot_features": 122})
+    is_order_clean_supported: bool = field(metadata={"robot_features": 123})
+    is_analysis_supported: bool = field(metadata={"robot_features": 124})
+    is_remote_supported: bool = field(metadata={"robot_features": 125})
+    is_support_voice_control_debug: bool = field(metadata={"robot_features": 130})
+
+    # Features from model whitelists/blacklists or other flags
+    is_mop_forbidden_supported: bool = field(
+        metadata={
+            "model_whitelist": [
+                RoborockProductNickname.TANOSV,
+                RoborockProductNickname.TOPAZSV,
+                RoborockProductNickname.TANOS,
+                RoborockProductNickname.TANOSE,
+                RoborockProductNickname.TANOSSLITE,
+                RoborockProductNickname.TANOSS,
+                RoborockProductNickname.TANOSSPLUS,
+                RoborockProductNickname.TANOSSMAX,
+                RoborockProductNickname.ULTRON,
+                RoborockProductNickname.ULTRONLITE,
+                RoborockProductNickname.PEARL,
+                RoborockProductNickname.RUBYSLITE,
+            ]
+        }
+    )
+    is_soft_clean_mode_supported: bool = field(
+        metadata={
+            "model_whitelist": [
+                RoborockProductNickname.TANOSV,
+                RoborockProductNickname.TANOSE,
+                RoborockProductNickname.TANOS,
+            ]
+        }
+    )
+    is_custom_mode_supported: bool = field(metadata={"model_blacklist": [RoborockProductNickname.TANOS]})
+    is_support_custom_carpet: bool = field(metadata={"model_whitelist": [RoborockProductNickname.ULTRONLITE]})
+    is_show_general_obstacle_supported: bool = field(metadata={"model_whitelist": [RoborockProductNickname.TANOSSPLUS]})
+    is_show_obstacle_photo_supported: bool = field(
+        metadata={
+            "model_whitelist": [
+                RoborockProductNickname.TANOSSPLUS,
+                RoborockProductNickname.TANOSSMAX,
+                RoborockProductNickname.ULTRON,
+            ]
+        }
+    )
+    is_rubber_brush_carpet_supported: bool = field(metadata={"model_whitelist": [RoborockProductNickname.ULTRONLITE]})
+    is_carpet_pressure_use_origin_paras_supported: bool = field(
+        metadata={"model_whitelist": [RoborockProductNickname.ULTRONLITE]}
+    )
+    is_support_mop_back_pwm_set: bool = field(metadata={"model_whitelist": [RoborockProductNickname.PEARL]})
+    is_collect_dust_mode_supported: bool = field(metadata={"model_blacklist": [RoborockProductNickname.PEARL]})
+
+    @classmethod
+    def from_feature_flags(
+        cls,
+        new_feature_info: int,
+        new_feature_info_str: str,
+        feature_info: list[int],
+        product_nickname: RoborockProductNickname | None,
+    ) -> DeviceFeatures:
+        """Creates a DeviceFeatures instance from raw feature flags.
+        :param new_feature_info: A int from get_init_status (sometimes can be found in homedata, but it is not always)
+        :param new_feature_info_str: A hex string from get_init_status or home_data.
+        :param feature_info: A list of ints from get_init_status
+        :param product_nickname: The product nickname of the device."""
+        # For any future reverse engineerining:
+        # RobotNewFeatures = new_feature_info
+        # newFeatureInfoStr = new_feature_info_str
+        # feature_info =robotFeatures
+        kwargs: dict[str, Any] = {}
+
+        for f in fields(cls):
+            # Default all features to False.
+            kwargs[f.name] = False
+            if not f.metadata:
+                continue
+
+            if (mask := f.metadata.get("robot_new_features")) is not None:
+                kwargs[f.name] = bool(mask & new_feature_info)
+            elif (bit_index := f.metadata.get("upper_32_bits")) is not None:
+                # Check bits in the upper 32-bit integer of new_feature_info
+                if new_feature_info:
+                    kwargs[f.name] = bool(((new_feature_info >> 32) >> bit_index) & 1)
+            elif (mask_info := f.metadata.get("new_feature_str_mask")) is not None:
+                # Check bitmask against a slice of the hex string
+                if new_feature_info_str:
+                    try:
+                        mask, slice_count = mask_info
+                        if len(new_feature_info_str) >= slice_count:
+                            last_chars = new_feature_info_str[-slice_count:]
+                            value = int(last_chars, 16)
+                            kwargs[f.name] = bool(mask & value)
+                    except (ValueError, IndexError):
+                        pass  # Keep it False
+            elif (bit := f.metadata.get("new_feature_str_bit")) is not None:
+                # Check a specific bit in the hex string using its index
+                if new_feature_info_str:
+                    try:
+                        # Bit index defines which character and which bit inside it to check
+                        char_index_from_end = 1 + bit.value // 4
+                        if char_index_from_end <= len(new_feature_info_str):
+                            char_hex = new_feature_info_str[-char_index_from_end]
+                            nibble = int(char_hex, 16)
+                            bit_in_nibble = bit.value % 4
+                            kwargs[f.name] = bool((nibble >> bit_in_nibble) & 1)
+                    except (ValueError, IndexError):
+                        pass  # Keep it False
+            elif (feature_id := f.metadata.get("robot_features")) is not None:
+                kwargs[f.name] = feature_id in feature_info
+            elif (whitelist := f.metadata.get("model_whitelist")) is not None:
+                # If product_nickname is None, assume it is not in the whitelist
+                kwargs[f.name] = product_nickname in whitelist or product_nickname is None
+            elif (blacklist := f.metadata.get("model_blacklist")) is not None:
+                # If product_nickname is None, assume it is not in the blacklist.
+                if product_nickname is None:
+                    kwargs[f.name] = True
+                else:
+                    kwargs[f.name] = product_nickname not in blacklist
+
+        return cls(**kwargs)
+
+    def get_supported_features(self) -> list[str]:
+        """Returns a list of supported features (Primarily used for logging purposes)."""
+        return [k for k, v in vars(self).items() if v]

{python_roborock-2.27.0 → python_roborock-2.28.0}/roborock/devices/device.py

@@ -117,4 +117,4 @@ class RoborockDevice:
         This is a placeholder command and will likely be changed/moved in the future.
         """
         status_type: type[Status] = ModelStatus.get(self._product_info.model, S7MaxVStatus)
-        return await self._v1_channel.send_decoded_command(RoborockCommand.GET_STATUS, response_type=status_type)
+        return await self._v1_channel.rpc_channel.send_command(RoborockCommand.GET_STATUS, response_type=status_type)

{python_roborock-2.27.0 → python_roborock-2.28.0}/roborock/devices/local_channel.py

@@ -50,6 +50,11 @@ class LocalChannel:
         self._encoder: Encoder = create_local_encoder(local_key)
         self._queue_lock = asyncio.Lock()
 
+    @property
+    def is_connected(self) -> bool:
+        """Check if the channel is currently connected."""
+        return self._is_connected
+
     async def connect(self) -> None:
         """Connect to the device."""
         if self._is_connected:
@@ -113,7 +118,7 @@ class LocalChannel:
             else:
                 _LOGGER.debug("Received message with no waiting handler: request_id=%s", request_id)
 
-    async def send_command(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
+    async def send_message(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
         """Send a command message and wait for the response message."""
         if not self._transport or not self._is_connected:
             raise RoborockConnectionException("Not connected to device")

{python_roborock-2.27.0 → python_roborock-2.28.0}/roborock/devices/mqtt_channel.py

@@ -80,7 +80,7 @@ class MqttChannel:
             else:
                 _LOGGER.debug("Received message with no waiting handler: request_id=%s", request_id)
 
-    async def send_command(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
+    async def send_message(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
         """Send a command message and wait for the response message.
 
         Returns the raw response message - caller is responsible for parsing.

{python_roborock-2.27.0 → python_roborock-2.28.0}/roborock/devices/v1_channel.py

@@ -6,25 +6,21 @@ handling both MQTT and local connections with automatic fallback.
 
 import logging
 from collections.abc import Callable
-from typing import Any, TypeVar
+from typing import TypeVar
 
 from roborock.containers import HomeDataDevice, NetworkInfo, RoborockBase, UserData
 from roborock.exceptions import RoborockException
 from roborock.mqtt.session import MqttParams, MqttSession
 from roborock.protocols.v1_protocol import (
-    CommandType,
-    ParamsType,
     SecurityData,
-    create_mqtt_payload_encoder,
     create_security_data,
-    decode_rpc_response,
-    encode_local_payload,
 )
 from roborock.roborock_message import RoborockMessage
 from roborock.roborock_typing import RoborockCommand
 
 from .local_channel import LocalChannel, LocalSession, create_local_session
 from .mqtt_channel import MqttChannel
+from .v1_rpc_channel import V1RpcChannel, create_combined_rpc_channel, create_mqtt_rpc_channel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -58,9 +54,10 @@ class V1Channel:
         """
         self._device_uid = device_uid
         self._mqtt_channel = mqtt_channel
-        self._mqtt_payload_encoder = create_mqtt_payload_encoder(security_data)
+        self._mqtt_rpc_channel = create_mqtt_rpc_channel(mqtt_channel, security_data)
         self._local_session = local_session
         self._local_channel: LocalChannel | None = None
+        self._combined_rpc_channel: V1RpcChannel | None = None
         self._mqtt_unsub: Callable[[], None] | None = None
         self._local_unsub: Callable[[], None] | None = None
         self._callback: Callable[[RoborockMessage], None] | None = None
@@ -76,6 +73,16 @@ class V1Channel:
         """Return whether MQTT connection is available."""
         return self._mqtt_unsub is not None
 
+    @property
+    def rpc_channel(self) -> V1RpcChannel:
+        """Return the combined RPC channel prefers local with a fallback to MQTT."""
+        return self._combined_rpc_channel or self._mqtt_rpc_channel
+
+    @property
+    def mqtt_rpc_channel(self) -> V1RpcChannel:
+        """Return the MQTT RPC channel."""
+        return self._mqtt_rpc_channel
+
     async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
         """Subscribe to all messages from the device.
 
@@ -119,7 +126,9 @@ class V1Channel:
         This is a cloud only command used to get the local device's IP address.
         """
         try:
-            return await self._send_mqtt_decoded_command(RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo)
+            return await self._mqtt_rpc_channel.send_command(
+                RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo
+            )
         except RoborockException as e:
             raise RoborockException(f"Network info failed for device {self._device_uid}") from e
 
@@ -136,59 +145,9 @@ class V1Channel:
         except RoborockException as e:
             self._local_channel = None
             raise RoborockException(f"Error connecting to local device {self._device_uid}: {e}") from e
-
+        self._combined_rpc_channel = create_combined_rpc_channel(self._local_channel, self._mqtt_rpc_channel)
         return await self._local_channel.subscribe(self._on_local_message)
 
-    async def send_decoded_command(
-        self,
-        method: CommandType,
-        *,
-        response_type: type[_T],
-        params: ParamsType = None,
-    ) -> _T:
-        """Send a command using the best available transport.
-
-        Will prefer local connection if available, falling back to MQTT.
-        """
-        connection = "local" if self.is_local_connected else "mqtt"
-        _LOGGER.debug("Sending command (%s): %s, params=%s", connection, method, params)
-        if self._local_channel:
-            return await self._send_local_decoded_command(method, response_type=response_type, params=params)
-        return await self._send_mqtt_decoded_command(method, response_type=response_type, params=params)
-
-    async def _send_mqtt_raw_command(self, method: CommandType, params: ParamsType | None = None) -> dict[str, Any]:
-        """Send a raw command and return a raw unparsed response."""
-        message = self._mqtt_payload_encoder(method, params)
-        _LOGGER.debug("Sending MQTT message for device %s: %s", self._device_uid, message)
-        response = await self._mqtt_channel.send_command(message)
-        return decode_rpc_response(response)
-
-    async def _send_mqtt_decoded_command(
-        self, method: CommandType, *, response_type: type[_T], params: ParamsType | None = None
-    ) -> _T:
-        """Send a command over MQTT and decode the response."""
-        decoded_response = await self._send_mqtt_raw_command(method, params)
-        return response_type.from_dict(decoded_response)
-
-    async def _send_local_raw_command(self, method: CommandType, params: ParamsType | None = None) -> dict[str, Any]:
-        """Send a raw command over local connection."""
-        if not self._local_channel:
-            raise RoborockException("Local channel is not connected")
-
-        message = encode_local_payload(method, params)
-        _LOGGER.debug("Sending local message for device %s: %s", self._device_uid, message)
-        response = await self._local_channel.send_command(message)
-        return decode_rpc_response(response)
-
-    async def _send_local_decoded_command(
-        self, method: CommandType, *, response_type: type[_T], params: ParamsType | None = None
-    ) -> _T:
-        """Send a command over local connection and decode the response."""
-        if not self._local_channel:
-            raise RoborockException("Local channel is not connected")
-        decoded_response = await self._send_local_raw_command(method, params)
-        return response_type.from_dict(decoded_response)
-
     def _on_mqtt_message(self, message: RoborockMessage) -> None:
         """Handle incoming MQTT messages."""
         _LOGGER.debug("V1Channel received MQTT message from device %s: %s", self._device_uid, message)

python_roborock-2.28.0/roborock/devices/v1_rpc_channel.py

@@ -0,0 +1,148 @@
+"""V1 Rpc Channel for Roborock devices.
+
+This is a wrapper around the V1 channel that provides a higher level interface
+for sending typed commands and receiving typed responses. This also provides
+a simple interface for sending commands and receiving responses over both MQTT
+and local connections, preferring local when available.
+"""
+
+import logging
+from collections.abc import Callable
+from typing import Any, Protocol, TypeVar, overload
+
+from roborock.containers import RoborockBase
+from roborock.protocols.v1_protocol import (
+    CommandType,
+    ParamsType,
+    SecurityData,
+    create_mqtt_payload_encoder,
+    decode_rpc_response,
+    encode_local_payload,
+)
+from roborock.roborock_message import RoborockMessage
+
+from .local_channel import LocalChannel
+from .mqtt_channel import MqttChannel
+
+_LOGGER = logging.getLogger(__name__)
+
+
+_T = TypeVar("_T", bound=RoborockBase)
+
+
+class V1RpcChannel(Protocol):
+    """Protocol for V1 RPC channels.
+
+    This is a wrapper around a raw channel that provides a high-level interface
+    for sending commands and receiving responses.
+    """
+
+    @overload
+    async def send_command(
+        self,
+        method: CommandType,
+        *,
+        params: ParamsType = None,
+    ) -> Any:
+        """Send a command and return a decoded response."""
+        ...
+
+    @overload
+    async def send_command(
+        self,
+        method: CommandType,
+        *,
+        response_type: type[_T],
+        params: ParamsType = None,
+    ) -> _T:
+        """Send a command and return a parsed response RoborockBase type."""
+        ...
+
+
+class BaseV1RpcChannel(V1RpcChannel):
+    """Base implementation that provides the typed response logic."""
+
+    async def send_command(
+        self,
+        method: CommandType,
+        *,
+        response_type: type[_T] | None = None,
+        params: ParamsType = None,
+    ) -> _T | Any:
+        """Send a command and return either a decoded or parsed response."""
+        decoded_response = await self._send_raw_command(method, params=params)
+
+        if response_type is not None:
+            return response_type.from_dict(decoded_response)
+        return decoded_response
+
+    async def _send_raw_command(
+        self,
+        method: CommandType,
+        *,
+        params: ParamsType = None,
+    ) -> Any:
+        """Send a raw command and return the decoded response. Must be implemented by subclasses."""
+        raise NotImplementedError
+
+
+class CombinedV1RpcChannel(BaseV1RpcChannel):
+    """A V1 RPC channel that can use both local and MQTT channels, preferring local when available."""
+
+    def __init__(
+        self, local_channel: LocalChannel, local_rpc_channel: V1RpcChannel, mqtt_channel: V1RpcChannel
+    ) -> None:
+        """Initialize the combined channel with local and MQTT channels."""
+        self._local_channel = local_channel
+        self._local_rpc_channel = local_rpc_channel
+        self._mqtt_rpc_channel = mqtt_channel
+
+    async def _send_raw_command(
+        self,
+        method: CommandType,
+        *,
+        params: ParamsType = None,
+    ) -> Any:
+        """Send a command and return a parsed response RoborockBase type."""
+        if self._local_channel.is_connected:
+            return await self._local_rpc_channel.send_command(method, params=params)
+        return await self._mqtt_rpc_channel.send_command(method, params=params)
+
+
+class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
+    """Protocol for V1 channels that send encoded commands."""
+
+    def __init__(
+        self,
+        name: str,
+        channel: MqttChannel | LocalChannel,
+        payload_encoder: Callable[[CommandType, ParamsType], RoborockMessage],
+    ) -> None:
+        """Initialize the channel with a raw channel and an encoder function."""
+        self._name = name
+        self._channel = channel
+        self._payload_encoder = payload_encoder
+
+    async def _send_raw_command(
+        self,
+        method: CommandType,
+        *,
+        params: ParamsType = None,
+    ) -> Any:
+        """Send a command and return a parsed response RoborockBase type."""
+        _LOGGER.debug("Sending command (%s): %s, params=%s", self._name, method, params)
+        message = self._payload_encoder(method, params)
+        response = await self._channel.send_message(message)
+        return decode_rpc_response(response)
+
+
+def create_mqtt_rpc_channel(mqtt_channel: MqttChannel, security_data: SecurityData) -> V1RpcChannel:
+    """Create a V1 RPC channel using an MQTT channel."""
+    payload_encoder = create_mqtt_payload_encoder(security_data)
+    return PayloadEncodedV1RpcChannel("mqtt", mqtt_channel, payload_encoder)
+
+
+def create_combined_rpc_channel(local_channel: LocalChannel, mqtt_rpc_channel: V1RpcChannel) -> V1RpcChannel:
+    """Create a V1 RPC channel that combines local and MQTT channels."""
+    local_rpc_channel = PayloadEncodedV1RpcChannel("local", local_channel, encode_local_payload)
+    return CombinedV1RpcChannel(local_channel, local_rpc_channel, mqtt_rpc_channel)