From 7263e09692c7e7347c5dcbed46c94d8d4fee4878 Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 17 Sep 2023 19:40:54 +0800 Subject: [PATCH] v0.0.5 --- .gitignore | 4 +- .../midea_meiju_codec/__init__.py | 143 ++++- .../midea_meiju_codec/config_flow.py | 263 +++++--- custom_components/midea_meiju_codec/const.py | 6 + .../midea_meiju_codec/core/cloud.py | 581 +++++++++++++----- .../midea_meiju_codec/core/device.py | 193 +++--- .../midea_meiju_codec/core/discover.py | 2 + .../midea_meiju_codec/core/lua_runtime.py | 11 +- .../midea_meiju_codec/core/security.py | 155 +++-- .../midea_meiju_codec/device_mapping/T0xAC.py | 97 +-- .../midea_meiju_codec/device_mapping/T0xEA.py | 177 ++++++ .../device_mapping/example.py | 267 ++++++++ .../midea_meiju_codec/midea_entities.py | 9 +- .../midea_meiju_codec/services.yaml | 18 + .../midea_meiju_codec/translations/en.json | 103 +++- .../translations/zh-Hans.json | 75 ++- 16 files changed, 1595 insertions(+), 509 deletions(-) create mode 100644 custom_components/midea_meiju_codec/device_mapping/T0xEA.py create mode 100644 custom_components/midea_meiju_codec/device_mapping/example.py create mode 100644 custom_components/midea_meiju_codec/services.yaml diff --git a/.gitignore b/.gitignore index f8d4d12..16374db 100644 --- a/.gitignore +++ b/.gitignore @@ -154,4 +154,6 @@ cython_debug/ .idea test.py -*.lua \ No newline at end of file +*.lua + +time.py \ No newline at end of file diff --git a/custom_components/midea_meiju_codec/__init__.py b/custom_components/midea_meiju_codec/__init__.py index 2fd345c..919dad6 100644 --- a/custom_components/midea_meiju_codec/__init__.py +++ b/custom_components/midea_meiju_codec/__init__.py @@ -1,5 +1,6 @@ import os import base64 +import voluptuous as vol from importlib import import_module from homeassistant.config_entries import ConfigEntry from homeassistant.util.json import load_json @@ -8,7 +9,10 @@ try: except ImportError: from homeassistant.util.json import save_json from homeassistant.helpers.typing import ConfigType -from homeassistant.core import HomeAssistant +from homeassistant.core import ( + HomeAssistant, + ServiceCall +) from homeassistant.const import ( Platform, CONF_TYPE, @@ -27,9 +31,14 @@ from .core.device import MiedaDevice from .const import ( DOMAIN, DEVICES, + CONF_REFRESH_INTERVAL, CONFIG_PATH, CONF_KEY, CONF_ACCOUNT, + CONF_SN8, + CONF_SN, + CONF_MODEL_NUMBER, + CONF_LUA_FILE ) ALL_PLATFORM = [ @@ -82,8 +91,71 @@ def load_device_config(hass: HomeAssistant, device_type, sn8): return json_data +def register_services(hass: HomeAssistant): + + async def async_set_attributes(service: ServiceCall): + device_id = service.data.get("device_id") + attributes = service.data.get("attributes") + MideaLogger.debug(f"Service called: set_attributes, device_id: {device_id}, attributes: {attributes}") + try: + device: MiedaDevice = hass.data[DOMAIN][DEVICES][device_id].get(CONF_DEVICE) + except KeyError: + MideaLogger.error(f"Failed to call service set_attributes: the device {device_id} isn't exist.") + return + if device: + device.set_attributes(attributes) + + async def async_send_command(service: ServiceCall): + device_id = service.data.get("device_id") + cmd_type = service.data.get("cmd_type") + cmd_body = service.data.get("cmd_body") + try: + cmd_body = bytearray.fromhex(cmd_body) + except ValueError: + MideaLogger.error(f"Failed to call service set_attributes: invalid cmd_body, a hexadecimal string required") + return + try: + device: MiedaDevice = hass.data[DOMAIN][DEVICES][device_id].get(CONF_DEVICE) + except KeyError: + MideaLogger.error(f"Failed to call service set_attributes: the device {device_id} isn't exist.") + return + if device: + device.send_command(cmd_type, cmd_body) + + hass.services.async_register( + DOMAIN, + "set_attributes", + async_set_attributes, + schema=vol.Schema({ + vol.Required("device_id"): vol.Coerce(int), + vol.Required("attributes"): vol.Any(dict) + }) + ) + hass.services.async_register( + DOMAIN, "send_command", async_send_command, + schema=vol.Schema({ + vol.Required("device_id"): vol.Coerce(int), + vol.Required("cmd_type"): vol.In([2, 3]), + vol.Required("cmd_body"): str + }) + ) + + async def update_listener(hass: HomeAssistant, config_entry: ConfigEntry): - pass + device_id = config_entry.data.get(CONF_DEVICE_ID) + if device_id is not None: + ip_address = config_entry.options.get( + CONF_IP_ADDRESS, None + ) + refresh_interval = config_entry.options.get( + CONF_REFRESH_INTERVAL, None + ) + device: MiedaDevice = hass.data[DOMAIN][DEVICES][device_id][CONF_DEVICE] + if device: + if ip_address is not None: + device.set_ip_address(ip_address) + if refresh_interval is not None: + device.set_refresh_interval(refresh_interval) async def async_setup(hass: HomeAssistant, config: ConfigType): @@ -100,6 +172,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType): bit_lua = base64.b64decode(BIT_LUA.encode("utf-8")).decode("utf-8") with open(bit, "wt") as fp: fp.write(bit_lua) + + register_services(hass) return True @@ -115,13 +189,14 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry): ip_address = config_entry.options.get(CONF_IP_ADDRESS, None) if not ip_address: ip_address = config_entry.data.get(CONF_IP_ADDRESS) + refresh_interval = config_entry.options.get(CONF_REFRESH_INTERVAL) port = config_entry.data.get(CONF_PORT) model = config_entry.data.get(CONF_MODEL) protocol = config_entry.data.get(CONF_PROTOCOL) - subtype = config_entry.data.get("subtype") - sn = config_entry.data.get("sn") - sn8 = config_entry.data.get("sn8") - lua_file = config_entry.data.get("lua_file") + subtype = config_entry.data.get(CONF_MODEL_NUMBER) + sn = config_entry.data.get(CONF_SN) + sn8 = config_entry.data.get(CONF_SN8) + lua_file = config_entry.data.get(CONF_LUA_FILE) if protocol == 3 and (key is None or key is None): MideaLogger.error("For V3 devices, the key and the token is required.") return False @@ -140,37 +215,41 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry): sn8=sn8, lua_file=lua_file, ) - if device: - device.open() - if DOMAIN not in hass.data: - hass.data[DOMAIN] = {} - if DEVICES not in hass.data[DOMAIN]: - hass.data[DOMAIN][DEVICES] = {} - hass.data[DOMAIN][DEVICES][device_id] = {} - hass.data[DOMAIN][DEVICES][device_id][CONF_DEVICE] = device - hass.data[DOMAIN][DEVICES][device_id][CONF_ENTITIES] = {} - config = load_device_config(hass, device_type, sn8) - if config is not None and len(config) > 0: - queries = config.get("queries") - if queries is not None and isinstance(queries, list): - device.queries = queries - centralized = config.get("centralized") - if centralized is not None and isinstance(centralized, list): - device.centralized = centralized - hass.data[DOMAIN][DEVICES][device_id]["manufacturer"] = config.get("manufacturer") - hass.data[DOMAIN][DEVICES][device_id][CONF_ENTITIES] = config.get(CONF_ENTITIES) - for platform in ALL_PLATFORM: - hass.async_create_task(hass.config_entries.async_forward_entry_setup( - config_entry, platform)) - config_entry.add_update_listener(update_listener) - return True - return False + if refresh_interval is not None: + device.set_refresh_interval(refresh_interval) + device.open() + if DOMAIN not in hass.data: + hass.data[DOMAIN] = {} + if DEVICES not in hass.data[DOMAIN]: + hass.data[DOMAIN][DEVICES] = {} + hass.data[DOMAIN][DEVICES][device_id] = {} + hass.data[DOMAIN][DEVICES][device_id][CONF_DEVICE] = device + hass.data[DOMAIN][DEVICES][device_id][CONF_ENTITIES] = {} + config = load_device_config(hass, device_type, sn8) + if config is not None and len(config) > 0: + queries = config.get("queries") + if queries is not None and isinstance(queries, list): + device.set_queries(queries) + centralized = config.get("centralized") + if centralized is not None and isinstance(centralized, list): + device.set_centralized(centralized) + calculate = config.get("calculate") + if calculate is not None and isinstance(calculate, dict): + device.set_calculate(calculate) + hass.data[DOMAIN][DEVICES][device_id]["manufacturer"] = config.get("manufacturer") + hass.data[DOMAIN][DEVICES][device_id]["rationale"] = config.get("rationale") + hass.data[DOMAIN][DEVICES][device_id][CONF_ENTITIES] = config.get(CONF_ENTITIES) + for platform in ALL_PLATFORM: + hass.async_create_task(hass.config_entries.async_forward_entry_setup( + config_entry, platform)) + config_entry.add_update_listener(update_listener) + return True async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry): device_id = config_entry.data.get(CONF_DEVICE_ID) if device_id is not None: - device = hass.data[DOMAIN][DEVICES][device_id][CONF_DEVICE] + device: MiedaDevice = hass.data[DOMAIN][DEVICES][device_id][CONF_DEVICE] if device is not None: if get_sn8_used(hass, device.sn8) == 1: lua_file = config_entry.data.get("lua_file") diff --git a/custom_components/midea_meiju_codec/config_flow.py b/custom_components/midea_meiju_codec/config_flow.py index 5b4c8f8..536f884 100644 --- a/custom_components/midea_meiju_codec/config_flow.py +++ b/custom_components/midea_meiju_codec/config_flow.py @@ -4,11 +4,10 @@ import os import ipaddress from homeassistant.helpers.aiohttp_client import async_create_clientsession from homeassistant import config_entries +from homeassistant.core import callback from homeassistant.const import ( CONF_TYPE, - CONF_USERNAME, CONF_PASSWORD, - CONF_DEVICE, CONF_PORT, CONF_MODEL, CONF_IP_ADDRESS, @@ -17,19 +16,31 @@ from homeassistant.const import ( CONF_TOKEN, CONF_NAME ) -from .core.cloud import MeijuCloudExtend +from . import remove_device_config, load_device_config +from .core.cloud import get_midea_cloud from .core.discover import discover from .core.device import MiedaDevice from .const import ( DOMAIN, + CONF_REFRESH_INTERVAL, STORAGE_PATH, CONF_ACCOUNT, + CONF_SERVER, CONF_HOME, - CONF_KEY + CONF_KEY, + CONF_SN8, + CONF_SN, + CONF_MODEL_NUMBER, + CONF_LUA_FILE ) _LOGGER = logging.getLogger(__name__) +servers = { + 1: "MSmartHome", + 2: "美的美居", +} + class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): _session = None @@ -38,11 +49,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): _device_list = {} _device = None + @staticmethod + @callback + def async_get_options_flow(config_entry): + return OptionsFlowHandler(config_entry) + def _get_configured_account(self): for entry in self._async_current_entries(): if entry.data.get(CONF_TYPE) == CONF_ACCOUNT: - return entry.data.get(CONF_USERNAME), entry.data.get(CONF_PASSWORD) - return None, None + return entry.data.get(CONF_ACCOUNT), entry.data.get(CONF_PASSWORD), entry.data.get(CONF_SERVER) + return None, None, None def _device_configured(self, device_id): for entry in self._async_current_entries(): @@ -61,24 +77,35 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): async def async_step_user(self, user_input=None, error=None): if self._session is None: self._session = async_create_clientsession(self.hass) - username, password = self._get_configured_account() - if username is not None and password is not None: + account, password, server = self._get_configured_account() + if account is not None and password is not None: if self._cloud is None: - self._cloud = MeijuCloudExtend(self._session, username, password) + self._cloud = get_midea_cloud( + session=self._session, + cloud_name=servers[server], + account=account, + password=password + ) if await self._cloud.login(): return await self.async_step_home() else: return await self.async_step_user(error="account_invalid") if user_input is not None: if self._cloud is None: - self._cloud = MeijuCloudExtend(self._session, user_input[CONF_USERNAME], user_input[CONF_PASSWORD]) + self._cloud = get_midea_cloud( + session=self._session, + cloud_name=servers[user_input[CONF_SERVER]], + account=user_input[CONF_ACCOUNT], + password=user_input[CONF_PASSWORD] + ) if await self._cloud.login(): return self.async_create_entry( - title=f"{user_input[CONF_USERNAME]}", + title=f"{user_input[CONF_ACCOUNT]}", data={ CONF_TYPE: CONF_ACCOUNT, - CONF_USERNAME: user_input[CONF_USERNAME], - CONF_PASSWORD: user_input[CONF_PASSWORD] + CONF_ACCOUNT: user_input[CONF_ACCOUNT], + CONF_PASSWORD: user_input[CONF_PASSWORD], + CONF_SERVER: user_input[CONF_SERVER] }) else: self._cloud = None @@ -86,8 +113,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): return self.async_show_form( step_id="user", data_schema=vol.Schema({ - vol.Required(CONF_USERNAME): str, - vol.Required(CONF_PASSWORD): str + vol.Required(CONF_ACCOUNT): str, + vol.Required(CONF_PASSWORD): str, + vol.Required(CONF_SERVER, default=1): vol.In(servers) }), errors={"base": error} if error else None ) @@ -96,15 +124,14 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): if user_input is not None: self._current_home = user_input[CONF_HOME] return await self.async_step_device() - homes = await self._cloud.get_homegroups() - home_list = {} - for home in homes: - home_list[int(home.get("homegroupId"))] = home.get("name") + homes = await self._cloud.list_home() + if homes is None or len(homes) == 0: + return await self.async_step_device(error="no_home") return self.async_show_form( step_id="home", data_schema=vol.Schema({ - vol.Required(CONF_HOME, default=list(home_list.keys())[0]): - vol.In(home_list), + vol.Required(CONF_HOME, default=list(homes.keys())[0]): + vol.In(homes), }), errors={"base": error} if error else None ) @@ -113,39 +140,39 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): if user_input is not None: # 下载lua # 本地尝试连接设备 - self._device = self._device_list[user_input[CONF_DEVICE]] - if not self._device.get("online"): + self._device = self._device_list[user_input[CONF_DEVICE_ID]] + if self._device.get("online") is not True: return await self.async_step_device(error="offline_error") return await self.async_step_discover() - devices = await self._cloud.get_devices(self._current_home) + appliances = await self._cloud.list_appliances(self._current_home) self._device_list = {} device_list = {} - for device in devices: - if not self._device_configured(int(device.get("applianceCode"))): + for appliance_code, appliance_info in appliances.items(): + if not self._device_configured(appliance_code): try: - subtype = int(device.get("modelNumber")) if device.get("modelNumber") is not None else 0 + model_number = int(appliance_info.get("model_number")) if appliance_info.get("model_number") is not None else 0 except ValueError: - subtype = 0 - self._device_list[int(device.get("applianceCode"))] = { - "device_id": int(device.get("applianceCode")), - "name": device.get("name"), - "type": int(device.get("type"), 16), - "sn8": device.get("sn8", "00000000"), - "sn": device.get("sn"), - "model": device.get("productModel", "0"), - "subtype": subtype, - "enterprise_code": device.get("enterpriseCode","0000"), - "online": device.get("onlineStatus") == "1" + model_number = 0 + self._device_list[appliance_code] = { + CONF_DEVICE_ID: appliance_code, + CONF_NAME: appliance_info.get("name"), + CONF_TYPE: appliance_info.get("type"), + CONF_SN8: appliance_info.get("sn8", "00000000"), + CONF_SN: appliance_info.get("sn"), + CONF_MODEL: appliance_info.get("model", "0"), + CONF_MODEL_NUMBER: model_number, + "manufacturer_code": appliance_info.get("manufacturer_code","0000"), + "online": appliance_info.get("online") } - device_list[int(device.get("applianceCode"))] = \ - f"{device.get('name')} ({'在线' if device.get('onlineStatus') == '1' else '离线'})" + device_list[appliance_code] = \ + f"{appliance_info.get('name')} ({'online' if appliance_info.get('online') is True else 'offline'})" if len(self._device_list) == 0: return await self.async_step_device(error="no_new_devices") return self.async_show_form( step_id="device", data_schema=vol.Schema({ - vol.Required(CONF_DEVICE, default=list(device_list.keys())[0]): + vol.Required(CONF_DEVICE_ID, default=list(device_list.keys())[0]): vol.In(device_list), }), errors={"base": error} if error else None @@ -157,46 +184,55 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): ip_address = None if self._is_valid_ip_address(user_input[CONF_IP_ADDRESS]): ip_address = user_input[CONF_IP_ADDRESS] - discover_devices = discover([self._device["type"]], ip_address) + discover_devices = discover([self._device[CONF_TYPE]], ip_address) _LOGGER.debug(discover_devices) if discover_devices is None or len(discover_devices) == 0: return await self.async_step_discover(error="discover_failed") - current_device = discover_devices.get(self._device["device_id"]) + current_device = discover_devices.get(self._device[CONF_DEVICE_ID]) if current_device is None: return await self.async_step_discover(error="discover_failed") os.makedirs(self.hass.config.path(STORAGE_PATH), exist_ok=True) path = self.hass.config.path(STORAGE_PATH) - file = await self._cloud.get_lua(self._device["sn"], self._device["type"], path, self._device["enterprise_code"]) + file = await self._cloud.download_lua( + path=path, + device_type=self._device[CONF_TYPE], + sn=self._device[CONF_SN], + model_number=self._device[CONF_MODEL_NUMBER], + manufacturer_code=self._device["manufacturer_code"] + ) if file is None: return await self.async_step_discover(error="download_lua_failed") use_token = None use_key = None connected = False - if current_device.get("protocol") == 3: - for byte_order_big in [False, True]: - token, key = await self._cloud.get_token(self._device.get("device_id"), byte_order_big=byte_order_big) - if token and key: - dm = MiedaDevice( - name=self._device.get("name"), - device_id=self._device.get("device_id"), - device_type=current_device.get(CONF_TYPE), - ip_address=current_device.get(CONF_IP_ADDRESS), - port=current_device.get(CONF_PORT), - token=token, - key=key, - protocol=3, - model=None, - subtype = None, - sn=None, - sn8=None, - lua_file=None - ) - if dm.connect(): - use_token = token - use_key = key - connected = True - else: - return await self.async_step_discover(error="cant_get_token") + if current_device.get(CONF_PROTOCOL) == 3: + keys = await self._cloud.get_keys(self._device.get(CONF_DEVICE_ID)) + for method, key in keys.items(): + dm = MiedaDevice( + name="", + device_id=self._device.get(CONF_DEVICE_ID), + device_type=current_device.get(CONF_TYPE), + ip_address=current_device.get(CONF_IP_ADDRESS), + port=current_device.get(CONF_PORT), + token=key["token"], + key=key["key"], + protocol=3, + model=None, + subtype = None, + sn=None, + sn8=None, + lua_file=None + ) + _LOGGER.debug( + f"Successful to take token and key, token: {key['token']}," + f" key: { key['key']}, method: {method}" + ) + if dm.connect(): + use_token = key["token"] + use_key = key["key"] + dm.disconnect() + connected = True + break else: dm = MiedaDevice( name=self._device.get("name"), @@ -214,26 +250,26 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): lua_file=None ) if dm.connect(): + dm.disconnect() connected = True - if not connected: return await self.async_step_discover(error="connect_error") return self.async_create_entry( title=self._device.get("name"), data={ - CONF_NAME: self._device.get("name"), - CONF_DEVICE_ID: self._device.get("device_id"), - CONF_TYPE: current_device.get("type"), - CONF_PROTOCOL: current_device.get("protocol"), - CONF_IP_ADDRESS: current_device.get("ip_address"), - CONF_PORT: current_device.get("port"), + CONF_NAME: self._device.get(CONF_NAME), + CONF_DEVICE_ID: self._device.get(CONF_DEVICE_ID), + CONF_TYPE: current_device.get(CONF_TYPE), + CONF_PROTOCOL: current_device.get(CONF_PROTOCOL), + CONF_IP_ADDRESS: current_device.get(CONF_IP_ADDRESS), + CONF_PORT: current_device.get(CONF_PORT), CONF_TOKEN: use_token, CONF_KEY: use_key, - CONF_MODEL: self._device.get("model"), - "subtype": self._device.get("subtype"), - "sn": self._device.get("sn"), - "sn8": self._device.get("sn8"), - "lua_file": file, + CONF_MODEL: self._device.get(CONF_MODEL), + CONF_MODEL_NUMBER: self._device.get(CONF_MODEL_NUMBER), + CONF_SN: self._device.get(CONF_SN), + CONF_SN8: self._device.get(CONF_SN8), + CONF_LUA_FILE: file, }) else: return await self.async_step_discover(error="invalid_input") @@ -248,4 +284,67 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class OptionsFlowHandler(config_entries.OptionsFlow): def __init__(self, config_entry: config_entries.ConfigEntry): - pass + self._config_entry = config_entry + + async def async_step_init(self, user_input=None, error=None): + if self._config_entry.data.get(CONF_TYPE) == CONF_ACCOUNT: + return self.async_abort(reason="account_unsupport_config") + if user_input is not None: + if user_input.get("option") == 1: + return await self.async_step_configure() + else: + return await self.async_step_reset() + + return self.async_show_form( + step_id="init", + data_schema=vol.Schema({ + vol.Required("option", default=1): + vol.In({1: "Options", 2: "Reset device configuration"}) + + }), + errors={"base": error} if error else None + ) + + async def async_step_reset(self, user_input=None): + if user_input is not None: + if user_input["check"]: + remove_device_config(self.hass, self._config_entry.data.get(CONF_SN8)) + load_device_config( + self.hass, + self._config_entry.data.get(CONF_TYPE), + self._config_entry.data.get(CONF_SN8)) + return self.async_abort(reason="reset_success") + return self.async_show_form( + step_id="reset", + data_schema=vol.Schema({ + vol.Required("check", default=False): bool + }) + ) + + async def async_step_configure(self, user_input=None): + if user_input is not None: + return self.async_create_entry(title="", data=user_input) + ip_address = self._config_entry.options.get( + CONF_IP_ADDRESS, None + ) + if ip_address is None: + ip_address = self._config_entry.data.get( + CONF_IP_ADDRESS, None + ) + refresh_interval = self._config_entry.options.get( + CONF_REFRESH_INTERVAL, 30 + ) + data_schema = vol.Schema({ + vol.Required( + CONF_IP_ADDRESS, + default=ip_address + ): str, + vol.Required( + CONF_REFRESH_INTERVAL, + default=refresh_interval + ): int + }) + return self.async_show_form( + step_id="configure", + data_schema=data_schema + ) \ No newline at end of file diff --git a/custom_components/midea_meiju_codec/const.py b/custom_components/midea_meiju_codec/const.py index 21ac0ea..f3aa379 100644 --- a/custom_components/midea_meiju_codec/const.py +++ b/custom_components/midea_meiju_codec/const.py @@ -2,8 +2,14 @@ DOMAIN = "midea_meiju_codec" STORAGE_PATH = f".storage/{DOMAIN}/lua" CONFIG_PATH = f".storage/{DOMAIN}/config" DEVICES = "DEVICES" +CONF_REFRESH_INTERVAL = "refresh_interval" CONF_ACCOUNT = "account" +CONF_SERVER = "server" CONF_HOME = "home" CONF_KEY = "key" +CONF_SN = "sn" +CONF_SN8 = "sn8" +CONF_MODEL_NUMBER = "model_number" +CONF_LUA_FILE = "lua_file" CJSON_LUA = "--
-- cjson.lua
--
-- Copyright (c) 2018 rxi
--
-- Permission is hereby granted, free of charge, to any person obtaining a copy of
-- this software and associated documentation files (the "Software"), to deal in
-- the Software without restriction, including without limitation the rights to
-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-- of the Software, and to permit persons to whom the Software is furnished to do
-- so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in all
-- copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-- SOFTWARE.
--

