ksMqttConnector.h

/*
 *  Copyright (c) 2021-2023, Krzysztof Strehlau
 *
 *  This file is a part of the ksIotFramework library.
 *  All licensing information can be found inside LICENSE.md file.
 *
 *  https://github.com/cziter15/ksIotFrameworkLib/blob/master/LICENSE
 */
 
#pragma once
 
#include <string>
#include <string_view>
 
#include "../ksComponent.h"
#include "../evt/ksEvent.h"
#include "../ksSimpleTimer.h"
 
#if (defined(ESP32) && ESP_ARDUINO_VERSION_MAJOR >= 3)
    #define ksMqttConnectorNetClient_t NetworkClient
    #define ksMqttConnectorNetClientSecure_t NetworkClientSecure
#else
    #define ksMqttConnectorNetClient_t WiFiClient
    #define ksMqttConnectorNetClientSecure_t WiFiClientSecure
#endif
 
class PubSubClient;
class ksCertFingerprint;
class ksMqttConnectorNetClient_t;
 
namespace ksf
{
    namespace comps
    {
        class ksWifiConnector;
        class ksMqttConnector : public ksComponent
        {
            KSF_RTTI_DECLARATIONS(ksMqttConnector, ksComponent)
 
            protected:
#if APP_LOG_ENABLED
                ksApplication* app{nullptr};                                    
#endif
                std::unique_ptr<ksMqttConnectorNetClient_t> netClientUq;        
                std::unique_ptr<PubSubClient> mqttClientUq;                     
 
                std::weak_ptr<ksWifiConnector> wifiConnWp;                      
 
                uint64_t lastSuccessConnectionTime{0};                          
                uint32_t reconnectCounter{0};                                   
 
                struct {
                    bool sendConnectionStatus : 1;                              
                    bool usePersistentSession : 1;                              
                    bool wasConnected : 1;                                      
                } bitflags = {true, false, true};
 
                ksSimpleTimer reconnectTimer{KSF_MQTT_RECONNECT_DELAY_MS};      
 
                std::string login;                                              
                std::string password;                                           
                std::string prefix;                                             
                std::string broker;                                             
                uint16_t portNumber{1883};                                      
 
                std::unique_ptr<ksCertFingerprint> certFingerprint;             
 
                bool connectToBroker();
 
                void mqttConnectedInternal();
 
                void mqttMessageInternal(const char* topic, const uint8_t* payload, uint32_t length);
 
            public:
                enum class QosLevel
                {
                    QOS_AT_LEAST_ONCE,
                    QOS_EXACTLY_ONCE
                };
 
                DECLARE_KS_EVENT(onDeviceMessage, const std::string_view&, const std::string_view&)     
                DECLARE_KS_EVENT(onAnyMessage, const std::string_view&, const std::string_view&)        
 
                DECLARE_KS_EVENT(onConnected)                                                           
                DECLARE_KS_EVENT(onDisconnected)                                                        
 
                ksMqttConnector(bool sendConnectionStatus = true, bool usePersistentSession = false);
 
                bool init(ksApplication* app) override;
                    
                bool postInit(ksApplication* app) override;
 
                bool loop(ksApplication* app) override;
 
                bool isConnected() const;
 
                uint32_t getConnectionTimeSeconds() const;
 
                uint32_t getReconnectCounter() const { return reconnectCounter; }
 
                void subscribe(const std::string& topic, bool skipDevicePrefix = false, ksMqttConnector::QosLevel = ksMqttConnector::QosLevel::QOS_AT_LEAST_ONCE);
 
                void unsubscribe(const std::string& topic, bool skipDevicePrefix = false);
 
                void publish(const std::string& topic, const std::string& payload, bool retain = false, bool skipDevicePrefix = false);
 
                void setupConnection(const std::string broker, const std::string& port, std::string login, std::string password, std::string prefix, const std::string& fingerprint);
        
                virtual ~ksMqttConnector();
        };
    }
}