net_mqtt.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#include <ove/net_mqtt.h>
#include <ove/types.hpp>
#include <string_view>
 
#ifdef CONFIG_OVE_NET_MQTT
 
namespace ove {
 
namespace mqtt {
 
enum class Qos : uint8_t {
    AtMostOnce  = 0, 
    AtLeastOnce = 1, 
};
 
struct Config {
    const char *host{};            
    uint16_t    port{1883};        
    const char *client_id{};       
    const char *username{};        
    const char *password{};        
    uint16_t    keep_alive_s{30};  
    bool        use_tls{false};    
};
 
class Client {
public:
    using MsgFn = void (*)(std::string_view topic,
                   std::string_view payload);
 
    Client() {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_mqtt_client_init(&handle_, &storage_);
#else
        int err = ove_mqtt_client_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Client() {
        if (!handle_) return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_mqtt_client_deinit(handle_);
#else
        ove_mqtt_client_destroy(handle_);
#endif
    }
 
    Client(const Client &) = delete;
    Client &operator=(const Client &) = delete;
    Client(Client &&) = delete;
    Client &operator=(Client &&) = delete;
 
    [[nodiscard]] int connect(const Config &cfg,
                  MsgFn on_message = nullptr) {
        s_msg_fn_ = on_message;
        ove_mqtt_config_t c{};
        c.host         = cfg.host;
        c.port         = cfg.port;
        c.client_id    = cfg.client_id;
        c.username     = cfg.username;
        c.password     = cfg.password;
        c.keep_alive_s = cfg.keep_alive_s;
        c.use_tls      = cfg.use_tls ? 1 : 0;
        c.on_message   = on_message ? trampoline_ : nullptr;
        c.user_data    = nullptr;
        return ove_mqtt_connect(handle_, &c);
    }
 
    void disconnect() { ove_mqtt_disconnect(handle_); }
 
    [[nodiscard]] int publish(const char *topic, const void *payload,
                  size_t len, Qos qos = Qos::AtMostOnce) {
        return ove_mqtt_publish(handle_, topic, payload, len,
                       static_cast<ove_mqtt_qos_t>(qos));
    }
 
    [[nodiscard]] int publish(const char *topic,
                  std::string_view payload,
                  Qos qos = Qos::AtMostOnce) {
        return publish(topic, payload.data(), payload.size(), qos);
    }
 
    [[nodiscard]] int subscribe(const char *topic,
                    Qos qos = Qos::AtMostOnce) {
        return ove_mqtt_subscribe(handle_, topic,
                     static_cast<ove_mqtt_qos_t>(qos));
    }
 
    [[nodiscard]] int unsubscribe(const char *topic) {
        return ove_mqtt_unsubscribe(handle_, topic);
    }
 
    [[nodiscard]] int loop(uint32_t timeout_ms = 500) {
        return ove_mqtt_loop(handle_, timeout_ms);
    }
 
    bool valid() const { return handle_ != nullptr; }
 
    ove_mqtt_client_t handle() const { return handle_; }
 
private:
    static void trampoline_(const char *topic, size_t topic_len,
                const void *payload, size_t payload_len,
                void * /*user_data*/) {
        if (s_msg_fn_) {
            s_msg_fn_(
                std::string_view(topic, topic_len),
                std::string_view(
                    static_cast<const char *>(payload),
                    payload_len));
        }
    }
 
    static inline MsgFn s_msg_fn_{};
 
    ove_mqtt_client_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_mqtt_client_storage_t storage_ = {};
#endif
};
 
} /* namespace mqtt */
 
} // namespace ove
 
#endif /* CONFIG_OVE_NET_MQTT */