local cjson = { _version = "0.1.1" }

-------------------------------------------------------------------------------
-- Encode
-------------------------------------------------------------------------------

local encode

local escape_char_map = {
  [ "\\" ] = "\\\\",
  [ "\"" ] = "\\\"",
  [ "\b" ] = "\\b",
  [ "\f" ] = "\\f",
  [ "\n" ] = "\\n",
  [ "\r" ] = "\\r",
  [ "\t" ] = "\\t",
}

local escape_char_map_inv = { [ "\\/" ] = "/" }
for k, v in pairs(escape_char_map) do
  escape_char_map_inv[v] = k
end


local function escape_char(c)
  return escape_char_map[c] or string.format("\\u%04x", c:byte())
end


local function encode_nil(val)
  return "null"
end


local function encode_table(val, stack)
  local res = {}
  stack = stack or {}

  -- Circular reference?
  if stack[val] then error("circular reference") end

  stack[val] = true

  if val[1] ~= nil or next(val) == nil then
    -- Treat as array -- check keys are valid and it is not sparse
    local n = 0
    for k in pairs(val) do
      if type(k) ~= "number" then
        error("invalid table: mixed or invalid key types")
      end
      n = n + 1
    end
    if n ~= #val then
      error("invalid table: sparse array")
    end
    -- Encode
    for i, v in ipairs(val) do
      table.insert(res, encode(v, stack))
    end
    stack[val] = nil
    return "[" .. table.concat(res, ",") .. "]"

  else
    -- Treat as an object
    for k, v in pairs(val) do
      if type(k) ~= "string" then
        error("invalid table: mixed or invalid key types")
      end
      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
    end
    stack[val] = nil
    return "{" .. table.concat(res, ",") .. "}"
  end
end


local function encode_string(val)
  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
end


local function encode_number(val)
  -- Check for NaN, -inf and inf
  if val ~= val or val <= -math.huge or val >= math.huge then
    error("unexpected number value '" .. tostring(val) .. "'")
  end
  return string.format("%.14g", val)
end


local type_func_map = {
  [ "nil"     ] = encode_nil,
  [ "table"   ] = encode_table,
  [ "string"  ] = encode_string,
  [ "number"  ] = encode_number,
  [ "boolean" ] = tostring,
}


encode = function(val, stack)
  local t = type(val)
  local f = type_func_map[t]
  if f then
    return f(val, stack)
  end
  error("unexpected type '" .. t .. "'")
end


function cjson.encode(val)
  return ( encode(val) )
end


-------------------------------------------------------------------------------
-- Decode
-------------------------------------------------------------------------------

local parse

local function create_set(...)
  local res = {}
  for i = 1, select("#", ...) do
    res[ select(i, ...) ] = true
  end
  return res
end

local space_chars   = create_set(" ", "\t", "\r", "\n")
local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
local literals      = create_set("true", "false", "null")

local literal_map = {
  [ "true"  ] = true,
  [ "false" ] = false,
  [ "null"  ] = nil,
}


local function next_char(str, idx, set, negate)
  for i = idx, #str do
    if set[str:sub(i, i)] ~= negate then
      return i
    end
  end
  return #str + 1
end


local function decode_error(str, idx, msg)
  local line_count = 1
  local col_count = 1
  for i = 1, idx - 1 do
    col_count = col_count + 1
    if str:sub(i, i) == "\n" then
      line_count = line_count + 1
      col_count = 1
    end
  end
  error( string.format("%s at line %d col %d", msg, line_count, col_count) )
end


local function codepoint_to_utf8(n)
  -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
  local f = math.floor
  if n <= 0x7f then
    return string.char(n)
  elseif n <= 0x7ff then
    return string.char(f(n / 64) + 192, n % 64 + 128)
  elseif n <= 0xffff then
    return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
  elseif n <= 0x10ffff then
    return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
                       f(n % 4096 / 64) + 128, n % 64 + 128)
  end
  error( string.format("invalid unicode codepoint '%x'", n) )
end


local function parse_unicode_escape(s)
  local n1 = tonumber( s:sub(3, 6),  16 )
  local n2 = tonumber( s:sub(9, 12), 16 )
  -- Surrogate pair?
  if n2 then
    return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
  else
    return codepoint_to_utf8(n1)
  end
