ksMqttConnector.h

/*
 *  Copyright (c) 2021-2025, 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 "../misc/ksSimpleTimer.h"
#include "../misc/ksDomainQuery.h"
 
#if (defined(ESP32))
    #if ESP_ARDUINO_VERSION_MAJOR >= 3
        #define ksMqttConnectorNetClient_t NetworkClient
        #define ksMqttConnectorNetClientSecure_t NetworkClientSecure
    #else
        #define ksMqttConnectorNetClient_t WiFiClient
        #define ksMqttConnectorNetClientSecure_t WiFiClientSecure
    #endif
    class ksMqttConnectorNetClientSecure_t;
    class ksMqttConnectorNetClient_t;
#elif defined(ESP8266)
    namespace BearSSL{class WiFiClientSecure;}
    #define ksMqttConnectorNetClientSecure_t BearSSL::WiFiClientSecure
    #define ksMqttConnectorNetClient_t WiFiClient
    class ksMqttConnectorNetClient_t;
#else
    #error Platform not implemented.
#endif
 
class PubSubClient;
 
namespace ksf::misc
{
    class ksCertFingerprint;
}
 
namespace ksf::comps
{
    class ksWifiConnector;
 
    class ksMqttConnector : public ksComponent
    {
        KSF_RTTI_DECLARATIONS(ksMqttConnector, ksComponent)
 
        protected:
#if APP_LOG_ENABLED
            ksApplication* app{nullptr};                                    
#endif
 
            misc::ksDomainQuery domainResolver;                             
            std::unique_ptr<ksMqttConnectorNetClient_t> netClientUq;        
            std::unique_ptr<PubSubClient> mqttClientUq;                     
            std::weak_ptr<ksWifiConnector> wifiConnWp;                      
            misc::ksSimpleTimer reconnectTimer;                             
 
            uint64_t lastSuccessConnectionTime{0};                          
            uint32_t reconnectCounter{0};                                   
 
            struct 
            {
                bool sendConnectionStatus : 1;                              
                bool usePersistentSession : 1;                              
                bool wasConnected : 1;                                      
            } 
            bitflags = {true, false, true};
 
            std::string login;                                              
            std::string password;                                           
            std::string prefix;                                             
            uint16_t portNumber{1883};                                      
 
            std::unique_ptr<misc::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);
 
            virtual ~ksMqttConnector();
 
            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(std::string broker, const std::string& port, std::string login, std::string password, std::string prefix, const std::string& fingerprint);
    };
}