Migrate to MQTT from HTTPS polling

custom_components/hildebrandglow/__init__.py

@@ -6,8 +6,8 @@
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
-from .glow import Glow
+from .const import APP_ID, DOMAIN
+from .glow import Glow, InvalidAuth
 
 CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({})}, extra=vol.ALLOW_EXTRA)
 
@@ -23,7 +23,19 @@ async def async_setup(hass: HomeAssistant, config: Dict[str, Any]) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Hildebrand Glow from a config entry."""
-    glow = Glow(entry.data["app_id"], entry.data["token"])
+    glow = Glow(APP_ID, entry.data["username"], entry.data["password"])
+
+    try:
+        await hass.async_add_executor_job(glow.authenticate)
+        await hass.async_add_executor_job(glow.retrieve_cad_hardwareId)
+        await hass.async_add_executor_job(glow.connect_mqtt)
+
+        while not glow.broker_active:
+            continue
+
+    except InvalidAuth:
+        return False
+
     hass.data[DOMAIN][entry.entry_id] = glow
 
     for component in PLATFORMS:

custom_components/hildebrandglow/config_flow.py

@@ -5,19 +5,18 @@
 import voluptuous as vol
 from homeassistant import config_entries, core, data_entry_flow
 
-from .const import DOMAIN  # pylint:disable=unused-import
+from .const import APP_ID, DOMAIN  # pylint:disable=unused-import
 from .glow import CannotConnect, Glow, InvalidAuth
 
 _LOGGER = logging.getLogger(__name__)
 
-DATA_SCHEMA = vol.Schema({"app_id": str, "username": str, "password": str})
+DATA_SCHEMA = vol.Schema({"username": str, "password": str})
 
 
 def config_object(data: dict, glow: Dict[str, Any]) -> Dict[str, Any]:
     """Prepare a ConfigEntity with authentication data and a temporary token."""
     return {
         "name": glow["name"],
-        "app_id": data["app_id"],
         "username": data["username"],
         "password": data["password"],
         "token": glow["token"],
@@ -31,7 +30,7 @@ async def validate_input(hass: core.HomeAssistant, data: dict) -> Dict[str, Any]
     Data has the keys from DATA_SCHEMA with values provided by the user.
     """
     glow = await hass.async_add_executor_job(
-        Glow.authenticate, data["app_id"], data["username"], data["password"]
+        Glow.authenticate, APP_ID, data["username"], data["password"]
     )
 
     # Return some info we want to store in the config entry.

custom_components/hildebrandglow/const.py

@@ -1,3 +1,4 @@
 """Constants for the Hildebrand Glow integration."""
 
 DOMAIN = "hildebrandglow"
+APP_ID = "b0f1b774-a586-4f72-9edd-27ead8aa7a8d"

custom_components/hildebrandglow/glow.py

@@ -1,31 +1,54 @@
 """Classes for interacting with the Glowmarkt API."""
+from __future__ import annotations
+
 from pprint import pprint
-from typing import Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List
 
+import paho.mqtt.client as mqtt
 import requests
 from homeassistant import exceptions
 
+from .mqttpayload import MQTTPayload
+
+if TYPE_CHECKING:
+    from .sensor import GlowConsumptionCurrent
+
 
 class Glow:
     """Bindings for the Hildebrand Glow Platform API."""
 
     BASE_URL = "https://api.glowmarkt.com/api/v0-1"
+    HILDEBRAND_MQTT_HOST = "glowmqtt.energyhive.com"
+    HILDEBRAND_MQTT_TOPIC = "SMART/HILD/{hardwareId}"
+
+    username: str
+    password: str
+
+    token: str
 
-    def __init__(self, app_id: str, token: str):
+    hardwareId: str
+    broker: mqtt.Client
+
+    sensors: Dict[str, GlowConsumptionCurrent] = {}
+
+    def __init__(self, app_id: str, username: str, password: str):
         """Create an authenticated Glow object."""
         self.app_id = app_id
-        self.token = token
+        self.username = username
+        self.password = password
 