end


local function parse_string(str, i)
  local has_unicode_escape = false
  local has_surrogate_escape = false
  local has_escape = false
  local last
  for j = i + 1, #str do
    local x = str:byte(j)

    if x < 32 then
      decode_error(str, j, "control character in string")
    end

    if last == 92 then -- "\\" (escape char)
      if x == 117 then -- "u" (unicode escape sequence)
        local hex = str:sub(j + 1, j + 5)
        if not hex:find("%x%x%x%x") then
          decode_error(str, j, "invalid unicode escape in string")
        end
        if hex:find("^[dD][89aAbB]") then
          has_surrogate_escape = true
        else
          has_unicode_escape = true
        end
      else
        local c = string.char(x)
        if not escape_chars[c] then
          decode_error(str, j, "invalid escape char '" .. c .. "' in string")
        end
        has_escape = true
      end
      last = nil

    elseif x == 34 then -- '"' (end of string)
      local s = str:sub(i + 1, j - 1)
      if has_surrogate_escape then
        s = s:gsub("\\u[dD][89aAbB]..\\u....", parse_unicode_escape)
      end
      if has_unicode_escape then
        s = s:gsub("\\u....", parse_unicode_escape)
      end
      if has_escape then
        s = s:gsub("\\.", escape_char_map_inv)
      end
      return s, j + 1

    else
      last = x
    end
  end
  decode_error(str, i, "expected closing quote for string")
end


local function parse_number(str, i)
  local x = next_char(str, i, delim_chars)
  local s = str:sub(i, x - 1)
  local n = tonumber(s)
  if not n then
    decode_error(str, i, "invalid number '" .. s .. "'")
  end
  return n, x
end


local function parse_literal(str, i)
  local x = next_char(str, i, delim_chars)
  local word = str:sub(i, x - 1)
  if not literals[word] then
    decode_error(str, i, "invalid literal '" .. word .. "'")
  end
  return literal_map[word], x
end


local function parse_array(str, i)
  local res = {}
  local n = 1
  i = i + 1
  while 1 do
    local x
    i = next_char(str, i, space_chars, true)
    -- Empty / end of array?
    if str:sub(i, i) == "]" then
      i = i + 1
      break
    end
    -- Read token
    x, i = parse(str, i)
    res[n] = x
    n = n + 1
    -- Next token
    i = next_char(str, i, space_chars, true)
    local chr = str:sub(i, i)
    i = i + 1
    if chr == "]" then break end
    if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
  end
  return res, i
end


local function parse_object(str, i)
  local res = {}
  i = i + 1
  while 1 do
    local key, val
    i = next_char(str, i, space_chars, true)
    -- Empty / end of object?
    if str:sub(i, i) == "}" then
      i = i + 1
      break
    end
    -- Read key
    if str:sub(i, i) ~= '"' then
      decode_error(str, i, "expected string for key")
    end
    key, i = parse(str, i)
    -- Read ':' delimiter
    i = next_char(str, i, space_chars, true)
    if str:sub(i, i) ~= ":" then
      decode_error(str, i, "expected ':' after key")
    end
    i = next_char(str, i + 1, space_chars, true)
    -- Read value
    val, i = parse(str, i)
    -- Set
    res[key] = val
    -- Next token
    i = next_char(str, i, space_chars, true)
    local chr = str:sub(i, i)
    i = i + 1
    if chr == "}" then break end
    if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
  end
  return res, i
end


local char_func_map = {
  [ '"' ] = parse_string,
  [ "0" ] = parse_number,
  [ "1" ] = parse_number,
  [ "2" ] = parse_number,
  [ "3" ] = parse_number,
  [ "4" ] = parse_number,
  [ "5" ] = parse_number,
  [ "6" ] = parse_number,
  [ "7" ] = parse_number,
  [ "8" ] = parse_number,
  [ "9" ] = parse_number,
  [ "-" ] = parse_number,
  [ "t" ] = parse_literal,
  [ "f" ] = parse_literal,
  [ "n" ] = parse_literal,
  [ "[" ] = parse_array,
  [ "{" ] = parse_object,
}


parse = function(str, idx)
  local chr = str:sub(idx, idx)
  local f = char_func_map[chr]
  if f then
    return f(str, idx)
  end
  decode_error(str, idx, "unexpected character '" .. chr .. "'")
end


function cjson.decode(str)
  if type(str) ~= "string" then
    error("expected argument of type string, got " .. type(str))
  end
  local res, idx = parse(str, next_char(str, 1, space_chars, true))
  idx = next_char(str, idx, space_chars, true)
  if idx <= #str then
    decode_error(str, idx, "trailing garbage")
  end
  return res
end
return cjson" BIT_LUA = "--[[

LUA MODULE

  bit.numberlua - Bitwise operations implemented in pure Lua as numbers,
    with Lua 5.2 'bit32' and (LuaJIT) LuaBitOp 'bit' compatibility interfaces.

SYNOPSIS

  local bit = require 'bit.numberlua'
  print(bit.band(0xff00ff00, 0x00ff00ff)) --> 0xffffffff
  
  -- Interface providing strong Lua 5.2 'bit32' compatibility
  local bit32 = require 'bit.numberlua'.bit32
  assert(bit32.band(-1) == 0xffffffff)
  
  -- Interface providing strong (LuaJIT) LuaBitOp 'bit' compatibility
  local bit = require 'bit.numberlua'.bit
  assert(bit.tobit(0xffffffff) == -1)
  
DESCRIPTION
  
  This library implements bitwise operations entirely in Lua.
  This module is typically intended if for some reasons you don't want
  to or cannot  install a popular C based bit library like BitOp 'bit' [1]
  (which comes pre-installed with LuaJIT) or 'bit32' (which comes
  pre-installed with Lua 5.2) but want a similar interface.
  
  This modules represents bit arrays as non-negative Lua numbers. [1]
  It can represent 32-bit bit arrays when Lua is compiled
  with lua_Number as double-precision IEEE 754 floating point.

  The module is nearly the most efficient it can be but may be a few times
  slower than the C based bit libraries and is orders or magnitude
  slower than LuaJIT bit operations, which compile to native code.  Therefore,
  this library is inferior in performane to the other modules.

  The `xor` function in this module is based partly on Roberto Ierusalimschy's
  post in http://lua-users.org/lists/lua-l/2002-09/msg00134.html .
  
  The included BIT.bit32 and BIT.bit sublibraries aims to provide 100%
  compatibility with the Lua 5.2 "bit32" and (LuaJIT) LuaBitOp "bit" library.
  This compatbility is at the cost of some efficiency since inputted
  numbers are normalized and more general forms (e.g. multi-argument
  bitwise operators) are supported.
  
STATUS

  WARNING: Not all corner cases have been tested and documented.
  Some attempt was made to make these similar to the Lua 5.2 [2]
  and LuaJit BitOp [3] libraries, but this is not fully tested and there
  are currently some differences.  Addressing these differences may
  be improved in the future but it is not yet fully determined how to
  resolve these differences.
  
  The BIT.bit32 library passes the Lua 5.2 test suite (bitwise.lua)
  http://www.lua.org/tests/5.2/ .  The BIT.bit library passes the LuaBitOp
  test suite (bittest.lua).  However, these have not been tested on
  platforms with Lua compiled with 32-bit integer numbers.

API

  BIT.tobit(x) --> z
  
    Similar to function in BitOp.
    
  BIT.tohex(x, n)
  
    Similar to function in BitOp.
  
  BIT.band(x, y) --> z
  
    Similar to function in Lua 5.2 and BitOp but requires two arguments.
  
  BIT.bor(x, y) --> z
  
    Similar to function in Lua 5.2 and BitOp but requires two arguments.

  BIT.bxor(x, y) --> z
  
    Similar to function in Lua 5.2 and BitOp but requires two arguments.
  
  BIT.bnot(x) --> z
  
    Similar to function in Lua 5.2 and BitOp.

  BIT.lshift(x, disp) --> z
  
    Similar to function in Lua 5.2 (warning: BitOp uses unsigned lower 5 bits of shift),
  
  BIT.rshift(x, disp) --> z
  
    Similar to function in Lua 5.2 (warning: BitOp uses unsigned lower 5 bits of shift),

  BIT.extract(x, field [, width]) --> z
  
    Similar to function in Lua 5.2.
  
  BIT.replace(x, v, field, width) --> z
  
    Similar to function in Lua 5.2.
  
  BIT.bswap(x) --> z
  
    Similar to function in Lua 5.2.

  BIT.rrotate(x, disp) --> z
  BIT.ror(x, disp) --> z
  
    Similar to function in Lua 5.2 and BitOp.

  BIT.lrotate(x, disp) --> z
  BIT.rol(x, disp) --> z

    Similar to function in Lua 5.2 and BitOp.
  
  BIT.arshift
  
    Similar to function in Lua 5.2 and BitOp.
    
  BIT.btest
  
    Similar to function in Lua 5.2 with requires two arguments.

  BIT.bit32
  
    This table contains functions that aim to provide 100% compatibility
    with the Lua 5.2 "bit32" library.
    
    bit32.arshift (x, disp) --> z
    bit32.band (...) --> z
    bit32.bnot (x) --> z
    bit32.bor (...) --> z
    bit32.btest (...) --> true | false
    bit32.bxor (...) --> z
    bit32.extract (x, field [, width]) --> z
    bit32.replace (x, v, field [, width]) --> z
    bit32.lrotate (x, disp) --> z
    bit32.lshift (x, disp) --> z
    bit32.rrotate (x, disp) --> z
    bit32.rshift (x, disp) --> z

  BIT.bit
  
    This table contains functions that aim to provide 100% compatibility
    with the LuaBitOp "bit" library (from LuaJIT).
    
    bit.tobit(x) --> y
    bit.tohex(x [,n]) --> y
    bit.bnot(x) --> y
    bit.bor(x1 [,x2...]) --> y
    bit.band(x1 [,x2...]) --> y
    bit.bxor(x1 [,x2...]) --> y
    bit.lshift(x, n) --> y
    bit.rshift(x, n) --> y
    bit.arshift(x, n) --> y
    bit.rol(x, n) --> y
    bit.ror(x, n) --> y
    bit.bswap(x) --> y
    
DEPENDENCIES

  None (other than Lua 5.1 or 5.2).
    
DOWNLOAD/INSTALLATION

  If using LuaRocks:
    luarocks install lua-bit-numberlua

  Otherwise, download <https://github.com/davidm/lua-bit-numberlua/zipball/master>.
  Alternately, if using git:
    git clone git://github.com/davidm/lua-bit-numberlua.git
    cd lua-bit-numberlua
  Optionally unpack:
    ./util.mk
  or unpack and install in LuaRocks:
    ./util.mk install 

REFERENCES

  [1] http://lua-users.org/wiki/FloatingPoint
  [2] http://www.lua.org/manual/5.2/
  [3] http://bitop.luajit.org/
  
LICENSE

  (c) 2008-2011 David Manura.  Licensed under the same terms as Lua (MIT).

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  (end license)

--]]

local M = {_TYPE='module', _NAME='bit.numberlua', _VERSION='0.3.1.20120131'}

local floor = math.floor

local MOD = 2^32
local MODM = MOD-1

local function memoize(f)
  local mt = {}
  local t = setmetatable({}, mt)
  function mt:__index(k)
    local v = f(k); t[k] = v
    return v
  end
  return t
end

local function make_bitop_uncached(t, m)
  local function bitop(a, b)
    local res,p = 0,1
    while a ~= 0 and b ~= 0 do
      local am, bm = a%m, b%m
      res = res + t[am][bm]*p
      a = (a - am) / m
      b = (b - bm) / m
      p = p*m
    end
    res = res + (a+b)*p
    return res
  end
  return bitop
end

local function make_bitop(t)
  local op1 = make_bitop_uncached(t,2^1)
  local op2 = memoize(function(a)
    return memoize(function(b)
      return op1(a, b)
    end)
  end)
  return make_bitop_uncached(op2, 2^(t.n or 1))
end

-- ok?  probably not if running on a 32-bit int Lua number type platform
function M.tobit(x)
  return x % 2^32
end

M.bxor = make_bitop {[0]={[0]=0,[1]=1},[1]={[0]=1,[1]=0}, n=4}
local bxor = M.bxor

function M.bnot(a)   return MODM - a end
local bnot = M.bnot

function M.band(a,b) return ((a+b) - bxor(a,b))/2 end
local band = M.band

function M.bor(a,b)  return MODM - band(MODM - a, MODM - b) end
local bor = M.bor

local lshift, rshift -- forward declare

function M.rshift(a,disp) -- Lua5.2 insipred
  if disp < 0 then return lshift(a,-disp) end
  return floor(a % 2^32 / 2^disp)
end
rshift = M.rshift

function M.lshift(a,disp) -- Lua5.2 inspired
  if disp < 0 then return rshift(a,-disp) end 
  return (a * 2^disp) % 2^32
end
lshift = M.lshift

function M.tohex(x, n) -- BitOp style
  n = n or 8
  local up
  if n <= 0 then
    if n == 0 then return '' end
    up = true
    n = - n
  end
  x = band(x, 16^n-1)
  return ('%0'..n..(up and 'X' or 'x')):format(x)
end
local tohex = M.tohex

function M.extract(n, field, width) -- Lua5.2 inspired
  width = width or 1
  return band(rshift(n, field), 2^width-1)
end
local extract = M.extract

function M.replace(n, v, field, width) -- Lua5.2 inspired
  width = width or 1
  local mask1 = 2^width-1
  v = band(v, mask1) -- required by spec?
  local mask = bnot(lshift(mask1, field))
  return band(n, mask) + lshift(v, field)
end
local replace = M.replace

function M.bswap(x)  -- BitOp style
  local a = band(x, 0xff); x = rshift(x, 8)
  local b = band(x, 0xff); x = rshift(x, 8)
  local c = band(x, 0xff); x = rshift(x, 8)
  local d = band(x, 0xff)
  return lshift(lshift(lshift(a, 8) + b, 8) + c, 8) + d
end
local bswap = M.bswap

function M.rrotate(x, disp)  -- Lua5.2 inspired
  disp = disp % 32
  local low = band(x, 2^disp-1)
  return rshift(x, disp) + lshift(low, 32-disp)
