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 <ove/error.hpp>
#include <string_view>
 
#ifdef CONFIG_OVE_NET_MQTT
 
namespace ove::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() noexcept
    {
        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]] Result<void> connect(const Config &cfg, MsgFn on_message = nullptr) noexcept
    {
        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 from_rc(ove_mqtt_connect(handle_, &c));
    }
 
    void disconnect()
    {
        ove_mqtt_disconnect(handle_);
    }
 
    [[nodiscard]] Result<void> publish(const char *topic, const void *payload, size_t len,
                       Qos qos = Qos::AtMostOnce) noexcept
    {
        return from_rc(ove_mqtt_publish(handle_, topic, payload, len,
                        static_cast<ove_mqtt_qos_t>(qos)));
    }
 
    [[nodiscard]] Result<void> publish(const char *topic, std::string_view payload,
                       Qos qos = Qos::AtMostOnce) noexcept
    {
        return publish(topic, payload.data(), payload.size(), qos);
    }
 
    [[nodiscard]] Result<void> subscribe(const char *topic, Qos qos = Qos::AtMostOnce) noexcept
    {
        return from_rc(
            ove_mqtt_subscribe(handle_, topic, static_cast<ove_mqtt_qos_t>(qos)));
    }
 
    [[nodiscard]] Result<void> unsubscribe(const char *topic) noexcept
    {
        return from_rc(ove_mqtt_unsubscribe(handle_, topic));
    }
 
    [[nodiscard]] Result<void>
    loop(std::chrono::nanoseconds timeout = std::chrono::milliseconds{500}) noexcept
    {
        return from_rc(ove_mqtt_loop(handle_, to_timeout_ns(timeout)));
    }
 
    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 ove::mqtt */
 
#endif /* CONFIG_OVE_NET_MQTT */