Fix for HA 2024.1.0 - replace deprecated unit constants

custom_components/xiaomi_miot_raw/__init__.py

@@ -195,6 +195,7 @@ async def async_remove_entry(hass, entry):
 async def _setup_micloud_entry(hass, config_entry):
     """Thanks to @AlexxIT """
     data: dict = config_entry.data.copy()
+    hass.data[DOMAIN]['micloud_config'] = data
     server_location = data.get('server_location') or 'cn'
 
     session = aiohttp_client.async_create_clientsession(hass, auto_cleanup=False)

custom_components/xiaomi_miot_raw/basic_dev_class.py

@@ -2,7 +2,7 @@
 import json
 import time
 import logging
-from datetime import timedelta
+from datetime import timedelta, datetime
 from functools import partial
 from dataclasses import dataclass
 
@@ -62,7 +62,9 @@
 
 class GenericMiotDevice(Entity):
     """通用 MiOT 设备"""
-
+
+    lastAutoUpdateAccountTime=datetime.now()-timedelta(seconds=3600)
+
     def __init__(self, device, config, device_info, hass = None, mi_type = None):
         """Initialize the entity."""
 
@@ -506,7 +508,56 @@ def pre_process_data(key, value):
                         statedict[key] = pre_process_data(key, dict1[value['siid']][value['piid']])
 
                 else:
-                    pass
+                    # auth err
+                    # 小米账号登录信息失效
+                    # 自动重新登录，间隔3600秒
+                    lostTime=(datetime.now()-GenericMiotDevice.lastAutoUpdateAccountTime).total_seconds()
+                    _LOGGER.debug("miaccount auth err:lostTime:%d" % (lostTime))
+                    if (lostTime>3600):
+                        _LOGGER.warning("auto update mi_account token")
+                        GenericMiotDevice.lastAutoUpdateAccountTime=datetime.now()
+
+                        config=self.hass.data[DOMAIN]['micloud_config']
+                        #_LOGGER.debug(f"self.hass.data[DOMAIN]['config']: {json.dumps (config)}")
+                        if 'username' in config:
+                            cloud=self._cloud_instance
+                            resp = await cloud.login(config['username'],
+                                                config['password'])
+                            if resp == (0, None):
+                                #让新 token 实时生效
+                                for item in self.hass.data[DOMAIN]['cloud_instance_list']:
+                                  mc = item['cloud_instance']
+                                  mc.login_by_credientals(
+                                    cloud.auth["user_id"],
+                                    cloud.auth['service_token'],
+                                    cloud.auth['ssecurity']
+                                  )
+
+                                if self.hass.config_entries.async_entries(DOMAIN):  #更新每个设备的token
+                                  _LOGGER.warning("Found existing config entries")
+                                  for entry in self.hass.config_entries.async_entries(DOMAIN):
+                                    if (
+                                      entry.data.get("update_from_cloud")
+                                    ):
+                                      _LOGGER.warning("Updating existing entry")
+                                      update_from_cloud=entry.data.get("update_from_cloud")
+                                      update_from_cloud_new={
+                                         "did": update_from_cloud["did"],
+                                         "userId": update_from_cloud["userId"],
+                                         "serviceToken": cloud.auth['service_token'],
+                                         "ssecurity": cloud.auth['ssecurity'],
+                                         "server_location": update_from_cloud["server_location"]
+                                      }
+                                      entry_data_new=dict(entry.data)
+                                      entry_data_new.update({"update_from_cloud":update_from_cloud_new})
+                                      entry_id = entry.entry_id
+                                      self.hass.data[DOMAIN]['configs'][entry_id] = entry_data_new 
+                                      self.hass.config_entries.async_update_entry(  #保存新token到文件
+                                        entry,
+                                        data=entry_data_new,
+                                     )
+                            else: 
+                                _LOGGER.error("config.data no username")
 
             self._fail_count = 0
             self._state_attrs.update(statedict)
@@ -681,8 +732,7 @@ def _handle_coordinator_update(self) -> None:
     def _handle_platform_specific_attrs(self):
         pass
 