end
local rrotate = M.rrotate

function M.lrotate(x, disp)  -- Lua5.2 inspired
  return rrotate(x, -disp)
end
local lrotate = M.lrotate

M.rol = M.lrotate  -- LuaOp inspired
M.ror = M.rrotate  -- LuaOp insipred


function M.arshift(x, disp) -- Lua5.2 inspired
  local z = rshift(x, disp)
  if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
  return z
end
local arshift = M.arshift

function M.btest(x, y) -- Lua5.2 inspired
  return band(x, y) ~= 0
end

--
-- Start Lua 5.2 "bit32" compat section.
--

M.bit32 = {} -- Lua 5.2 'bit32' compatibility


local function bit32_bnot(x)
  return (-1 - x) % MOD
end
M.bit32.bnot = bit32_bnot

local function bit32_bxor(a, b, c, ...)
  local z
  if b then
    a = a % MOD
    b = b % MOD
    z = bxor(a, b)
    if c then
      z = bit32_bxor(z, c, ...)
    end
    return z
  elseif a then
    return a % MOD
  else
    return 0
  end
end
M.bit32.bxor = bit32_bxor

local function bit32_band(a, b, c, ...)
  local z
  if b then
    a = a % MOD
    b = b % MOD
    z = ((a+b) - bxor(a,b)) / 2
    if c then
      z = bit32_band(z, c, ...)
    end
    return z
  elseif a then
    return a % MOD
  else
    return MODM
  end
end
M.bit32.band = bit32_band

local function bit32_bor(a, b, c, ...)
  local z
  if b then
    a = a % MOD
    b = b % MOD
    z = MODM - band(MODM - a, MODM - b)
    if c then
      z = bit32_bor(z, c, ...)
    end
    return z
  elseif a then
    return a % MOD
  else
    return 0
  end
end
M.bit32.bor = bit32_bor

function M.bit32.btest(...)
  return bit32_band(...) ~= 0
end

function M.bit32.lrotate(x, disp)
  return lrotate(x % MOD, disp)
end

function M.bit32.rrotate(x, disp)
  return rrotate(x % MOD, disp)
end

function M.bit32.lshift(x,disp)
  if disp > 31 or disp < -31 then return 0 end
  return lshift(x % MOD, disp)
end

function M.bit32.rshift(x,disp)
  if disp > 31 or disp < -31 then return 0 end
  return rshift(x % MOD, disp)
end

function M.bit32.arshift(x,disp)
  x = x % MOD
  if disp >= 0 then
    if disp > 31 then
      return (x >= 0x80000000) and MODM or 0
    else
      local z = rshift(x, disp)
      if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
      return z
    end
  else
    return lshift(x, -disp)
  end
end

function M.bit32.extract(x, field, ...)
  local width = ... or 1
  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
  x = x % MOD
  return extract(x, field, ...)
end

function M.bit32.replace(x, v, field, ...)
  local width = ... or 1
  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
  x = x % MOD
  v = v % MOD
  return replace(x, v, field, ...)
end


--
-- Start LuaBitOp "bit" compat section.
--

M.bit = {} -- LuaBitOp "bit" compatibility

function M.bit.tobit(x)
  x = x % MOD
  if x >= 0x80000000 then x = x - MOD end
  return x
end
local bit_tobit = M.bit.tobit

function M.bit.tohex(x, ...)
  return tohex(x % MOD, ...)
end

function M.bit.bnot(x)
  return bit_tobit(bnot(x % MOD))
end

local function bit_bor(a, b, c, ...)
  if c then
    return bit_bor(bit_bor(a, b), c, ...)
  elseif b then
    return bit_tobit(bor(a % MOD, b % MOD))
  else
    return bit_tobit(a)
  end
end
M.bit.bor = bit_bor

local function bit_band(a, b, c, ...)
  if c then
    return bit_band(bit_band(a, b), c, ...)
  elseif b then
    return bit_tobit(band(a % MOD, b % MOD))
  else
    return bit_tobit(a)
  end
end
M.bit.band = bit_band

local function bit_bxor(a, b, c, ...)
  if c then
    return bit_bxor(bit_bxor(a, b), c, ...)
  elseif b then
    return bit_tobit(bxor(a % MOD, b % MOD))
  else
    return bit_tobit(a)
  end
end
M.bit.bxor = bit_bxor

function M.bit.lshift(x, n)
  return bit_tobit(lshift(x % MOD, n % 32))
end

function M.bit.rshift(x, n)
  return bit_tobit(rshift(x % MOD, n % 32))
end

function M.bit.arshift(x, n)
  return bit_tobit(arshift(x % MOD, n % 32))
end

function M.bit.rol(x, n)
  return bit_tobit(lrotate(x % MOD, n % 32))
end

function M.bit.ror(x, n)
  return bit_tobit(rrotate(x % MOD, n % 32))
end

function M.bit.bswap(x)
  return bit_tobit(bswap(x % MOD))
end

