New panel design

main/api/ha_client.c

@@ -0,0 +1,263 @@
+/*
+ * Home Assistant REST transport. See ha_client.h for the contract and why
+ * this is plain HTTP.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "cJSON.h"
+#include "esp_http_client.h"
+#include "esp_log.h"
+
+#include "app_config.h"
+#include "ha_client.h"
+#include "ha_template.h"
+
+static const char *TAG = "ha_client";
+
+#define HA_URL_MAX  128
+#define HA_BODY_MAX 1024
+
+/*
+ * The forecast reply is the big one: six days of conditions and temperatures,
+ * measured at ~1.1KB. The state template is ~400 bytes. 4KB leaves room for
+ * HA to grow a field without silently truncating.
+ */
+#define HA_RESP_MAX 4096
+
+/* Local network, no TLS handshake, so these can be far tighter than the
+ * cloud client's. A LAN request that has not answered in 5s is not going to. */
+#define HA_TIMEOUT_MS 5000
+
+static char resp_buf[HA_RESP_MAX];
+static size_t resp_len;
+static bool resp_truncated;
+
+/*
+ * Kept alive between polls. Re-creating the client each time re-opens the TCP
+ * connection, which is cheap on a LAN but not free, and this runs inside the
+ * window where rendering is paused.
+ */
+static esp_http_client_handle_t client;
+
+/*
+ * Long-lived HA tokens are JWTs -- ~180-200 characters, not the 30-40 an
+ * "API key" suggests. 320 leaves room for "Bearer " plus a token noticeably
+ * longer than the ones HA issues today.
+ */
+static char auth_header[320];
+
+static esp_err_t http_event_handler(esp_http_client_event_t *evt)
+{
+    switch (evt->event_id) {
+    case HTTP_EVENT_ON_DATA:
+        /* Responses are chunked, so Content-Length is often -1; accumulate
+         * into a fixed buffer rather than sizing an allocation from it. */
+        if (resp_len + evt->data_len < sizeof(resp_buf)) {
+            memcpy(resp_buf + resp_len, evt->data, evt->data_len);
+            resp_len += evt->data_len;
+        } else if (!resp_truncated) {
+            resp_truncated = true;   /* once per response, not per chunk */
+            ESP_LOGW(TAG, "Response exceeds %d bytes, truncating", HA_RESP_MAX);
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return ESP_OK;
+}
+
+static void client_drop(void)
+{
+    if (client != NULL) {
+        esp_http_client_cleanup(client);
+        client = NULL;
+    }
+}
+
+esp_err_t ha_client_init(void)
+{
+    if (HA_HOST[0] == '\0' || HA_TOKEN[0] == '\0') {
+        ESP_LOGW(TAG, "HA_HOST or HA_TOKEN not set in main/app_config.h -- "
+                      "Home Assistant will not be polled");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    const int n = snprintf(auth_header, sizeof(auth_header), "Bearer %s", HA_TOKEN);
+    if (n < 0 || n >= (int)sizeof(auth_header)) {
+        ESP_LOGE(TAG, "Token too long for the auth header buffer");
+        return ESP_ERR_INVALID_SIZE;
+    }
+
+    return ESP_OK;
+}
+
+/*
+ * One POST. `path` and `body` are borrowed; the reply lands in resp_buf.
+ *
+ * The client is rebuilt whenever the URL changes, because the three endpoints
+ * this talks to (template, service call, forecast) are different paths on the
+ * same host and esp_http_client keeps the connection per-handle.
+ */
+static esp_err_t ha_post(const char *path, const char *body)
+{
+    char url[HA_URL_MAX];
+    const int n = snprintf(url, sizeof(url), "http://%s:%d%s", HA_HOST, HA_PORT, path);
+    if (n < 0 || n >= (int)sizeof(url)) {
+        ESP_LOGE(TAG, "URL truncated for path %s", path);
+        return ESP_ERR_INVALID_SIZE;
+    }
+
+    if (client == NULL) {
+        const esp_http_client_config_t config = {
+            .url = url,
+            .method = HTTP_METHOD_POST,
+            .timeout_ms = HA_TIMEOUT_MS,
+            .event_handler = http_event_handler,
+            .keep_alive_enable = true,
+        };
+        client = esp_http_client_init(&config);
+        if (client == NULL) {
+            return ESP_ERR_NO_MEM;
+        }
+        esp_http_client_set_header(client, "Authorization", auth_header);
+        esp_http_client_set_header(client, "Content-Type", "application/json");
+    } else if (esp_http_client_set_url(client, url) != ESP_OK) {
+        client_drop();
+        return ESP_FAIL;
+    }
+
+    esp_http_client_set_method(client, HTTP_METHOD_POST);
+    esp_http_client_set_post_field(client, body, (int)strlen(body));
+
+    resp_len = 0;
+    resp_truncated = false;
+
+    esp_err_t err = esp_http_client_perform(client);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "POST %s failed: %s", path, esp_err_to_name(err));
+        client_drop();   /* a half-open connection would fail every later poll */
+        return err;
+    }
+
+    const int status = esp_http_client_get_status_code(client);
+    if (status != 200) {
+        ESP_LOGE(TAG, "HTTP %d from %s", status, path);
+        if (status == 401) {
+            ESP_LOGE(TAG, "Token rejected -- check HA_TOKEN in app_config.h");
+        }
+        client_drop();
+        return ESP_FAIL;
+    }
+
+    if (resp_len == 0) {
+        /* Service calls legitimately return an empty body. */
+        resp_buf[0] = '\0';
+        return ESP_OK;
+    }
+
+    resp_buf[resp_len] = '\0';
+    return ESP_OK;
+}
+
+esp_err_t ha_fetch_state(ha_data_t *data)
+{
+    if (data == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    /*
+     * The template is JSON-escaped by cJSON rather than by hand: it is full of
+     * quotes and braces, and getting the escaping subtly wrong yields a 400
+     * that looks like a template bug.
+     */
+    cJSON *req = cJSON_CreateObject();
+    if (req == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+    if (cJSON_AddStringToObject(req, "template", HA_STATE_TEMPLATE) == NULL) {
+        cJSON_Delete(req);
+        return ESP_ERR_NO_MEM;
+    }
+
+    char *body = cJSON_PrintUnformatted(req);
+    cJSON_Delete(req);
+    if (body == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    const esp_err_t err = ha_post("/api/template", body);
+    cJSON_free(body);
+
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    if (!ha_parse_json(resp_buf, data)) {
+        ESP_LOGE(TAG, "State response was not valid JSON");
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t ha_fetch_forecast(ha_data_t *data)
+{
+    if (data == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    /* return_response is required: without it HA runs the service and returns
+     * nothing, which looks like an empty forecast rather than a mistake. */
+    const esp_err_t err = ha_post(
+        "/api/services/weather/get_forecasts?return_response", HA_FORECAST_BODY);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    if (!ha_parse_forecast_json(resp_buf, data)) {
+        ESP_LOGE(TAG, "Forecast response could not be parsed");
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t ha_light_command(int index, bool on, int16_t brightness)
+{
+    if (index < 0 || index >= HA_LIGHT_COUNT) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    const ha_light_cfg_t *cfg = &HA_LIGHTS[index];
+    const char *domain = ha_service_domain(cfg->entity_id);
+
+    char path[HA_URL_MAX];
+    int n = snprintf(path, sizeof(path), "/api/services/%s/turn_%s",
+                     domain, on ? "on" : "off");
+    if (n < 0 || n >= (int)sizeof(path)) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+
+    char body[HA_BODY_MAX];
+    if (on && brightness >= 0 && cfg->dimmable) {
+        n = snprintf(body, sizeof(body),
+                     "{\"entity_id\":\"%s\",\"brightness\":%d}",
+                     cfg->entity_id, brightness);
+    } else {
+        /* No brightness key: turning on without one makes HA restore the
+         * light's previous level, which is what a user expects from a tap. */
+        n = snprintf(body, sizeof(body), "{\"entity_id\":\"%s\"}", cfg->entity_id);
+    }
+    if (n < 0 || n >= (int)sizeof(body)) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+
+    ESP_LOGI(TAG, "%s -> %s%s", cfg->entity_id, on ? "on" : "off",
+             (on && brightness >= 0 && cfg->dimmable) ? " (with brightness)" : "");
+
+    return ha_post(path, body);
+}