-    @asyncio.coroutine
-    def async_service_handler(self, service):
+    async def async_service_handler(self, service):
         """Map services to methods on XiaomiMiioDevice."""
         method = SERVICE_TO_METHOD.get(service.service)
         params = {
@@ -702,11 +752,11 @@ def async_service_handler(self, service):
 
         update_tasks = []
         for device in devices:
-            yield from getattr(device, method["method"])(**params)
+            yield getattr(device, method["method"])(**params)
             update_tasks.append(device.async_update_ha_state(True))
 
         if update_tasks:
-            yield from asyncio.wait(update_tasks, loop=self.hass.loop)
+            yield asyncio.wait(update_tasks, loop=self.hass.loop)
 
 class ToggleableMiotDevice(GenericMiotDevice, ToggleEntity):
     def __init__(self, device, config, device_info, hass = None, mi_type = None):

custom_components/xiaomi_miot_raw/binary_sensor.py

@@ -58,7 +58,6 @@
 }
 
 # pylint: disable=unused-argument
-@asyncio.coroutine
 async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     hass.data[DOMAIN]['add_handler'].setdefault(TYPE, {})
     if 'config_entry' in config:

custom_components/xiaomi_miot_raw/camera.py

@@ -0,0 +1,151 @@
+"""Platform for camera integration."""
+import asyncio
+import logging
+from functools import partial
+import collections
+
+from datetime import timedelta
+import json
+from collections import OrderedDict
+import homeassistant.helpers.config_validation as cv
+import voluptuous as vol
+from homeassistant.components.camera import (
+    SUPPORT_ON_OFF, SUPPORT_STREAM,
+    PLATFORM_SCHEMA,
+    Camera
+)
+from homeassistant.const import *
+from homeassistant.exceptions import PlatformNotReady
+from homeassistant.util import color
+from miio.exceptions import DeviceException
+from .deps.miio_new import MiotDevice
+import miio
+import copy
+
+from .basic_dev_class import (
+    GenericMiotDevice,
+    ToggleableMiotDevice,
+    MiotSubDevice,
+    MiotSubToggleableDevice,
+    MiotIRDevice,
+)
+from . import async_generic_setup_platform
+from .deps.const import (
+    DOMAIN,
+    ATTR_SYSSTATUS,
+    CONF_UPDATE_INSTANT,
+    CONF_MAPPING,
+    CONF_CONTROL_PARAMS,
+    CONF_CLOUD,
+    CONF_MODEL,
+    ATTR_STATE_VALUE,
+    ATTR_MODEL,
+    ATTR_FIRMWARE_VERSION,
+    ATTR_HARDWARE_VERSION,
+    SCHEMA,
+    MAP,
+    DUMMY_IP,
+    DUMMY_TOKEN,
+)
+
+TYPE = 'camera'
+
+_LOGGER = logging.getLogger(__name__)
+SCAN_INTERVAL = timedelta(seconds=10)
+DEFAULT_NAME = "Generic MIoT " + TYPE
+DATA_KEY = TYPE + '.' + DOMAIN
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
+    SCHEMA
+)
+
+# pylint: disable=unused-argument
+@asyncio.coroutine
+async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    await async_generic_setup_platform(
+        hass,
+        config,
+        async_add_devices,
+        discovery_info,
+        TYPE,
+        {'default': MiotCamera}
+    )
+
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    config = copy.copy(hass.data[DOMAIN]['configs'].get(config_entry.entry_id, dict(config_entry.data)))
+    await async_setup_platform(hass, config, async_add_entities)
+
+
+class MiotCamera(GenericMiotDevice, Camera):
+    def enable_motion_detection(self) -> None:
+        pass
+
+    def disable_motion_detection(self) -> None:
+        pass
+
+    def __init__(self, device, config, device_info, hass, main_mi_type):
+        self._device: miio.chuangmi_camera.ChuangmiCamera = None  # Just for type hint
+        self._state: bool = None
+        GenericMiotDevice.__init__(self, device, config, device_info, hass, main_mi_type)
+        Camera.__init__(self)
+        self.register_callback(self.update_callback)
+
+    @property
+    def should_poll(self):
+        return True
+
+    def update_callback(self):
+        device_status = self.get_devicestatus()
+        # sleep will return [{'sysstatus': 'sleep'}]
+        # otherwise will return all other status
+        self._state = (len(device_status) > 1)
+        _LOGGER.debug(f"camera.update_callback result: {self._state}")
+
+    def get_devicestatus(self):
+        return self._device.send('get_devicestatus', {
+            'alarmsensitivity': "",
+            'cameraprompt': "",
+            'flip': "",
+            'infraredlight': "",
+            'ledstatus': "",
+            'recordtype': "",
+            'wakeuplevel': "",
+        })
+
+    @property
+    def supported_features(self) -> int:
+        return SUPPORT_ON_OFF
+
+    @property
+    def is_recording(self) -> bool:
+        return self._state
+
+    @property
+    def is_streaming(self) -> bool:
+        return False
+
+    @property
+    def is_on(self) -> bool:
+        return True
+
+    async def async_turn_on(self) -> None:
+        await self.async_do_turn_on(True)
+
+    async def async_turn_off(self) -> None:
+        await self.async_do_turn_on(False)
+
+    async def async_do_turn_on(self, new_status) -> None:
+        _LOGGER.info(f"Start camera.async_do_turn_on( {new_status} )")
+
+        if new_status:
+            cmd = "normal"
+        else:
+            cmd = "sleep"
+        result = self._device.send("set_" + ATTR_SYSSTATUS, [cmd])
+        if result != ['ok']:
+            _LOGGER.warning("result for send {}, {}".format(cmd, result))
+            return
+
+        self._state = new_status
+        self.schedule_update_ha_state()