return M" diff --git a/custom_components/midea_meiju_codec/core/cloud.py b/custom_components/midea_meiju_codec/core/cloud.py index 15a234f..76731ea 100644 --- a/custom_components/midea_meiju_codec/core/cloud.py +++ b/custom_components/midea_meiju_codec/core/cloud.py @@ -1,204 +1,465 @@ -import datetime -import time -import json import logging -from aiohttp import ClientSession -from secrets import token_hex, token_urlsafe +import time +import datetime +import json +import base64 from threading import Lock -from .security import CloudSecurity - -CLIENT_TYPE = 1 # Android -FORMAT = 2 # JSON -APP_KEY = "4675636b" +from aiohttp import ClientSession +from secrets import token_hex +from .security import CloudSecurity, MeijuCloudSecurity, MSmartCloudSecurity _LOGGER = logging.getLogger(__name__) +clouds = { + "美的美居": { + "class_name": "MeijuCloud", + "app_key": "46579c15", + "login_key": "ad0ee21d48a64bf49f4fb583ab76e799", + "iot_key": bytes.fromhex(format(9795516279659324117647275084689641883661667, 'x')).decode(), + "hmac_key": bytes.fromhex(format(117390035944627627450677220413733956185864939010425, 'x')).decode(), + "api_url": "https://mp-prod.smartmidea.net/mas/v5/app/proxy?alias=", + }, + "MSmartHome": { + "class_name": "MSmartHomeCloud", + "app_key": "ac21b9f9cbfe4ca5a88562ef25e2b768", + "iot_key": bytes.fromhex(format(7882822598523843940, 'x')).decode(), + "hmac_key": bytes.fromhex(format(117390035944627627450677220413733956185864939010425, 'x')).decode(), + "api_url": "https://mp-prod.appsmb.com/mas/v5/app/proxy?alias=", + }, +} -class MideaCloudBase: - LANGUAGE = "en_US" - APP_ID = "1010" - SRC = "1010" - LOGIN_KEY = None - IOT_KEY = None - DEVICE_ID = int(time.time() * 100000) +default_keys = { + 99: { + "token": "ee755a84a115703768bcc7c6c13d3d629aa416f1e2fd798beb9f78cbb1381d09" + "1cc245d7b063aad2a900e5b498fbd936c811f5d504b2e656d4f33b3bbc6d1da3", + "key": "ed37bd31558a4b039aaf4e7a7a59aa7a75fd9101682045f69baf45d28380ae5c" + } +} - def __init__(self, session: ClientSession, security, username: str, password: str, server: str = None): - self.session = session - self.username = username - self.password = password - self.server = None - self.login_id = None - self.access_token = "" - self.key = None + +class MideaCloud: + def __init__( + self, + session: ClientSession, + security: CloudSecurity, + app_key: str, + account: str, + password: str, + api_url: str + ): + self._device_id = CloudSecurity.get_deviceid(account) + self._session = session + self._security = security self._api_lock = Lock() - self.login_session = None - self.security = security - self.server = server + self._app_key = app_key + self._account = account + self._password = password + self._api_url = api_url + self._access_token = None + self._login_id = None - async def api_request(self, endpoint, args=None, data=None) -> dict | None: - args = args or {} - headers = {} - if data is None: - data = { - "appId": self.APP_ID, - "format": FORMAT, - "clientType": CLIENT_TYPE, - "language": self.LANGUAGE, - "src": self.SRC, - "stamp": datetime.datetime.now().strftime("%Y%m%d%H%M%S"), - "deviceId": self.DEVICE_ID, - } - data.update(args) + def _make_general_data(self): + return { + } + async def _api_request(self, endpoint: str, data: dict, header=None) -> dict | None: + header = header or {} if not data.get("reqId"): data.update({ - "reqId": token_hex(16), + "reqId": token_hex(16) + }) + if not data.get("stamp"): + data.update({ + "stamp": datetime.datetime.now().strftime("%Y%m%d%H%M%S") }) - - url = self.server + endpoint random = str(int(time.time())) - - sign = self.security.sign(json.dumps(data), random) - headers.update({ - "Content-Type": "application/json", + url = self._api_url + endpoint + dump_data = json.dumps(data) + sign = self._security.sign(dump_data, random) + header.update({ + "content-type": "application/json; charset=utf-8", "secretVersion": "1", "sign": sign, "random": random, - "accessToken": self.access_token }) - response = {"code": -1} + if self._access_token is not None: + header.update({ + "accesstoken": self._access_token + }) + response:dict = {"code": -1} for i in range(0, 3): try: with self._api_lock: - r = await self.session.request("POST", url, headers=headers, data=json.dumps(data), timeout=10) + r = await self._session.request("POST", url, headers=header, data=dump_data, timeout=10) raw = await r.read() - _LOGGER.debug(f"Endpoint: {endpoint}, Response: {str(raw)}") + _LOGGER.debug(f"Midea cloud API url: {url}, data: {data}, response: {raw}") response = json.loads(raw) break except Exception as e: - _LOGGER.error(f"Cloud error: {repr(e)}") + pass if int(response["code"]) == 0 and "data" in response: return response["data"] + print(response) return None - async def get_login_id(self): - response = await self.api_request( - "/v1/user/login/id/get", - args={"loginAccount": self.username} - ) - if response: - self.login_id = response["loginId"] - return True - return False + async def _get_login_id(self) -> str | None: + data = self._make_general_data() + data.update({ + "loginAccount": f"{self._account}" + }) + if response := await self._api_request( + endpoint="/v1/user/login/id/get", + data=data + ): + return response.get("loginId") + return None - async def login(self): - result = await self.get_login_id() - if result: - response = await self.api_request( - "/mj/user/login", - data={ - "data": { - "appKey": APP_KEY, - "platform": FORMAT, - "deviceId": self.DEVICE_ID - }, - "iotData": { - "appId": self.APP_ID, - "clientType": CLIENT_TYPE, - "iampwd": self.security.encrypt_iam_password(self.login_id, self.password), - "loginAccount": self.username, - "password": self.security.encrypt_password(self.login_id, self.password), - "pushToken": token_urlsafe(120), - "reqId": token_hex(16), - "src": self.SRC, - "stamp": datetime.time().strftime("%Y%m%d%H%M%S"), - }, - } + async def login(self) -> bool: + raise NotImplementedError() + + async def get_keys(self, appliance_id: int): + result = {} + for method in [1, 2]: + udp_id = self._security.get_udp_id(appliance_id, method) + data = self._make_general_data() + data.update({ + "udpid": udp_id + }) + response = await self._api_request( + endpoint="/v1/iot/secure/getToken", + data=data ) - if response: - self.access_token = response["mdata"]["accessToken"] - if "key" in response: - self.key = CloudSecurity.decrypt(bytes.fromhex(response["key"])) + if response and "tokenlist" in response: + for token in response["tokenlist"]: + if token["udpId"] == udp_id: + result[method] = { + "token": token["token"].lower(), + "key": token["key"].lower() + } + result.update(default_keys) + return result + + async def list_home(self) -> dict | None: + return {1: "My home"} + + async def list_appliances(self, home_id) -> dict | None: + raise NotImplementedError() + + async def download_lua( + self, path: str, + device_type: str, + sn: str, + model_number: str | None, + manufacturer_code: str = "0000", + ): + raise NotImplementedError() + + +class MeijuCloud(MideaCloud): + APP_ID = "900" + APP_VERSION = "8.20.0.2" + + def __init__( + self, + cloud_name: str, + session: ClientSession, + account: str, + password: str, + ): + super().__init__( + session=session, + security=MeijuCloudSecurity( + login_key=clouds[cloud_name]["login_key"], + iot_key=clouds[cloud_name]["iot_key"], + hmac_key=clouds[cloud_name]["hmac_key"], + ), + app_key=clouds[cloud_name]["app_key"], + account=account, + password=password, + api_url=clouds[cloud_name]["api_url"] + ) + + async def login(self) -> bool: + if login_id := await self._get_login_id(): + self._login_id = login_id + stamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S") + data = { + "iotData": { + "clientType": 1, + "deviceId": self._device_id, + "iampwd": self._security.encrypt_iam_password(self._login_id, self._password), + "iotAppId": self.APP_ID, + "loginAccount": self._account, + "password": self._security.encrypt_password(self._login_id, self._password), + "reqId": token_hex(16), + "stamp": stamp + }, + "data": { + "appKey": self._app_key, + "deviceId": self._device_id, + "platform": 2 + }, + "timestamp": stamp, + "stamp": stamp + } + if response := await self._api_request( + endpoint="/mj/user/login", + data=data + ): + self._access_token = response["mdata"]["accessToken"] + self._security.set_aes_keys( + self._security.aes_decrypt_with_fixed_key( + response["key"] + ), None + ) + return True return False - async def get_token(self, device_id: int, byte_order_big=False): - if byte_order_big: - udpid = CloudSecurity.get_udpid(device_id.to_bytes(6, "big")) - else: - udpid = CloudSecurity.get_udpid(device_id.to_bytes(6, "little")) - _LOGGER.debug(f"The udpid of deivce [{device_id}] generated " - f"with byte order '{'big' if byte_order_big else 'little'}': {udpid}") - response = await self.api_request( - "/v1/iot/secure/getToken", - args={"udpid": udpid} - ) - if response and "tokenlist" in response: - for token in response["tokenlist"]: - if token["udpId"] == udpid: - return token["token"].upper(), token["key"].upper() - return None, None + async def list_home(self): + if response := await self._api_request( + endpoint="/v1/homegroup/list/get", + data={} + ): + homes = {} + for home in response["homeList"]: + homes.update({ + int(home["homegroupId"]): home["name"] + }) + return homes + return None + async def list_appliances(self, home_id) -> dict | None: + data = { + "homegroupId": home_id + } + if response := await self._api_request( + endpoint="/v1/appliance/home/list/get", + data=data + ): + appliances = {} + for home in response.get("homeList") or []: + for room in home.get("roomList") or []: + for appliance in room.get("applianceList"): + device_info = { + "name": appliance.get("name"), + "type": int(appliance.get("type"), 16), + "sn": self._security.aes_decrypt(appliance.get("sn")) if appliance.get("sn") else "", + "sn8": appliance.get("sn8", "00000000"), + "model_number": appliance.get("modelNumber", "0"), + "manufacturer_code":appliance.get("enterpriseCode", "0000"), + "model": appliance.get("productModel"), + "online": appliance.get("onlineStatus") == "1", + } + if device_info.get("sn8") is None or len(device_info.get("sn8")) == 0: + device_info["sn8"] = "00000000" + if device_info.get("model") is None or len(device_info.get("model")) == 0: + device_info["model"] = device_info["sn8"] + appliances[int(appliance["applianceCode"])] = device_info + return appliances + return None -class MeijuCloudExtend(MideaCloudBase): - LANGUAGE = "zh_CN" - LOGIN_KEY = "ad0ee21d48a64bf49f4fb583ab76e799" - IOT_KEY = "prod_secret123@muc" - SERVER = "https://mp-prod.smartmidea.net/mas/v5/app/proxy?alias=" - - def __init__(self, session: ClientSession, username: str, password: str): - super().__init__(session=session, - security=CloudSecurity(self.IOT_KEY, self.LOGIN_KEY), - username=username, - password=password, - server=self.SERVER) - - async def get_homegroups(self): - response = await self.api_request("/v1/homegroup/list/get", args={}) - return response.get("homeList") - - async def get_devices(self, homegroupID=None): - if homegroupID is None: - homes = [] - homegroups = await self.get_homegroups() - if homegroups: - for home in homegroups: - homes.append(home["homegroupId"]) - else: - homes = [homegroupID] - devices = [] - for home in homes: - response = await self.api_request("/v1/appliance/home/list/get", args={ - 'homegroupId': home - }) - if response: - for h in response.get("homeList") or []: - for r in h.get("roomList") or []: - for a in r.get("applianceList"): - a["sn"] = CloudSecurity.decrypt(bytes.fromhex(a["sn"]), self.key).decode() - devices.append(a) - return devices - - async def get_lua(self, sn, device_type, path, enterprise_code=None): - response = await self.api_request( - "/v1/appliance/protocol/lua/luaGet", - data={ - "applianceSn": sn, - "applianceType": "0x%02X" % device_type, - "applianceMFCode": enterprise_code if enterprise_code else "0000", - 'version': "0", - "iotAppId": "900", - "stamp": datetime.datetime.now().strftime("%Y%m%d%H%M%S") - } - ) + async def download_lua( + self, path: str, + device_type: int, + sn: str, + model_number: str | None, + manufacturer_code: str = "0000", + ): + data = { + "applianceSn": sn, + "applianceType": "0x%02X" % device_type, + "applianceMFCode": manufacturer_code, + 'version': "0", + "iotAppId": self.APP_ID, + } fnm = None - if response: - res = await self.session.get(response["url"]) + if response := await self._api_request( + endpoint="/v1/appliance/protocol/lua/luaGet", + data=data + ): + res = await self._session.get(response["url"]) if res.status == 200: lua = await res.text() if lua: - stream = 'local bit = require "bit" ' + CloudSecurity.decrypt(bytes.fromhex(lua)).decode() + stream = ('local bit = require "bit"\n' + + self._security.aes_decrypt_with_fixed_key(lua)) + stream = stream.replace("\r\n", "\n") fnm = f"{path}/{response['fileName']}" with open(fnm, "w") as fp: fp.write(stream) return fnm + + +class MSmartHomeCloud(MideaCloud): + APP_ID = "1010" + SRC = "10" + APP_VERSION = "3.0.2" + + def __init__( + self, + cloud_name: str, + session: ClientSession, + account: str, + password: str, + ): + super().__init__( + session=session, + security=MSmartCloudSecurity( + login_key=clouds[cloud_name]["app_key"], + iot_key=clouds[cloud_name]["iot_key"], + hmac_key=clouds[cloud_name]["hmac_key"], + ), + app_key=clouds[cloud_name]["app_key"], + account=account, + password=password, + api_url=clouds[cloud_name]["api_url"] + ) + self._auth_base = base64.b64encode( + f"{self._app_key}:{clouds['MSmartHome']['iot_key']}".encode("ascii") + ).decode("ascii") + self._uid = "" + + def _make_general_data(self): + return { + "appVersion": self.APP_VERSION, + "src": self.SRC, + "format": "2", + "stamp": datetime.datetime.now().strftime("%Y%m%d%H%M%S"), + "platformId": "1", + "deviceId": self._device_id, + "reqId": token_hex(16), + "uid": self._uid, + "clientType": "1", + "appId": self.APP_ID, + } + + async def _api_request(self, endpoint: str, data: dict, header=None) -> dict | None: + header = header or {} + header.update({ + "x-recipe-app": self.APP_ID, + "authorization": f"Basic {self._auth_base}" + }) + if len(self._uid) > 0: + header.update({ + "uid": self._uid + }) + return await super()._api_request(endpoint, data, header) + + async def _re_route(self): + data = self._make_general_data() + data.update({ + "userType": "0", + "userName": f"{self._account}" + }) + if response := await self._api_request( + endpoint="/v1/multicloud/platform/user/route", + data=data + ): + if api_url := response.get("masUrl"): + self._api_url = api_url + + async def login(self) -> bool: + await self._re_route() + if login_id := await self._get_login_id(): + self._login_id = login_id + iot_data = self._make_general_data() + iot_data.pop("uid") + stamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S") + iot_data.update({ + "iampwd": self._security.encrypt_iam_password(self._login_id, self._password), + "loginAccount": self._account, + "password": self._security.encrypt_password(self._login_id, self._password), + "stamp": stamp + }) + data = { + "iotData": iot_data, + "data": { + "appKey": self._app_key, + "deviceId": self._device_id, + "platform": "2" + }, + "stamp": stamp + } + if response := await self._api_request( + endpoint="/mj/user/login", + data=data + ): + self._uid = response["uid"] + self._access_token = response["mdata"]["accessToken"] + self._security.set_aes_keys(response["accessToken"], response["randomData"]) + return True + return False + + async def list_appliances(self, home_id=None) -> dict | None: + data = self._make_general_data() + if response := await self._api_request( + endpoint="/v1/appliance/user/list/get", + data=data + ): + appliances = {} + for appliance in response["list"]: + device_info = { + "name": appliance.get("name"), + "type": int(appliance.get("type"), 16), + "sn": self._security.aes_decrypt(appliance.get("sn")) if appliance.get("sn") else "", + "sn8": "", + "model_number": appliance.get("modelNumber", "0"), + "manufacturer_code":appliance.get("enterpriseCode", "0000"), + "model": "", + "online": appliance.get("onlineStatus") == "1", + } + device_info["sn8"] = device_info.get("sn")[9:17] if len(device_info["sn"]) > 17 else "" + device_info["model"] = device_info.get("sn8") + appliances[int(appliance["id"])] = device_info + return appliances + return None + + async def download_lua( + self, path: str, + device_type: int, + sn: str, + model_number: str | None, + manufacturer_code: str = "0000", + ): + data = { + "clientType": "1", + "appId": self.APP_ID, + "format": "2", + "deviceId": self._device_id, + "iotAppId": self.APP_ID, + "applianceMFCode": manufacturer_code, + "applianceType": "0x%02X" % device_type, + "modelNumber": model_number, + "applianceSn": self._security.aes_encrypt_with_fixed_key(sn.encode("ascii")).hex(), + "version": "0", + "encryptedType ": "2" + } + fnm = None + if response := await self._api_request( + endpoint="/v2/luaEncryption/luaGet", + data=data + ): + res = await self._session.get(response["url"]) + if res.status == 200: + lua = await res.text() + if lua: + stream = ('local bit = require "bit"\n' + + self._security.aes_decrypt_with_fixed_key(lua)) + stream = stream.replace("\r\n", "\n") + fnm = f"{path}/{response['fileName']}" + with open(fnm, "w") as fp: + fp.write(stream) + return fnm + + +def get_midea_cloud(cloud_name: str, session: ClientSession, account: str, password: str) -> MideaCloud | None: + cloud = None + if cloud_name in clouds.keys(): + cloud = globals()[clouds[cloud_name]["class_name"]]( + cloud_name=cloud_name, + session=session, + account=account, + password=password + ) + return cloud diff --git a/custom_components/midea_meiju_codec/core/device.py b/custom_components/midea_meiju_codec/core/device.py index f9924c9..775057b 100644 --- a/custom_components/midea_meiju_codec/core/device.py +++ b/custom_components/midea_meiju_codec/core/device.py @@ -5,6 +5,7 @@ from enum import IntEnum from .security import LocalSecurity, MSGTYPE_HANDSHAKE_REQUEST, MSGTYPE_ENCRYPTED_REQUEST from .packet_builder import PacketBuilder from .lua_runtime import MideaCodec +from .message import MessageQuestCustom from .logger import MideaLogger @@ -70,6 +71,8 @@ class MiedaDevice(threading.Thread): self._connected = False self._queries = [{}] self._centralized = [] + self._calculate_get = [] + self._calculate_set = [] self._lua_runtime = MideaCodec(lua_file, sn=sn, subtype=subtype) if lua_file is not None else None @property @@ -111,22 +114,18 @@ class MiedaDevice(threading.Thread): def set_refresh_interval(self, refresh_interval): self._refresh_interval = refresh_interval - @property - def queries(self): - return self._queries - - @queries.setter - def queries(self, queries: list): + def set_queries(self, queries: list): self._queries = queries - @property - def centralized(self): - return self._centralized - - @centralized.setter - def centralized(self, centralized: list): + def set_centralized(self, centralized: list): self._centralized = centralized + def set_calculate(self, calculate: dict): + values_get = calculate.get("get") + values_set = calculate.get("set") + self._calculate_get = values_get if values_get else [] + self._calculate_set = values_set if values_set else [] + def get_attribute(self, attribute): return self._attributes.get(attribute) @@ -137,7 +136,7 @@ class MiedaDevice(threading.Thread): new_status[attr] = self._attributes.get(attr) new_status[attribute] = value if set_cmd := self._lua_runtime.build_control(new_status): - self.build_send(set_cmd) + self._build_send(set_cmd) def set_attributes(self, attributes): new_status = {} @@ -150,22 +149,26 @@ class MiedaDevice(threading.Thread): new_status[attribute] = value if has_new: if set_cmd := self._lua_runtime.build_control(new_status): - self.build_send(set_cmd) + self._build_send(set_cmd) - @staticmethod - def fetch_v2_message(msg): - result = [] - while len(msg) > 0: - factual_msg_len = len(msg) - if factual_msg_len < 6: - break - alleged_msg_len = msg[4] + (msg[5] << 8) - if factual_msg_len >= alleged_msg_len: - result.append(msg[:alleged_msg_len]) - msg = msg[alleged_msg_len:] - else: - break - return result, msg + def set_ip_address(self, ip_address): + MideaLogger.debug(f"Update IP address to {ip_address}") + self._ip_address = ip_address + self.close_socket() + + def send_command(self, cmd_type, cmd_body: bytearray): + cmd = MessageQuestCustom(self._device_type, cmd_type, cmd_body) + try: + self._build_send(cmd.serialize().hex()) + except socket.error as e: + MideaLogger.debug( + f"Interface send_command failure, {repr(e)}, " + f"cmd_type: {cmd_type}, cmd_body: {cmd_body.hex()}", + self._device_id + ) + + def register_update(self, update): + self._updates.append(update) def connect(self, refresh=False): try: @@ -175,11 +178,11 @@ class MiedaDevice(threading.Thread): self._socket.connect((self._ip_address, self._port)) MideaLogger.debug(f"Connected", self._device_id) if self._protocol == 3: - self.authenticate() + self._authenticate() MideaLogger.debug(f"Authentication success", self._device_id) - self.device_connected(True) + self._device_connected(True) if refresh: - self.refresh_status() + self._refresh_status() return True except socket.timeout: MideaLogger.debug(f"Connection timed out", self._device_id) @@ -194,10 +197,34 @@ class MiedaDevice(threading.Thread): except Exception as e: MideaLogger.error(f"Unknown error: {e.__traceback__.tb_frame.f_globals['__file__']}, " f"{e.__traceback__.tb_lineno}, {repr(e)}") - self.device_connected(False) + if refresh: + self._device_connected(False) + self._socket = None return False - def authenticate(self): + + def disconnect(self): + self._buffer = b"" + if self._socket: + self._socket.close() + self._socket = None + + @staticmethod + def _fetch_v2_message(msg): + result = [] + while len(msg) > 0: + factual_msg_len = len(msg) + if factual_msg_len < 6: + break + alleged_msg_len = msg[4] + (msg[5] << 8) + if factual_msg_len >= alleged_msg_len: + result.append(msg[:alleged_msg_len]) + msg = msg[alleged_msg_len:] + else: + break + return result, msg + + def _authenticate(self): request = self._security.encode_8370( self._token, MSGTYPE_HANDSHAKE_REQUEST) MideaLogger.debug(f"Handshaking") @@ -208,34 +235,34 @@ class MiedaDevice(threading.Thread): response = response[8: 72] self._security.tcp_key(response, self._key) - def send_message(self, data): + def _send_message(self, data): if self._protocol == 3: - self.send_message_v3(data, msg_type=MSGTYPE_ENCRYPTED_REQUEST) + self._send_message_v3(data, msg_type=MSGTYPE_ENCRYPTED_REQUEST) else: - self.send_message_v2(data) + self._send_message_v2(data) - def send_message_v2(self, data): + def _send_message_v2(self, data): if self._socket is not None: self._socket.send(data) else: - MideaLogger.debug(f"Send failure, device disconnected, data: {data.hex()}") + MideaLogger.debug(f"Command send failure, device disconnected, data: {data.hex()}") - def send_message_v3(self, data, msg_type=MSGTYPE_ENCRYPTED_REQUEST): + def _send_message_v3(self, data, msg_type=MSGTYPE_ENCRYPTED_REQUEST): data = self._security.encode_8370(data, msg_type) - self.send_message_v2(data) + self._send_message_v2(data) - def build_send(self, cmd): - MideaLogger.debug(f"Sending: {cmd}") + def _build_send(self, cmd: str): + MideaLogger.debug(f"Sending: {cmd.lower()}") bytes_cmd = bytes.fromhex(cmd) msg = PacketBuilder(self._device_id, bytes_cmd).finalize() - self.send_message(msg) + self._send_message(msg) - def refresh_status(self): + def _refresh_status(self): for query in self._queries: if query_cmd := self._lua_runtime.build_query(query): - self.build_send(query_cmd) + self._build_send(query_cmd) - def parse_message(self, msg): + def _parse_message(self, msg): if self._protocol == 3: messages, self._buffer = self._security.decode_8370(self._buffer + msg) else: @@ -254,8 +281,7 @@ class MiedaDevice(threading.Thread): cryptographic = message[40:-16] if payload_len % 16 == 0: decrypted = self._security.aes_decrypt(cryptographic) - MideaLogger.debug(f"Received: {decrypted.hex()}") - # 这就是最终消息 + MideaLogger.debug(f"Received: {decrypted.hex().lower()}") if status := self._lua_runtime.decode_status(decrypted.hex()): MideaLogger.debug(f"Decoded: {status}") new_status = {} @@ -265,22 +291,44 @@ class MiedaDevice(threading.Thread): self._attributes[single] = value new_status[single] = value if len(new_status) > 0: - self.update_all(new_status) + for c in self._calculate_get: + lvalue = c.get("lvalue") + rvalue = c.get("rvalue") + if lvalue and rvalue: + calculate = False + for s, v in new_status.items(): + if rvalue.find(f"[{s}]") >= 0: + calculate = True + break + if calculate: + calculate_str1 = \ + (f"{lvalue.replace('[', 'self._attributes[')} = " + f"{rvalue.replace('[', 'self._attributes[')}") \ + .replace("[","[\"").replace("]","\"]") + calculate_str2 = \ + (f"{lvalue.replace('[', 'new_status[')} = " + f"{rvalue.replace('[', 'self._attributes[')}") \ + .replace("[","[\"").replace("]","\"]") + try: + exec(calculate_str1) + exec(calculate_str2) + except Exception: + MideaLogger.warning( + f"Calculation Error: {lvalue} = {rvalue}", self._device_id + ) + self._update_all(new_status) return ParseMessageResult.SUCCESS - def send_heartbeat(self): + def _send_heartbeat(self): msg = PacketBuilder(self._device_id, bytearray([0x00])).finalize(msg_type=0) - self.send_message(msg) + self._send_message(msg) - def device_connected(self, connected=True): + def _device_connected(self, connected=True): self._connected = connected status = {"connected": connected} - self.update_all(status) + self._update_all(status) - def register_update(self, update): - self._updates.append(update) - - def update_all(self, status): + def _update_all(self, status): MideaLogger.debug(f"Status update: {status}") for update in self._updates: update(status) @@ -294,18 +342,7 @@ class MiedaDevice(threading.Thread): if self._is_run: self._is_run = False self._lua_runtime = None - self.close_socket() - - def close_socket(self): - self._buffer = b"" - if self._socket: - self._socket.close() - self._socket = None - - def set_ip_address(self, ip_address): - MideaLogger.debug(f"Update IP address to {ip_address}") - self._ip_address = ip_address - self.close_socket() + self.disconnect() def run(self): while self._is_run: @@ -313,7 +350,7 @@ class MiedaDevice(threading.Thread): if self.connect(refresh=True) is False: if not self._is_run: return - self.close_socket() + self.disconnect() time.sleep(5) timeout_counter = 0 start = time.time() @@ -323,20 +360,20 @@ class MiedaDevice(threading.Thread): while True: try: now = time.time() - if now - previous_refresh >= self._refresh_interval: - self.refresh_status() + if 0 < self._refresh_interval <= now - previous_refresh: + self._refresh_status() previous_refresh = now if now - previous_heartbeat >= self._heartbeat_interval: - self.send_heartbeat() + self._send_heartbeat() previous_heartbeat = now msg = self._socket.recv(512) msg_len = len(msg) if msg_len == 0: raise socket.error("Connection closed by peer") - result = self.parse_message(msg) + result = self._parse_message(msg) if result == ParseMessageResult.ERROR: MideaLogger.debug(f"Message 'ERROR' received") - self.close_socket() + self.disconnect() break elif result == ParseMessageResult.SUCCESS: timeout_counter = 0 @@ -344,16 +381,16 @@ class MiedaDevice(threading.Thread): timeout_counter = timeout_counter + 1 if timeout_counter >= 120: MideaLogger.debug(f"Heartbeat timed out") - self.close_socket() + self.disconnect() break except socket.error as e: MideaLogger.debug(f"Socket error {repr(e)}") - self.close_socket() + self.disconnect() break except Exception as e: MideaLogger.error(f"Unknown error :{e.__traceback__.tb_frame.f_globals['__file__']}, " f"{e.__traceback__.tb_lineno}, {repr(e)}") - self.close_socket() + self.disconnect() break diff --git a/custom_components/midea_meiju_codec/core/discover.py b/custom_components/midea_meiju_codec/core/discover.py index 4f358e5..259aad8 100644 --- a/custom_components/midea_meiju_codec/core/discover.py +++ b/custom_components/midea_meiju_codec/core/discover.py @@ -107,6 +107,8 @@ def discover(discover_type=None, ip_address=None): MideaLogger.debug(f"Found a supported device: {device}") else: MideaLogger.debug(f"Found a unsupported device: {device}") + if ip_address is not None: + break except socket.timeout: break except socket.error as e: diff --git a/custom_components/midea_meiju_codec/core/lua_runtime.py b/custom_components/midea_meiju_codec/core/lua_runtime.py index 70ecebb..70e6a82 100644 --- a/custom_components/midea_meiju_codec/core/lua_runtime.py +++ b/custom_components/midea_meiju_codec/core/lua_runtime.py @@ -2,7 +2,7 @@ import lupa import threading import json from .logger import MideaLogger -lupa.LuaMemoryError + class LuaRuntime: def __init__(self, file): @@ -13,14 +13,15 @@ class LuaRuntime: self._json_to_data = self._runtimes.eval("function(param) return jsonToData(param) end") self._data_to_json = self._runtimes.eval("function(param) return dataToJson(param) end") - def json_to_data(self, json): + def json_to_data(self, json_value): with self._lock: - result = self._json_to_data(json) + result = self._json_to_data(json_value) + return result - def data_to_json(self, data): + def data_to_json(self, data_value): with self._lock: - result = self._data_to_json(data) + result = self._data_to_json(data_value) return result diff --git a/custom_components/midea_meiju_codec/core/security.py b/custom_components/midea_meiju_codec/core/security.py index b04fd6f..aa4d600 100644 --- a/custom_components/midea_meiju_codec/core/security.py +++ b/custom_components/midea_meiju_codec/core/security.py @@ -1,85 +1,170 @@ -import hmac -import logging from Crypto.Cipher import AES from Crypto.Util.Padding import pad, unpad from Crypto.Util.strxor import strxor from Crypto.Random import get_random_bytes from hashlib import md5, sha256 +import hmac + MSGTYPE_HANDSHAKE_REQUEST = 0x0 MSGTYPE_HANDSHAKE_RESPONSE = 0x1 MSGTYPE_ENCRYPTED_RESPONSE = 0x3 MSGTYPE_ENCRYPTED_REQUEST = 0x6 -_LOGGER = logging.getLogger(__name__) - class CloudSecurity: - - def __init__(self, iotKey, loginKey): - self._hmackey = "PROD_VnoClJI9aikS8dyy" - self._iotkey = iotKey - self._loginKey = loginKey + def __init__(self, login_key, iot_key, hmac_key, fixed_key=None, fixed_iv=None): + self._login_key = login_key + self._iot_key = iot_key + self._hmac_key = hmac_key + self._aes_key = None + self._aes_iv = None + self._fixed_key = format(fixed_key, 'x').encode("ascii") if fixed_key else None + self._fixed_iv = format(fixed_iv, 'x').encode("ascii") if fixed_iv else None def sign(self, data: str, random: str) -> str: - msg = self._iotkey - if data: - msg += data + msg = self._iot_key + msg += data msg += random - sign = hmac.new(self._hmackey.encode("ascii"), msg.encode("ascii"), sha256) + sign = hmac.new(self._hmac_key.encode("ascii"), msg.encode("ascii"), sha256) return sign.hexdigest() - def encrypt_password(self, loginId, data): + def encrypt_password(self, login_id, data): m = sha256() m.update(data.encode("ascii")) - login_hash = loginId + m.hexdigest() + self._loginKey + login_hash = login_id + m.hexdigest() + self._login_key m = sha256() m.update(login_hash.encode("ascii")) return m.hexdigest() + def encrypt_iam_password(self, login_id, data) -> str: + raise NotImplementedError - def encrypt_iam_password(self, loginId, data) -> str: + @staticmethod + def get_deviceid(username): + return md5(f"Hello, {username}!".encode("ascii")).digest().hex()[:16] + + @staticmethod + def get_udp_id(appliance_id, method=0): + if method == 0: + bytes_id = bytes(reversed(appliance_id.to_bytes(8, "big"))) + elif method == 1: + bytes_id = appliance_id.to_bytes(6, "big") + elif method == 2: + bytes_id = appliance_id.to_bytes(6, "little") + else: + return None + data = bytearray(sha256(bytes_id).digest()) + for i in range(0, 16): + data[i] ^= data[i + 16] + return data[0: 16].hex() + + def set_aes_keys(self, key, iv): + if isinstance(key, str): + key = key.encode("ascii") + if isinstance(iv, str): + iv = iv.encode("ascii") + self._aes_key = key + self._aes_iv = iv + + def aes_encrypt_with_fixed_key(self, data): + return self.aes_encrypt(data, self._fixed_key, self._fixed_iv) + + def aes_decrypt_with_fixed_key(self, data): + return self.aes_decrypt(data, self._fixed_key, self._fixed_iv) + + def aes_encrypt(self, data, key=None, iv=None): + if key is not None: + aes_key = key + aes_iv = iv + else: + aes_key = self._aes_key + aes_iv = self._aes_iv + if aes_key is None: + raise ValueError("Encrypt need a key") + if isinstance(data, str): + data = bytes.fromhex(data) + if aes_iv is None: # ECB + return AES.new(aes_key, AES.MODE_ECB).encrypt(pad(data, 16)) + else: # CBC + return AES.new(aes_key, AES.MODE_CBC, iv=aes_iv).encrypt(pad(data, 16)) + + def aes_decrypt(self, data, key=None, iv=None): + if key is not None: + aes_key = key + aes_iv = iv + else: + aes_key = self._aes_key + aes_iv = self._aes_iv + if aes_key is None: + raise ValueError("Encrypt need a key") + if isinstance(data, str): + data = bytes.fromhex(data) + if aes_iv is None: # ECB + return unpad(AES.new(aes_key, AES.MODE_ECB).decrypt(data), len(aes_key)).decode() + else: # CBC + return unpad(AES.new(aes_key, AES.MODE_CBC, iv=aes_iv).decrypt(data), len(aes_key)).decode() + + +class MeijuCloudSecurity(CloudSecurity): + def __init__(self, login_key, iot_key, hmac_key): + super().__init__(login_key, iot_key, hmac_key, + 10864842703515613082) + + def encrypt_iam_password(self, login_id, data) -> str: md = md5() md.update(data.encode("ascii")) md_second = md5() md_second.update(md.hexdigest().encode("ascii")) return md_second.hexdigest() - @staticmethod - def get_udpid(data): - data = bytearray(sha256(data).digest()) - for i in range(0, 16): - data[i] ^= data[i + 16] - return data[0: 16].hex() - @staticmethod - def decrypt(data:bytes, key:bytes="96c7acdfdb8af79a".encode()): - return unpad(AES.new(key, AES.MODE_ECB).decrypt(data), 16) +class MSmartCloudSecurity(CloudSecurity): + def __init__(self, login_key, iot_key, hmac_key): + super().__init__(login_key, iot_key, hmac_key, + 13101328926877700970, + 16429062708050928556) - @staticmethod - def encrypt(data:bytes, key:bytes="96c7acdfdb8af79a".encode()): - return AES.new(key, AES.MODE_ECB).encrypt(pad(data, 16)) + def encrypt_iam_password(self, login_id, data) -> str: + md = md5() + md.update(data.encode("ascii")) + md_second = md5() + md_second.update(md.hexdigest().encode("ascii")) + login_hash = login_id + md_second.hexdigest() + self._login_key + sha = sha256() + sha.update(login_hash.encode("ascii")) + return sha.hexdigest() + + def set_aes_keys(self, encrypted_key, encrypted_iv): + key_digest = sha256(self._login_key.encode("ascii")).hexdigest() + tmp_key = key_digest[:16].encode("ascii") + tmp_iv = key_digest[16:32].encode("ascii") + self._aes_key = self.aes_decrypt(encrypted_key, tmp_key, tmp_iv).encode('ascii') + self._aes_iv = self.aes_decrypt(encrypted_iv, tmp_key, tmp_iv).encode('ascii') class LocalSecurity: def __init__(self): self.blockSize = 16 self.iv = b"\0" * 16 - self.aes_key = bytes.fromhex("6a92ef406bad2f0359baad994171ea6d") - self.salt = bytes.fromhex("78686469776a6e6368656b6434643531326368646a783564386534633339344432443753") + self.aes_key = bytes.fromhex( + format(141661095494369103254425781617665632877, 'x') + ) + self.salt = bytes.fromhex( + format(233912452794221312800602098970898185176935770387238278451789080441632479840061417076563, 'x') + ) self._tcp_key = None self._request_count = 0 self._response_count = 0 def aes_decrypt(self, raw): try: - return unpad(AES.new(self.aes_key, AES.MODE_ECB).decrypt(bytearray(raw)), self.blockSize) + return unpad(AES.new(self.aes_key, AES.MODE_ECB).decrypt(bytearray(raw)), 16) except ValueError as e: - _LOGGER.error(f"Error in aes_decrypt: {repr(e)} - data: {raw.hex()}") - return bytearray(0) + return bytearray(0) def aes_encrypt(self, raw): - return AES.new(self.aes_key, AES.MODE_ECB).encrypt(bytearray(pad(raw, self.blockSize))) + return AES.new(self.aes_key, AES.MODE_ECB).encrypt(bytearray(pad(raw, 16))) def aes_cbc_decrypt(self, raw, key): return AES.new(key=key, mode=AES.MODE_CBC, iv=self.iv).decrypt(raw) @@ -155,4 +240,4 @@ class LocalSecurity: if leftover: packets, incomplete = self.decode_8370(leftover) return [data] + packets, incomplete - return [data], b"" \ No newline at end of file + return [data], b"" diff --git a/custom_components/midea_meiju_codec/device_mapping/T0xAC.py b/custom_components/midea_meiju_codec/device_mapping/T0xAC.py index 0a77492..6efa142 100644 --- a/custom_components/midea_meiju_codec/device_mapping/T0xAC.py +++ b/custom_components/midea_meiju_codec/device_mapping/T0xAC.py @@ -1,15 +1,17 @@ from homeassistant.const import * from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass +# from homeassistant.components.binary_sensor import BinarySensorDeviceClass from homeassistant.components.switch import SwitchDeviceClass DEVICE_MAPPING = { "default": { - "manufacturer": "美的", "rationale": ["off", "on"], "queries": [{}, {"query_type": "prevent_straight_wind"}], - "centralized": ["power", "temperature", "small_temperature", "mode", "eco", "comfort_power_save", - "comfort_sleep", "strong_wind", "wind_swing_lr", "wind_swing_lr", "wind_speed", - "ptc", "dry"], + "centralized": [ + "power", "temperature", "small_temperature", "mode", "eco", + "comfort_power_save", "comfort_sleep", "strong_wind", + "wind_swing_lr", "wind_swing_lr", "wind_speed","ptc", "dry" + ], "entities": { Platform.CLIMATE: { "thermostat": { @@ -60,42 +62,37 @@ DEVICE_MAPPING = { }, Platform.SWITCH: { "dry": { - "name": "干燥", "device_class": SwitchDeviceClass.SWITCH, }, "prevent_straight_wind": { - "name": "防直吹", "device_class": SwitchDeviceClass.SWITCH, "rationale": [1, 2] }, "aux_heat": { - "name": "电辅热", "device_class": SwitchDeviceClass.SWITCH, } }, Platform.SENSOR: { "indoor_temperature": { - "name": "室内温度", "device_class": SensorDeviceClass.TEMPERATURE, - "unit_of_measurement": TEMP_CELSIUS, + "unit_of_measurement": UnitOfTemperature.CELSIUS, "state_class": SensorStateClass.MEASUREMENT }, "outdoor_temperature": { - "name": "室外机温度", "device_class": SensorDeviceClass.TEMPERATURE, - "unit_of_measurement": TEMP_CELSIUS, + "unit_of_measurement": UnitOfTemperature.CELSIUS, "state_class": SensorStateClass.MEASUREMENT }, } } }, "22012227": { - "manufacturer": "美的", "rationale": ["off", "on"], "queries": [{}, {"query_type": "prevent_straight_wind"}], "centralized": ["power", "temperature", "small_temperature", "mode", "eco", "comfort_power_save", - "comfort_sleep", "strong_wind", "wind_swing_lr", "wind_swing_lr", "wind_speed", + "comfort_sleep", "strong_wind", "wind_swing_lr", "wind_swing_ud", "wind_speed", "ptc", "dry"], + "entities": { Platform.CLIMATE: { "thermostat": { @@ -140,7 +137,7 @@ DEVICE_MAPPING = { "aux_heat": "ptc", "min_temp": 17, "max_temp": 30, - "temperature_unit": TEMP_CELSIUS, + "temperature_unit": UnitOfTemperature.CELSIUS, "precision": PRECISION_HALVES, } }, @@ -160,82 +157,12 @@ DEVICE_MAPPING = { } }, Platform.SENSOR: { - "indoor_temperature": { - "name": "室内温度", - "device_class": SensorDeviceClass.TEMPERATURE, - "unit_of_measurement": TEMP_CELSIUS, - "state_class": SensorStateClass.MEASUREMENT - }, "outdoor_temperature": { "name": "室外机温度", "device_class": SensorDeviceClass.TEMPERATURE, - "unit_of_measurement": TEMP_CELSIUS, + "unit_of_measurement": UnitOfTemperature.CELSIUS, "state_class": SensorStateClass.MEASUREMENT }, - }, - Platform.BINARY_SENSOR: { - "power": {} - }, - Platform.SELECT: { - "preset_modes": { - "options": { - "none": { - "eco": "off", - "comfort_power_save": "off", - "comfort_sleep": "off", - "strong_wind": "off" - }, - "eco": {"eco": "on"}, - "comfort": {"comfort_power_save": "on"}, - "sleep": {"comfort_sleep": "on"}, - "boost": {"strong_wind": "on"} - } - }, - "hvac_modes": { - "options": { - "off": {"power": "off"}, - "heat": {"power": "on", "mode": "heat"}, - "cool": {"power": "on", "mode": "cool"}, - "auto": {"power": "on", "mode": "auto"}, - "dry": {"power": "on", "mode": "dry"}, - "fan_only": {"power": "on", "mode": "fan"} - } - } - }, - Platform.WATER_HEATER:{ - "water_heater": { - "name": "热水器", - "power": "power", - "operation_list": { - "off": {"power": "off"}, - "heat": {"power": "on", "mode": "heat"}, - "cool": {"power": "on", "mode": "cool"}, - "auto": {"power": "on", "mode": "auto"}, - "dry": {"power": "on", "mode": "dry"}, - "fan_only": {"power": "on", "mode": "fan"} - }, - "target_temperature": ["temperature", "small_temperature"], - "current_temperature": "indoor_temperature", - "min_temp": 17, - "max_temp": 30, - "temperature_unit": TEMP_CELSIUS, - "precision": PRECISION_HALVES, - } - }, - Platform.FAN: { - "fan": { - "power": "power", - "preset_modes": { - "off": {"power": "off"}, - "heat": {"power": "on", "mode": "heat"}, - "cool": {"power": "on", "mode": "cool"}, - "auto": {"power": "on", "mode": "auto"}, - "dry": {"power": "on", "mode": "dry"}, - "fan_only": {"power": "on", "mode": "fan"} - }, - "oscillate": "wind_swing_lr", - "speeds": list({"wind_speed": value + 1} for value in range(0, 100)), - } } } } diff --git a/custom_components/midea_meiju_codec/device_mapping/T0xEA.py b/custom_components/midea_meiju_codec/device_mapping/T0xEA.py new file mode 100644 index 0000000..13934ad --- /dev/null +++ b/custom_components/midea_meiju_codec/device_mapping/T0xEA.py @@ -0,0 +1,177 @@ +from homeassistant.const import * +from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass +from homeassistant.components.binary_sensor import BinarySensorDeviceClass + +DEVICE_MAPPING = { + "default": { + "rationale": [0, 1], + "calculate": { + "get": [ + { + "lvalue": "[remaining_time]", + "rvalue": "[left_time_hour] * 60 + [left_time_min]" + }, + { + "lvalue": "[warming_time]", + "rvalue": "[warm_time_hour] * 60 + [warm_time_min]" + }, + { + "lvalue": "[delay_time]", + "rvalue": "[order_time_hour] * 60 + [order_time_min]", + } + ], + "set": { + } + }, + "entities": { + Platform.SENSOR: { + "work_stage": {}, + "voltage": { + "device_class": SensorDeviceClass.VOLTAGE, + "unit_of_measurement": UnitOfElectricPotential.VOLT, + "state_class": SensorStateClass.MEASUREMENT + }, + "top_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "bottom_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "remaining_time": { + "unit_of_measurement": UnitOfTime.MINUTES + }, + "warming_time": { + "unit_of_measurement": UnitOfTime.MINUTES + }, + "delay_time": { + "unit_of_measurement": UnitOfTime.MINUTES + }, + }, + Platform.BINARY_SENSOR: { + "top_hot": { + "device_class": BinarySensorDeviceClass.RUNNING + }, + "flank_hot": { + "device_class": BinarySensorDeviceClass.RUNNING + }, + "bottom_hot": { + "device_class": BinarySensorDeviceClass.RUNNING + } + }, + Platform.SELECT: { + "mode": { + "options": { + "Rice": {"mode": "essence_rice", "work_status": "cooking"}, + "Porridge": {"mode": "gruel", "work_status": "cooking"}, + "热饭": {"mode": "heat_rice", "work_status": "cooking"}, + "Congee": {"mode": "boil_congee", "work_status": "cooking"}, + "Soup": {"mode": "cook_soup", "work_status": "cooking"}, + "Steam": {"mode": "stewing", "work_status": "cooking"}, + } + }, + "rice_type": { + "options": { + "None": {"rice_type": "none"}, + "Northeast rice": {"rice_type": "northeast"}, + "Long-grain rice": {"rice_type": "longrain"}, + "Fragrant rice": {"rice_type": "fragrant"}, + "Wuchang rice": {"rice_type": "five"}, + } + }, + "work_status": { + "options": { + "Stop": {"work_status": "cancel"}, + "Cooking": {"work_status": "cooking"}, + "Warming": {"work_status": "keep_warm"}, + "Soaking": {"work_status": "awakening_rice"}, + "Delay": {"work_status": "schedule"} + } + } + } + } + }, + "61001527": { + "rationale": [0, 1], + "calculate": { + "get": [ + { + "lvalue": "[remaining_time]", + "rvalue": "[left_time_hour] * 60 + [left_time_min]" + }, + { + "lvalue": "[warming_time]", + "rvalue": "[warm_time_hour] * 60 + [warm_time_min]" + }, + { + "lvalue": "[delay_time]", + "rvalue": "[order_time_hour] * 60 + [order_time_min]", + } + ], + "set": { + } + }, + "entities": { + Platform.SENSOR: { + "work_stage": {}, + "voltage": { + "device_class": SensorDeviceClass.VOLTAGE, + "unit_of_measurement": UnitOfElectricPotential.VOLT, + "state_class": SensorStateClass.MEASUREMENT + }, + "top_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "bottom_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "remaining_time": { + "unit_of_measurement": UnitOfTime.MINUTES + }, + "warming_time": { + "unit_of_measurement": UnitOfTime.MINUTES + }, + "delay_time": { + "unit_of_measurement": UnitOfTime.MINUTES + }, + }, + Platform.SELECT: { + "mode": { + "options": { + "精华饭": {"mode": "essence_rice", "work_status": "cooking"}, + "稀饭": {"mode": "gruel", "work_status": "cooking"}, + "热饭": {"mode": "heat_rice", "work_status": "cooking"}, + "煮粥": {"mode": "boil_congee", "work_status": "cooking"}, + "煲汤": {"mode": "cook_soup", "work_status": "cooking"}, + "蒸煮": {"mode": "stewing", "work_status": "cooking"}, + } + }, + "rice_type": { + "options": { + "无": {"rice_type": "none"}, + "东北大米": {"rice_type": "northeast"}, + "长粒米": {"rice_type": "longrain"}, + "香米": {"rice_type": "fragrant"}, + "五常大米": {"rice_type": "five"}, + } + }, + "work_status": { + "options": { + "停止": {"work_status": "cancel"}, + "烹饪": {"work_status": "cooking"}, + "保温": {"work_status": "keep_warm"}, + "醒米": {"work_status": "awakening_rice"}, + "预约": {"work_status": "schedule"}, + } + } + } + } + } +} diff --git a/custom_components/midea_meiju_codec/device_mapping/example.py b/custom_components/midea_meiju_codec/device_mapping/example.py new file mode 100644 index 0000000..d244c0b --- /dev/null +++ b/custom_components/midea_meiju_codec/device_mapping/example.py @@ -0,0 +1,267 @@ +from homeassistant.const import * +from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass +from homeassistant.components.binary_sensor import BinarySensorDeviceClass +from homeassistant.components.switch import SwitchDeviceClass + +DEVICE_MAPPING = { + "default": { + "manufacturer": "小天鹅", + "rationale": ["off", "on"], + "queries": [{}, {"query_type": "prevent_straight_wind"}], + "centralized": [ + "power", "temperature", "small_temperature", "mode", "eco", + "comfort_power_save", "comfort_sleep", "strong_wind", + "wind_swing_lr", "wind_swing_lr", "wind_speed","ptc", "dry" + ], + "calculate": { + "get": [ + { + "lvalue": "[target_temperature_new]", + "rvalue": "[target_temperature] / 2" + }, + { + "lvalue": "[current_temperature_new]", + "rvalue": "[current_temperature] / 2" + } + ], + "set": { + { + "lvalue": "[target_temperature]", + "rvalue": "[target_temperature_new] * 2" + }, + { + "lvalue": "[current_temperature]", + "rvalue": "[current_temperature_new] * 2" + } + } + }, + "entities": { + Platform.CLIMATE: { + "thermostat": { + "name": "Thermostat", + "power": "power", + "hvac_modes": { + "off": {"power": "off"}, + "heat": {"power": "on", "mode": "heat"}, + "cool": {"power": "on", "mode": "cool"}, + "auto": {"power": "on", "mode": "auto"}, + "dry": {"power": "on", "mode": "dry"}, + "fan_only": {"power": "on", "mode": "fan"} + }, + "preset_modes": { + "none": { + "eco": "off", + "comfort_power_save": "off", + "comfort_sleep": "off", + "strong_wind": "off" + }, + "eco": {"eco": "on"}, + "comfort": {"comfort_power_save": "on"}, + "sleep": {"comfort_sleep": "on"}, + "boost": {"strong_wind": "on"} + }, + "swing_modes": { + "off": {"wind_swing_lr": "off", "wind_swing_ud": "off"}, + "both": {"wind_swing_lr": "on", "wind_swing_ud": "on"}, + "horizontal": {"wind_swing_lr": "on", "wind_swing_ud": "off"}, + "vertical": {"wind_swing_lr": "off", "wind_swing_ud": "on"}, + }, + "fan_modes": { + "silent": {"wind_speed": 20}, + "low": {"wind_speed": 40}, + "medium": {"wind_speed": 60}, + "high": {"wind_speed": 80}, + "full": {"wind_speed": 100}, + "auto": {"wind_speed": 102} + }, + "target_temperature": ["temperature", "small_temperature"], + "current_temperature": "indoor_temperature", + "aux_heat": "ptc", + "min_temp": 17, + "max_temp": 30, + "temperature_unit": TEMP_CELSIUS, + "precision": PRECISION_HALVES, + } + }, + Platform.SWITCH: { + "dry": { + "device_class": SwitchDeviceClass.SWITCH, + }, + "prevent_straight_wind": { + "device_class": SwitchDeviceClass.SWITCH, + "rationale": [1, 2] + }, + "aux_heat": { + "device_class": SwitchDeviceClass.SWITCH, + } + }, + Platform.SENSOR: { + "indoor_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "outdoor_temperature": { + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + } + } + }, + "22012227": { + "manufacturer": "TOSHIBA", + "rationale": ["off", "on"], + "queries": [], + "centralized": ["power", "temperature", "small_temperature", "mode", "eco", "comfort_power_save", + "comfort_sleep", "strong_wind", "wind_swing_lr", "wind_swing_ud", "wind_speed", + "ptc", "dry"], + "entities": { + Platform.CLIMATE: { + "thermostat": { + "name": "Thermostat", + "power": "power", + "hvac_modes": { + "off": {"power": "off"}, + "heat": {"power": "on", "mode": "heat"}, + "cool": {"power": "on", "mode": "cool"}, + "auto": {"power": "on", "mode": "auto"}, + "dry": {"power": "on", "mode": "dry"}, + "fan_only": {"power": "on", "mode": "fan"} + }, + "preset_modes": { + "none": { + "eco": "off", + "comfort_power_save": "off", + "comfort_sleep": "off", + "strong_wind": "off" + }, + "eco": {"eco": "on"}, + "comfort": {"comfort_power_save": "on"}, + "sleep": {"comfort_sleep": "on"}, + "boost": {"strong_wind": "on"} + }, + "swing_modes": { + "off": {"wind_swing_lr": "off", "wind_swing_ud": "off"}, + "both": {"wind_swing_lr": "on", "wind_swing_ud": "on"}, + "horizontal": {"wind_swing_lr": "on", "wind_swing_ud": "off"}, + "vertical": {"wind_swing_lr": "off", "wind_swing_ud": "on"}, + }, + "fan_modes": { + "silent": {"wind_speed": 20}, + "low": {"wind_speed": 40}, + "medium": {"wind_speed": 60}, + "high": {"wind_speed": 80}, + "full": {"wind_speed": 100}, + "auto": {"wind_speed": 102} + }, + "target_temperature": "target_temperature_new", + "current_temperature": "current_temperature_new", + "aux_heat": "ptc", + "min_temp": 17, + "max_temp": 30, + "temperature_unit": UnitOfTemperature.CELSIUS, + "precision": PRECISION_HALVES, + } + }, + Platform.WATER_HEATER:{ + "water_heater": { + "name": "Gas Water Heater", + "power": "power", + "operation_list": { + "off": {"power": "off"}, + "heat": {"power": "on", "mode": "heat"}, + "cool": {"power": "on", "mode": "cool"}, + "auto": {"power": "on", "mode": "auto"}, + "dry": {"power": "on", "mode": "dry"}, + "fan_only": {"power": "on", "mode": "fan"} + }, + "target_temperature": ["temperature", "small_temperature"], + "current_temperature": "indoor_temperature", + "min_temp": 17, + "max_temp": 30, + "temperature_unit": UnitOfTemperature.CELSIUS, + "precision": PRECISION_HALVES, + } + }, + Platform.FAN: { + "fan": { + "power": "power", + "preset_modes": { + "off": {"power": "off"}, + "heat": {"power": "on", "mode": "heat"}, + "cool": {"power": "on", "mode": "cool"}, + "auto": {"power": "on", "mode": "auto"}, + "dry": {"power": "on", "mode": "dry"}, + "fan_only": {"power": "on", "mode": "fan"} + }, + "oscillate": "wind_swing_lr", + "speeds": list({"wind_speed": value + 1} for value in range(0, 100)), + } + }, + Platform.SWITCH: { + "dry": { + "name": "干燥", + "device_class": SwitchDeviceClass.SWITCH, + }, + "prevent_straight_wind": { + "name": "防直吹", + "device_class": SwitchDeviceClass.SWITCH, + "rationale": [1, 2] + }, + "aux_heat": { + "name": "电辅热", + "device_class": SwitchDeviceClass.SWITCH, + } + }, + Platform.SENSOR: { + "indoor_temperature": { + "name": "室内温度", + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + "outdoor_temperature": { + "name": "室外温度", + "device_class": SensorDeviceClass.TEMPERATURE, + "unit_of_measurement": UnitOfTemperature.CELSIUS, + "state_class": SensorStateClass.MEASUREMENT + }, + }, + Platform.BINARY_SENSOR: { + "dust_full": { + "icon": "mdi:air-filter", + "name": "滤网尘满", + "device_class": BinarySensorDeviceClass.PROBLEM + }, + "move_detect": {} + }, + Platform.SELECT: { + "preset_modes": { + "options": { + "none": { + "eco": "off", + "comfort_power_save": "off", + "comfort_sleep": "off", + "strong_wind": "off" + }, + "eco": {"eco": "on"}, + "comfort": {"comfort_power_save": "on"}, + "sleep": {"comfort_sleep": "on"}, + "boost": {"strong_wind": "on"} + } + }, + "hvac_modes": { + "options": { + "off": {"power": "off"}, + "heat": {"power": "on", "mode": "heat"}, + "cool": {"power": "on", "mode": "cool"}, + "auto": {"power": "on", "mode": "auto"}, + "dry": {"power": "on", "mode": "dry"}, + "fan_only": {"power": "on", "mode": "fan"} + } + } + } + } + } +} diff --git a/custom_components/midea_meiju_codec/midea_entities.py b/custom_components/midea_meiju_codec/midea_entities.py index 825f41d..f5a5828 100644 --- a/custom_components/midea_meiju_codec/midea_entities.py +++ b/custom_components/midea_meiju_codec/midea_entities.py @@ -22,9 +22,8 @@ class MideaEntity(Entity): self._config = config self._device_name = self._device.device_name self._rationale = rationale - rationale = config.get("rationale") - if rationale: - self._rationale = rationale + if rationale_local := config.get("rationale"): + self._rationale = rationale_local if self._rationale is None: self._rationale = ["off", "on"] self._attr_native_unit_of_measurement = self._config.get("unit_of_measurement") @@ -44,6 +43,10 @@ class MideaEntity(Entity): self._attr_name = f"{self._device_name} {name}" self.entity_id = self._attr_unique_id + @property + def device(self): + return self._device + @property def should_poll(self): return False diff --git a/custom_components/midea_meiju_codec/services.yaml b/custom_components/midea_meiju_codec/services.yaml new file mode 100644 index 0000000..1c48df0 --- /dev/null +++ b/custom_components/midea_meiju_codec/services.yaml @@ -0,0 +1,18 @@ +set_attributes: + fields: + device_id: + example: "1234567890" + attributes: + example: + "power": "on" + "mode": "cool" + +set_mode: +send_command: + fields: + device_id: + example: "1234567890" + cmd_type: + example: 2 + cmd_body: + example: "B0FF01370E0000A500" diff --git a/custom_components/midea_meiju_codec/translations/en.json b/custom_components/midea_meiju_codec/translations/en.json index 16e50e2..360e322 100644 --- a/custom_components/midea_meiju_codec/translations/en.json +++ b/custom_components/midea_meiju_codec/translations/en.json @@ -1,43 +1,104 @@ { "config": { "error": { - "account_invalid": "登录美居失败，是否已修改过密码", - "invalid_input": "无效的输入，请输入有效IP地址或auto", - "login_failed": "无法登录到美居，请检查用户名或密码", - "offline_error": "只能配置在线设备", - "download_lua_failed": "下载设备协议脚本失败", - "discover_failed": "无法在本地搜索到该设备", - "no_new_devices": "没有可用的设备", - "cant_get_token": "无法连接美的云获取设备关键信息(Token和Key)", - "config_incorrect": "配置信息不正确, 请检查后重新输入", - "connect_error": "无法连接到指定设备" + "no_home": "No available home", + "account_invalid": "Failed to authenticate on Midea cloud, the password may be changed", + "invalid_input": "Illegal input, IP address or 'auto' needed", + "login_failed": "Failed to login, wrong account or password", + "offline_error": "Only the online appliance can be configured", + "download_lua_failed": "Failed to download lua script of appliance", + "discover_failed": "The appliance can't be found on the local network", + "no_new_devices": "No any new available can be found in your home", + "connect_error": "Can't connect to the appliance" }, "step": { "user": { "data": { - "username": "用户名（手机号）", - "password": "密码" + "account": "Account", + "password": "Password" }, - "description": "登录并保存你的美居账号及密码", - "title": "登录" + "description": "Login and save storage your account", + "title": "Login" }, "home": { - "title": "家庭", + "title": "Home", "data": { - "home": "选择设备所在家庭" + "home": "Choose a location where your appliance in" } }, "device": { - "title": "设备", + "title": "Appliances", "data": { - "device": "选择要添加的设备" + "device_id": "Choice a appliance to add" } }, "discover": { - "description": "获取设备信息，设备必须位于本地局域网内", - "title": "设备信息", + "description": "Discover the appliance, it must in the local area work", + "title": "Appliance info", "data": { - "ip_address": "设备地址(输入auto自动搜索设备)" + "ip_address": "IP address('auto' for discovery automatic)" + } + } + } + }, + "options": { + "step": { + "init": { + "data": { + "option": "Option" + }, + "title": "Configure" + }, + "reset":{ + "title": "Reset the configuration of appliance", + "description": "Remove the old configuration and make a new configuration use template\nIf your configuration was modified, the changes will lost\nIf your appliance type or model not in template, then the new configuration won't be made", + "data":{ + "check": "I know that, do it" + } + }, + "configure": { + "data": { + "ip_address": "IP address", + "refresh_interval": "Refresh interval(0 means not refreshing actively)" + }, + "title": "Option" + } + }, + "abort":{ + "reset_success": "Reset done", + "account_unsupport_config": "Doesn't support this operation" + } + }, + "services": { + "set_attribute": { + "name": "set the attributes", + "description": "Set the attributes of appliance in a dict", + "fields" : { + "device_id": { + "name": "Appliance code", + "description": "Appliance code (Device ID)" + }, + "attributes": { + "name": "Attributes", + "description": "Attributes to set" + } + } + }, + "send_command": { + "name": "Custom command", + "description": "Send a custom command to appliance", + "fields" : { + "device_id": { + "name": "Appliance code", + "description": "Appliance code (Device ID)" + }, + "cmd_type": { + "name": "Type of command", + "description": "It can be 2 (query) or 3 (control)" + }, + "cmd_body": { + "name": "Body of command", + "description": "The body of command without the MSmart protocol head and the checksum at the end" } } } diff --git a/custom_components/midea_meiju_codec/translations/zh-Hans.json b/custom_components/midea_meiju_codec/translations/zh-Hans.json index 16e50e2..c0fd640 100644 --- a/custom_components/midea_meiju_codec/translations/zh-Hans.json +++ b/custom_components/midea_meiju_codec/translations/zh-Hans.json @@ -1,21 +1,20 @@ { "config": { "error": { - "account_invalid": "登录美居失败，是否已修改过密码", + "no_home": "未找到可用家庭", + "account_invalid": "登录美的云服务器失败，是否已修改过密码", "invalid_input": "无效的输入，请输入有效IP地址或auto", - "login_failed": "无法登录到美居，请检查用户名或密码", + "login_failed": "无法登录到选择的美的云服务器，请检查用户名或密码", "offline_error": "只能配置在线设备", "download_lua_failed": "下载设备协议脚本失败", "discover_failed": "无法在本地搜索到该设备", "no_new_devices": "没有可用的设备", - "cant_get_token": "无法连接美的云获取设备关键信息(Token和Key)", - "config_incorrect": "配置信息不正确, 请检查后重新输入", "connect_error": "无法连接到指定设备" }, "step": { "user": { "data": { - "username": "用户名（手机号）", + "account": "用户名", "password": "密码" }, "description": "登录并保存你的美居账号及密码", @@ -30,7 +29,7 @@ "device": { "title": "设备", "data": { - "device": "选择要添加的设备" + "device_id": "选择要添加的设备" } }, "discover": { @@ -41,5 +40,67 @@ } } } + }, + "options": { + "step": { + "init": { + "data": { + "option": "操作" + }, + "title": "选项" + }, + "reset":{ + "title": "重置配置文件", + "description": "移除已有的设备配置，并使用标准模板重新生成设备配置\n如果你的设备配置json文件进行过修改，重置之后修改将丢失\n如果标准模板中没有该设备类型，则不会生成设备配置", + "data":{ + "check": "我知道了，重置吧" + } + }, + "configure": { + "data": { + "ip_address": "IP地址", + "refresh_interval": "刷新间隔(设0为不进行主动刷新)" + }, + "title": "配置" + } + }, + "abort":{ + "reset_success": "重置完成，已尝试生成新的配置", + "account_unsupport_config": "账户配置不支持该操作" + } + }, + "services": { + "set_attribute": { + "name": "设置属性", + "description": "设置设备的属性值(可多属性一起设置)", + "fields" : { + "device_id": { + "name": "设备编码", + "description": "设备编码(Device ID)" + }, + "attributes": { + "name": "属性集合", + "description": "要设置的属性" + } + } + }, + "send_command": { + "name": "自定义命令", + "description": "向设备发送一个自定义命令", + "fields" : { + "device_id": { + "name": "设备编码", + "description": "设备编码(Device ID)" + }, + "cmd_type": { + "name": "命令类型", + "description": "命令类型，可以为2(查询)或3(设置)" + }, + "cmd_body": { + "name": "命令体", + "description": "命令的消息体(不包括前部的MSmart协议头及后部的校验码)" + } + } + } } -} \ No newline at end of file +}