EnigmaIOTjsonController.h

Go to the documentation of this file.

 
#ifndef _ENIGMAIOTJSONCONTROLLER_h
#define _ENIGMAIOTJSONCONTROLLER_h
 
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
 
#include <EnigmaIOTNode.h>
#include <ArduinoJson.h>
#if SUPPORT_HA_DISCOVERY    
#include <queue>
#endif
 
#if defined ESP8266 || defined ESP32
#include <functional>
typedef std::function<bool (const uint8_t* data, size_t len, nodePayloadEncoding_t payloadEncoding, dataMessageType_t dataMsgType)> sendData_cb; 
#if SUPPORT_HA_DISCOVERY
typedef std::function<void ()> haDiscovery_call_t; 
#endif // SUPPORT_HA_DISCOVERY
#else
#error This code only supports ESP8266 or ESP32 platforms
#endif // defined ESP8266 || defined ESP32
 
class EnigmaIOTjsonController {
protected:
    sendData_cb sendData;
    EnigmaIOTNodeClass* enigmaIotNode;
#if SUPPORT_HA_DISCOVERY
    std::queue<haDiscovery_call_t> haCallQueue;
    bool doSendHAdiscovery = false;
    clock_t sendHAtime;
    clock_t sendHAdelay = HA_FIRST_DISCOVERY_DELAY;
#endif // SUPPORT_HA_DISCOVERY
 
public:
    virtual void setup (EnigmaIOTNodeClass* node, void* config = NULL) = 0;
 
    virtual void loop () = 0;
 
    virtual bool processRxCommand (
        const uint8_t* mac, const uint8_t* buffer, uint8_t length, nodeMessageType_t command, nodePayloadEncoding_t payloadEncoding) = 0;
 
    void sendDataCallback (sendData_cb cb) {
        sendData = cb;
    }
 
    virtual void connectInform () {
        DEBUG_INFO ("Connect inform");
        sendStartAnouncement ();
#if SUPPORT_HA_DISCOVERY
        if (enigmaIotNode->getNode ()->getSleepy ()) {
            sendHAdelay = HA_FIRST_DISCOVERY_DELAY_SLEEPY;
        }
        DEBUG_INFO ("Enable HA Discovery");
        doSendHAdiscovery = true;
        sendHAtime = millis ();
#endif // SUPPORT_HA_DISCOVERY
    }
 
    virtual void disconnectInform (nodeInvalidateReason_t reason){}
 
    virtual void configManagerStart () = 0;
 
    virtual void configManagerExit (bool status) = 0;
 
    virtual bool loadConfig () = 0;
 
#if SUPPORT_HA_DISCOVERY    
    void callHAdiscoveryCalls () {
        if (doSendHAdiscovery && millis () - sendHAtime > sendHAdelay) {
            haDiscovery_call_t hacall = 0;
            DEBUG_INFO ("Call HA discovery");
            if (haCallQueue.size ()) {
                hacall = haCallQueue.front ();
            }
            DEBUG_INFO ("haCallQueue size is %d", haCallQueue.size ());
            if (hacall) {
                DEBUG_INFO ("Execute hacall");
                hacall ();
                haCallQueue.pop ();
                sendHAtime = millis ();
                if (enigmaIotNode->getNode ()->getSleepy ()) {
                    sendHAdelay = HA_NEXT_DISCOVERY_DELAY_SLEEPY;
                } else {
                    sendHAdelay = HA_NEXT_DISCOVERY_DELAY;
                }
            } else {
                doSendHAdiscovery = false;
            }
            DEBUG_INFO (" Exit call HA discovery. Delay = %d. doSendHAdiscovery = %s",
                        sendHAdelay, doSendHAdiscovery ? "true" : "false");
        }
    }
#endif
    
protected:
 
    virtual bool sendCommandResp (const char* command, bool result) = 0;
 
    virtual bool sendStartAnouncement () = 0;
 
    virtual bool saveConfig () = 0;
 
    bool sendJson (DynamicJsonDocument& json) {
        int len = measureMsgPack (json) + 1;
        uint8_t* buffer = (uint8_t*)malloc (len);
        len = serializeMsgPack (json, (char*)buffer, len);
 
        size_t strLen = measureJson (json) + 1;
        char* strBuffer = (char*)calloc (sizeof (uint8_t), strLen);
 
        /*Serial.printf ("Trying to send: %s\n", printHexBuffer (
            buffer, len));*/
        serializeJson (json, strBuffer, strLen);
        DEBUG_INFO ("Trying to send: %s", strBuffer);
        bool result = false;
        if (sendData)
            result = sendData (buffer, len, MSG_PACK, DATA_TYPE);
        if (!result) {
            DEBUG_WARN ("---- Error sending data");
        } else {
            DEBUG_INFO ("---- Data sent");
        }
        if (buffer) {
            free (buffer);        
        }
        if (strBuffer) {
            free (strBuffer);
        }
        return result;
    }
 
#if SUPPORT_HA_DISCOVERY    
    void addHACall (haDiscovery_call_t HACall) {
        haCallQueue.push (HACall);
    }
 
    bool sendHADiscovery (uint8_t* data, size_t len) {
        if (!data || !len) {
            DEBUG_WARN ("Empty HA message");
            return false;
        }
        bool result = false;
        if (sendData)
            result = sendData (data, len, MSG_PACK, HA_DISC_TYPE);
        if (!result) {
            DEBUG_WARN ("---- Error sending data");
        } else {
            DEBUG_INFO ("---- Data sent");
        }
        return result;
    }
#endif
};
 
#endif // _ENIGMAIOTJSONCONTROLLER_h