ksDevicePortal.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 "../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;                                      
            } bitflags = {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();

            ksDevicePortal(std::string portalPassword);

            bool init(ksApplication* app) override;

            bool postInit(ksApplication* app) override;

            bool loop(ksApplication* app) override;

            virtual ~ksDevicePortal();
    };
}