Subversion Repositories ESP8266_P1_Meter

#ifndef __MQTT_REMOTE_H__

#define __MQTT_REMOTE_H__

#include "IMQTTRemote.h"

#include <freertos/FreeRTOS.h>

#include <freertos/event_groups.h>

#include <functional>

#include <map>

#include <mqtt_client.h>

#include <optional>

#include <string>

namespace MQTTRemoteLog {

const char TAG[] = "MQTTRemote";

} // namespace MQTTRemoteLog

namespace MQTTRemoteDefaults {

const uint32_t CONNECTION_STATUS_STACK_SIZE = 4096;

const uint32_t CONNECTION_STATUS_TASK_PRIORITY = 7;

} // namespace MQTTRemoteDefaults

/**

 * @brief MQTT wrapper for setting up MQTT connection (and will) and provide API for sending and subscribing to

 * messages.

 */

class MQTTRemote : public IMQTTRemote {

public:

  enum ConnectionState : uint8_t {

    Connected = BIT0,

    Disconnected = BIT1,

  };

  /**

   * Additional configuration where most user can go with defaults.

   */

  struct Configuration {

// ESP-IDF 4.4 backward compatibility

#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)

    typedef esp_mqtt_client_config_t::broker_t::verification_t verification_t;

#else

    // See

    // https://github.com/espressif/esp-mqtt/blob/ae53d799da294f03ef65c33e88fa33648e638134/include/mqtt_client.h#L244

    struct verification_t {

      bool use_global_ca_store = false;

      esp_err_t (*crt_bundle_attach)(void *conf) = nullptr;

      const char *certificate = nullptr;

      size_t certificate_len = 0;

      bool skip_cert_common_name_check = false;

      const struct psk_key_hint *psk_hint_key = nullptr;

      const char **alpn_protos = nullptr;

    };

#endif

    /**

     * Maximum message size, in bytes, for incoming messages. Messages larger than this will be truncated.

     * This will be allocated on the heap upon MQTTRemote object creation.

     */

    uint32_t rx_buffer_size = 1024;

    /**

     * Maximum message size, in bytes, for outgoing messages. Messages larger than this will be truncated.

     * This will be allocated on the heap upon MQTTRemote object creation.

     */

    uint32_t tx_buffer_size = 1024;

    /**

     * Task size to use for the ESP-IDF MQTT task. If you are handling large and/or many messages (queues), you might

     * need to increase this.

     * Normally defaults to 6144 bytes, setting this to non std::opt will override setting from menuconfig.

     */

    std::optional<uint32_t> task_size = 4096;

    /**

     * MQTT keep alive interval, in seconds. If the client fails to communicate with the broker within the specified

     * Keep Alive period, the LWT/Last Will message is sent (by the broker).

     */

    uint32_t keep_alive_s = 10;

    /**

     * Values, see esp_mqtt_transport_t:

     * - MQTT_TRANSPORT_OVER_TCP = mqtt

     * - MQTT_TRANSPORT_OVER_SSL = mqtts (TLS)

     * - MQTT_TRANSPORT_OVER_WS = ws (websockets)

     * - MQTT_TRANSPORT_OVER_WSS = wss (websockets with TLS)

     *

     * If not set, will try to decude the transport to use given the host, based on schemes `mqtt`, `mqtts`, `ws`,

     * `wss`. If no scheme is found, will default to `mqtt`.

     */

    std::optional<esp_mqtt_transport_t> transport = std::nullopt;

    /**

     * If using TLS, this configures the certificate verification. Must be set if using TLS.

     *

     * With this, you can configure to use your own private certificate, or using the global bundle.

     *

     * Example to use the global bundle:

     * ```cpp

     *   #include <esp_rls.h>

     *

     *  .vertification = {

     *    .use_global_ca_store = true,

     *  },

     * ```

     *

     * Then before calling start():

     *

     * ```cpp

     *   mbedtls_ssl_config conf;

     *   mbedtls_ssl_config_init(&conf);

     *   esp_tls_init_global_ca_store();

     * ```

     * Here you have the option to use other TLS implementation like mbedtls or wolfssl.

     *

     *

     * Example how to use letsencrypt (or similary for your own certificates):

     * 1. Download the ISRG Root X1 PEM file from https://letsencrypt.org/certs/isrgrootx1.pem

     * 2. Add in main directory

     * 3. Add `target_add_binary_data(${COMPONENT_TARGET} "isrgrootx1.pem" TEXT)` to your CMakeLists.txt

     *

     * Setup verification as follows:

     * ```cpp

     *   extern const uint8_t isrgrootx1_pem_start[] asm("_binary_isrgrootx1_pem_start");

     *

     *  .vertification = {

     *    .certificate = (const char *)isrgrootx1_pem_start,

     *  },

     * ```

     *

     * If using your own certificate, you might need to set `skip_cert_common_name_check` to true in the verification.

     */

    verification_t verification = {};

  };

  /**

   * @brief Construct a new MQTTRemote object

   *

   * To set log level for this object, use: esp_log_level_set(MQTTRemoteLog::TAG, ESP_LOG_*);

   *

   * A call to start() most follow.

   *

   * @param client_id Base ID for this device. This is used for the last will / status

   * topic. Example, if this is "esp_now_router", then the status/last will topic will be "esp_now_router/status". This

   * is also used as client ID for the MQTT connection. This has to be [a-zA-Z0-9_] only and unique among all MQTT

   * clients on the server. It should also be stable across connections.

   * @param host MQTT hostname or IP for MQTT server. Supports `mqtt`, `mqtts`, `ws`, `wss` schemes. For example,

   * mqtts://hostname or just hostname/IP. If not using schemes, transport must be set in Configuration. Remember to

   * also specify the correct port to use for your schema.

   * @param port MQTT port number.

   * @param username MQTT username.

   * @param password MQTT password.

   */