custom_components/xiaomi_miot_raw/climate.py

@@ -75,7 +75,6 @@
 
 SCAN_INTERVAL = timedelta(seconds=10)
 # pylint: disable=unused-argument
-@asyncio.coroutine
 async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     hass.data[DOMAIN]['add_handler'].setdefault(TYPE, {})
     if 'config_entry' in config:

custom_components/xiaomi_miot_raw/config_flow.py

@@ -1,6 +1,7 @@
 import json
 import re
 
+import logging
 import asyncio
 from types import coroutine
 from typing import OrderedDict
@@ -40,6 +41,8 @@
 from .deps.special_devices import SPECIAL_DEVICES
 from .deps.xiaomi_cloud_new import MiCloud
 
+_LOGGER = logging.getLogger(__name__)
+
 SERVERS = {
     'cn': "China",
     'de': "Europe",
@@ -735,6 +738,40 @@ async def async_step_update_xiaomi_account(self, user_input=None, error=None, hi
                 if resp == (0, None):
                     self._all_config.update(user_input)
                     self._all_config.update(cloud.auth)
+
+                    #让新 token 实时生效
+                    for item in self.hass.data[DOMAIN]['cloud_instance_list']:
+                      mc = item['cloud_instance']
+                      mc.login_by_credientals(
+                        cloud.auth["user_id"],
+                        cloud.auth['service_token'],
+                        cloud.auth['ssecurity']
+                      )
+
+                    if self.hass.config_entries.async_entries(DOMAIN):  #更新每个设备的token
+                      _LOGGER.info("Found existing config entries")
+                      for entry in self.hass.config_entries.async_entries(DOMAIN):
+                        if (
+                          entry.data.get("update_from_cloud")
+                        ):
+                          _LOGGER.info("Updating existing entry")
+                          update_from_cloud=entry.data.get("update_from_cloud")
+                          update_from_cloud_new={
+                             "did": update_from_cloud["did"],
+                             "userId": update_from_cloud["userId"],
+                             "serviceToken": cloud.auth['service_token'],
+                             "ssecurity": cloud.auth['ssecurity'],
+                             "server_location": update_from_cloud["server_location"]
+                          }
+                          entry_data_new=dict(entry.data)
+                          entry_data_new.update({"update_from_cloud":update_from_cloud_new})
+                          entry_id = entry.entry_id
+                          self.hass.data[DOMAIN]['configs'][entry_id] = entry_data_new 
+                          self.hass.config_entries.async_update_entry(  #保存新token到文件
+                            entry,
+                            data=entry_data_new,
+                         )
+
                     self._steps.pop(0)
                     return await self._steps[0]
                 elif resp[0] == -2:

custom_components/xiaomi_miot_raw/cover.py

@@ -60,7 +60,6 @@
 SCAN_INTERVAL = timedelta(seconds=2)
 # pylint: disable=unused-argument
 
-@asyncio.coroutine
 async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     hass.data[DOMAIN]['add_handler'].setdefault(TYPE, {})
     if 'config_entry' in config:
@@ -121,7 +120,7 @@ def is_closed(self):
         """ Most of Xiaomi covers does not report position as 0 when they are fully closed.
             It can be 0, 1, 2... So we consider it closed when it is <= 3. The _current_position
             has been converted so it is always percentage. (#227) """
-        return self.current_cover_position <= 3
+        return int(self.current_cover_position) <= 3
 
     @property
     def is_closing(self):