-    @classmethod
-    def authenticate(cls, app_id: str, username: str, password: str) -> Dict[str, Any]:
-        """
-        Attempt to authenticate with Glowmarkt.
+        self.broker = mqtt.Client()
+        self.broker.username_pw_set(username=self.username, password=self.password)
+        self.broker.on_connect = self._cb_on_connect
+        self.broker.on_message = self._cb_on_message
 
-        Returns a time-limited access token.
-        """
-        url = f"{cls.BASE_URL}/auth"
-        auth = {"username": username, "password": password}
-        headers = {"applicationId": app_id}
+        self.broker_active = False
+
+    def authenticate(self) -> None:
+        """Attempt to authenticate with Glowmarkt."""
+        url = f"{self.BASE_URL}/auth"
+        auth = {"username": self.username, "password": self.password}
+        headers = {"applicationId": self.app_id}
 
         try:
             response = requests.post(url, json=auth, headers=headers)
@@ -35,11 +58,67 @@ def authenticate(cls, app_id: str, username: str, password: str) -> Dict[str, An
         data = response.json()
 
         if data["valid"]:
-            return data
+            self.token = data["token"]
         else:
             pprint(data)
             raise InvalidAuth
 
+    def retrieve_devices(self) -> List[Dict[str, Any]]:
+        """Retrieve the Zigbee devices known to Glowmarkt for the authenticated user."""
+        url = f"{self.BASE_URL}/device"
+        headers = {"applicationId": self.app_id, "token": self.token}
+
+        try:
+            response = requests.get(url, headers=headers)
+        except requests.Timeout:
+            raise CannotConnect
+
+        if response.status_code != 200:
+            raise InvalidAuth
+
+        data = response.json()
+        return data
+
+    def retrieve_cad_hardwareId(self) -> str:
+        """Locate the Consumer Access Device's hardware ID from the devices list."""
+        ZIGBEE_GLOW_STICK = "1027b6e8-9bfd-4dcb-8068-c73f6413cfaf"
+
+        devices = self.retrieve_devices()
+
+        cad: Dict[str, Any] = next(
+            (dev for dev in devices if dev["deviceTypeId"] == ZIGBEE_GLOW_STICK), None
+        )
+
+        self.hardwareId = cad["hardwareId"]
+
+        return self.hardwareId
+
+    def connect_mqtt(self) -> None:
+        """Connect the internal MQTT client to the discovered CAD."""
+        self.broker.connect(self.HILDEBRAND_MQTT_HOST)
+
+        self.broker.loop_start()
+
+    def _cb_on_connect(self, client, userdata, flags, rc):
+        """Receive a CONNACK message from the server."""
+        client.subscribe(self.HILDEBRAND_MQTT_TOPIC.format(hardwareId=self.hardwareId))
+
+        self.broker_active = True
+
+    def _cb_on_disconnect(self, client, userdata, rc):
+        """Receive notice the MQTT connection has disconnected."""
+        self.broker_active = False
+
+    def _cb_on_message(self, client, userdata, msg):
+        """Receive a PUBLISH message from the server."""
+        payload = MQTTPayload(msg.payload)
+
+        if "electricity.consumption" in self.sensors:
+            self.sensors["electricity.consumption"].update_state(payload)
+
+        if "gas.consumption" in self.sensors:
+            self.sensors["gas.consumption"].update_state(payload)
+
     def retrieve_resources(self) -> List[Dict[str, Any]]:
         """Retrieve the resources known to Glowmarkt for the authenticated user."""
         url = f"{self.BASE_URL}/resource"
@@ -72,6 +151,10 @@ def current_usage(self, resource: Dict[str, Any]) -> Dict[str, Any]:
         data = response.json()
         return data
 
+    def register_sensor(self, sensor, resource):
+        """Register a live sensor for dispatching MQTT messages."""
+        self.sensors[resource["classifier"]] = sensor
+
 
 class CannotConnect(exceptions.HomeAssistantError):
     """Error to indicate we cannot connect."""

custom_components/hildebrandglow/manifest.json

@@ -3,12 +3,10 @@
   "name": "Hildebrand Glow",
   "config_flow": true,
   "documentation": "https://github.com/unlobito/ha-hildebrandglow",
-  "requirements": ["requests"],
+  "requirements": ["requests", "paho-mqtt"],
   "ssdp": [],
   "zeroconf": [],
   "homekit": {},
   "dependencies": [],
-  "codeowners": [
-    "@unlobito"
-  ]
-}
+  "codeowners": ["@unlobito"]
+}