ksDevicePortal.h

/*
 *  Copyright (c) 2020-2025, Krzysztof Strehlau
 *
 *  This file is a part of the ksIotFrameworkLib IoT 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 "../evt/ksEvent.h"
#include "../ksComponent.h"
 
class DNSServer;
class ArduinoOTAClass;
 
#if defined(ESP32)
    class WebServer;
    #define WebServerClass WebServer
#elif defined(ESP8266)
    class WiFiServer;
    namespace esp8266webserver
    {
        template<typename ServerType = WiFiServer> class ESP8266WebServerTemplate;
    }
    #define WebServerClass esp8266webserver::ESP8266WebServerTemplate<WiFiServer>
#endif
 
namespace ksf::misc
{
    class ksWSServer;
}
 
namespace ksf::comps
{
    class ksMqttConnector;
 
    class ksDevicePortal : public ksComponent
    {
        KSF_RTTI_DECLARATIONS(ksDevicePortal, ksComponent)
 
        protected:
            ksf::ksApplication* app{nullptr};                           
            struct{
                bool breakApp : 1;                                      
                bool isSafeToCallEndOta : 1;                            
            } bitflags = {false, false};                                
 
            uint32_t logKeepAliveTimestamp{0};                          
            uint32_t lastLoopExecutionTimestamp{0};                     
            uint32_t loopExecutionTime{0};                              
            uint32_t scanNetworkTimestamp{0};                           
 
            std::string portalPassword;                                 
            std::weak_ptr<ksMqttConnector> mqttConnectorWp;             
 
            std::unique_ptr<WebServerClass> webServer;                  
            std::unique_ptr<misc::ksWSServer> webSocket;                
            std::unique_ptr<DNSServer> dnsServer;                       
            std::unique_ptr<ArduinoOTAClass> arduinoOTA;                
 
            void requestAppBreak() { bitflags.breakApp = true; }
 
            void triggerFactoryReset();
 
            void setupHttpServer();
 
            void setupWsServer();
 
            void updateFinished(bool fromPortal); 
 
            void rebootDevice();
 
            bool inRequest_NeedAuthentication();
 
            void onRequest_notFound() const;
 
            void onRequest_index();
 
            void onRequest_otaChunk();
 
            void onRequest_otaFinish();
 
            void onWebsocketTextMessage(uint8_t clientNum, const std::string_view& message);
 
            void handle_scanNetworks(std::string& response);
 
            void handle_getIdentity(std::string& response);
 
            void handle_getDeviceParams(std::string& response);
 
            std::string handle_executeCommand(const std::string_view& body);
 
            void onAppLog(std::string&& message);
 
        public:
            DECLARE_KS_EVENT(onUpdateStart)
            DECLARE_KS_EVENT(onUpdateEnd)
            DECLARE_KS_EVENT(onHandlePortalCommand, const std::string_view&, bool&, std::string&)
 
            ksDevicePortal();
 
            virtual ~ksDevicePortal();
 
            ksDevicePortal(std::string portalPassword);
 
            bool init(ksApplication* app) override;
 
            bool postInit(ksApplication* app) override;
 
            bool loop(ksApplication* app) override;
    };
}