  MQTTRemote(std::string client_id, std::string host, int port, std::string username, std::string password)

      : MQTTRemote(std::move(client_id), std::move(host), port, std::move(username), std::move(password),

                   Configuration{}) {}

  /**

   * @brief Construct a new MQTTRemote object

   *

   * To set log level for this object, use: esp_log_level_set(MQTTRemoteLog::TAG, ESP_LOG_*);

   *

   * A call to start() most follow.

   *

   * @param client_id Base ID for this device. This is used for the last will / status

   * topic. Example, if this is "esp_now_router", then the status/last will topic will be "esp_now_router/status". This

   * is also used as client ID for the MQTT connection. This has to be [a-zA-Z0-9_] only and unique among all MQTT

   * clients on the server. It should also be stable across connections.

   * @param host MQTT hostname or IP for MQTT server.

   * @param port MQTT port number.

   * @param username MQTT username.

   * @param password MQTT password.

   * @param configuration Additional configuration where most user can go with defaults.

   */

  MQTTRemote(std::string client_id, std::string host, int port, std::string username, std::string password,

             Configuration configuration);

  /**

   * @brief Call once there is a WIFI connection on which the host can be reached.

   * Will connect to the server and setup any subscriptions as well as start the MQTT loop.

   * @param on_connection_change optional callback on connection state change. Will be called when the client is

   * connected to server (every time, so expect calls on reconnection), and on disconnect. The parameter will be true on

   * new connection and false on disconnection. This callback will run from a dedicated task. Task size and priority can

   * be set.

   * @param task_size the stack size for the task that will call the on_connection_change callback, if set.

   * @param task_priority the priority for the task that will call the on_connection_change callback, if set.

   *

   * NOTE: Can only be called once WIFI has been setup! ESP-IDF will assert otherwise.

   */

  void start(std::function<void(bool)> on_connection_change = {},

             unsigned long task_size = MQTTRemoteDefaults::CONNECTION_STATUS_STACK_SIZE,

             uint8_t task_priority = MQTTRemoteDefaults::CONNECTION_STATUS_TASK_PRIORITY);

  /**

   * @brief Call once there is a WIFI connection on which the host can be reached.

   * Will connect to the server and setup any subscriptions as well as start the MQTT loop.

   * @param connection_state_changed_event_group optional event group for connection state change. Will be be set with

   * ConnectionState::Connected when the client is connected to server (every time, so expect re-setting on

   * reconnection), and ConnectionState::Disconnected on disconnect.

   *

   * NOTE: Can only be called once WIFI has been setup! ESP-IDF will assert otherwise.

   */

  void start(EventGroupHandle_t connection_state_changed_event_group);

  /**

   * @brief Publish a message.

   *

   * @param topic the topic to publish to.

   * @param message The message to send. This cannot be larger than the value set for max_message_size in the

   * constructor.

   * @param retain True to set this message as retained.

   * @param qos quality of service for published message (0 (default), 1 or 2)

   * @returns true on success, or false on failure.

   */

  bool publishMessage(std::string topic, std::string message, bool retain = false, uint8_t qos = 0) override;

  /**

   * Same as publishMessage(), but will print the message and topic and the result on serial.

   */

  bool publishMessageVerbose(std::string topic, std::string message, bool retain = false, uint8_t qos = 0) override;

  /**

   * @brief returns if there is a connection to the MQTT server.

   */

  bool connected() override { return _connected; }

  /**

   * @brief Subscribe to a topic. The callback will be invoked on every new message.

   * There can only be one callback per topic. If trying to subscribe to an already subscribe topic, it will be ignored.

   * Don't do heavy operations in the callback or delays as this will block the MQTT callback.

   *

   * Can be called before being connected. All subscriptions will be (re-)subscribed to once a connection is

   * (re-)established.

   *

   * @param message_callback a message callback with the topic and the message. The topic is repeated for convenience,

   * but it will always be for the subscribed topic.

   * @return true if a subcription was successful. Will return false if there is no active MQTT connection. In this

   * case, the subscription will be performed once connected. Will return false if this subscription is already

   * subscribed to.

   */

  bool subscribe(std::string topic, IMQTTRemote::SubscriptionCallback message_callback) override;

  /**

   * @brief Unsubscribe a topic.

   */

  bool unsubscribe(std::string topic) override;

  /**

   * @brief The client ID for this device. This is used for the last will / status

   * topic.Example, if this is "esp_now_router", then the status/last will topic will be "esp_now_router/status". This

   * has to be [a-zA-Z0-9_] only.

   */

  std::string &clientId() override { return _client_id; }

private:

  void startInternal();

  /*

   * @brief Event handler registered to receive MQTT events

   *

   *  This function is called by the MQTT client event loop.

   *

   * @param handler_args user data registered to the event.

   * @param base Event base for the handler(always MQTT Base in this example).

   * @param event_id The id for the received event.

   * @param event_data The data for the event, esp_mqtt_event_handle_t.

   */

  static void onMqttEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);

  static void runTask(void *pvParams);

private:

  bool _started = false;

  std::string _client_id;

  bool _connected = false;

  std::string _last_will_topic;

  esp_mqtt_client_handle_t _mqtt_client;

  std::function<void(bool)> _on_connection_change;

  EventGroupHandle_t _connection_state_changed_event_group;

  std::map<std::string, SubscriptionCallback> _subscriptions;

};

#endif // __MQTT_REMOTE_H__