linuxSmartie/src/hass.cpp

#include <hass.hpp>

HomeAssistant::HomeAssistant(std::string addr, std::string ent) {
    address = addr;
    entity = ent;
}

HomeAssistant::~HomeAssistant() {
    disconnect();
}

void HomeAssistant::event_handler(struct lws *wsi, enum lws_callback_reasons reason, char *in) {
    ArduinoJson::JsonDocument json;
    switch (reason) {
        case LWS_CALLBACK_CLIENT_CONNECTION_ERROR: {
            std::println("[HomeAssistant] websocket conn error: {}", in ? in : "(null)");
            return;
        }

        case LWS_CALLBACK_CLIENT_RECEIVE: {
            ArduinoJson::deserializeJson(json, in);
            std::string ha_type = json["type"].as<std::string>();
            // std::println("[HomeAssistant] got event type: {} ", ha_type);

            if (ha_type == "auth_required") {
                json.clear();
                json["type"] = "auth";
                json["access_token"] = HASS_TOKEN;
                ArduinoJson::serializeJson(json, tx);
                break;
            }

            if (ha_type == "auth_ok") {
                std::println("[HomeAssistant] subscribing to entity \"{}\"", entity);
                json.clear();
                json["id"] = id++;
                json["type"] = "subscribe_entities";
                json["entity_ids"][0] = entity.c_str();
                ArduinoJson::serializeJson(json, tx);
                break;
            }

            if (ha_type == "result") {
                if (json["success"].as<std::string>() == "false")
                    std::println("[HomeAssistant] api said success was \"false\" on message id {}", id - 1);
                break;
            }

            if (ha_type == "event") {
                state = json["event"]["c"][entity]["+"]["s"].as<float>();
                break;
            }

            std::println("[HomeAssistant] unhandled event: {}", (char *)in);
            break;
        }

        case LWS_CALLBACK_CLIENT_ESTABLISHED: {
            std::println("[HomeAssistant] Websocket connected");
            break;
        }

        case LWS_CALLBACK_CLIENT_CLOSED: {
            std::println("[HomeAssistant] Websocket closed");
            return;
        }

        case LWS_CALLBACK_CLIENT_WRITEABLE: {
            /* skip whole callback if there's no tx to send */
            if (tx.size() > 0) {
                // std::println("[HomeAssistant] sending {}", tx);
                size_t msgLen = LWS_PRE + tx.size();
                unsigned char *buf = (unsigned char *)malloc(msgLen);
                if (buf) {
                    memcpy(&buf[LWS_PRE], tx.c_str(), tx.size());
                    if (!lws_write(wsi, &buf[LWS_PRE], tx.size(), LWS_WRITE_TEXT))
                        ;
                    tx = "";
                    free(buf);
                }
            }
            break;
        }

        default:
            break;
    }
}

int HomeAssistant::callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) {
    HomeAssistant *self = static_cast<HomeAssistant *>(user);
    self->event_handler(wsi, reason, (char *)in);
    return 0;
}

int HomeAssistant::connect() {
    struct lws_client_connect_info i;
    struct lws_context_creation_info info;

    lws_set_log_level(LLL_ERR | LLL_WARN, lwsl_emit_syslog);

    memset(&i, 0, sizeof(i));
    memset(&info, 0, sizeof info);

    static const struct lws_protocols protocols[] = {
        {"lws-minimal-client", callback, sizeof(void *), 0, 0, NULL, 0},
        LWS_PROTOCOL_LIST_TERM};

    static const struct lws_extension extensions[] = {
        {"permessage-deflate",
         lws_extension_callback_pm_deflate,
         "permessage-deflate"
         "; client_no_context_takeover"
         "; client_max_window_bits"},
        {NULL, NULL, NULL}};

    info.options = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
    info.port = CONTEXT_PORT_NO_LISTEN;
    info.protocols = protocols;
    info.fd_limit_per_thread = 1 + 1 + 1;
    info.extensions = extensions;

    context = lws_create_context(&info);
    if (!context) {
        std::println("[HomeAssistant] error creating context");
        return -1;
    }

    i.context = context;
    i.port = 443;
    i.address = address.c_str();
    i.path = "/api/websocket";
    i.host = i.address;
    i.origin = i.address;
    i.ssl_connection = LCCSCF_USE_SSL | LCCSCF_PRIORITIZE_READS;
    i.protocol = NULL;
    i.userdata = this;
    i.local_protocol_name = "lws-minimal-client";

    websock = lws_client_connect_via_info(&i);
    if (!websock) {
        std::println("[HomeAssistant] error creating lws client");
        return -1;
    }
    return 0;
}

void HomeAssistant::service(int timeout_ms) {
    lws_callback_on_writable(websock);
    lws_service(context, timeout_ms);
}

void HomeAssistant::disconnect() {
    lws_context_destroy(context);
}