SinricPro.h

/*
 *  Copyright (c) 2019 Sinric. All rights reserved.
 *  Licensed under Creative Commons Attribution-Share Alike (CC BY-SA)
 *
 *  This file is part of the Sinric Pro (https://github.com/sinricpro/)
 */
 
#pragma once
 
#include "SinricProDeviceInterface.h"
#include "SinricProInterface.h"
#include "SinricProMessageid.h"
#include "SinricProModuleCommandHandler.h"
#include "SinricProNamespace.h"
#include "SinricProQueue.h"
#include "SinricProSignature.h"
#include "SinricProStrings.h"
#include "SinricProWebsocket.h"
#include "Timestamp.h"
#include "EventLimiter.h"
#ifndef SINRICPRO_NO_LOCAL_CONTROL
#include "SinricProUDP.h"
#endif
#include "SinricProMDNS.h"
namespace SINRICPRO_NAMESPACE {
 
using ConnectedCallbackHandler = std::function<void(void)>;
 
using DisconnectedCallbackHandler = std::function<void(void)>;
 
using OTAUpdateCallbackHandler = std::function<bool(const String& url, int major, int minor, int patch, bool enforce)>;
 
using SetSettingCallbackHandler = std::function<bool(const String& id, SettingValue& value)>;
 
using ReportHealthCallbackHandler = std::function<bool(String& healthReport)>;
 
using PongCallback = std::function<void(uint32_t)>;
 
class SinricProClass : public SinricProInterface {
    friend class SinricProDevice;
 
  public:
    class Proxy;
 
  public:
    void           begin(String appKey, String appSecret, String serverURL = SINRICPRO_SERVER_URL);
    void           handle();
    void           stop();
    bool           isConnected();
    void           onConnected(ConnectedCallbackHandler cb);
    void           onDisconnected(DisconnectedCallbackHandler cb);
    void           onPong(PongCallback cb);
    void           restoreDeviceStates(bool flag);
    void           setResponseMessage(String&& message);
    unsigned long  getTimestamp() override;
    virtual String sign(const String& message);
    Proxy          operator[](const String deviceId);
    void           onOTAUpdate(OTAUpdateCallbackHandler cb);
    void           onSetSetting(SetSettingCallbackHandler cb);
    void           onReportHealth(ReportHealthCallbackHandler cb);
    bool           sendSettingEvent(String settingId, SettingValue settingValue, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
  protected:
    template <typename DeviceType>
    DeviceType& add(String deviceId);
 
    void add(SinricProDeviceInterface& newDevice);
    void add(SinricProDeviceInterface* newDevice);
 
    JsonDocument prepareResponse(JsonDocument& requestMessage);
    JsonDocument prepareEvent(String deviceId, const char* action, const char* cause) override;
    void         sendMessage(JsonDocument& jsonMessage) override;
 
  private:
    void handleReceiveQueue();
    void handleSendQueue();
 
    void handleDeviceRequest(JsonDocument& requestMessage, const SinricProMessage* origin);
    void handleModuleRequest(JsonDocument& requestMessage, const SinricProMessage* origin);
    void handleResponse(JsonDocument& responseMessage);
    void handleInvalidSignatureRequest(JsonDocument& requestMessage, const SinricProMessage* origin);
 
    JsonDocument prepareRequest(String deviceId, const char* action);
 
    void connect();
    void disconnect();
    void reconnect();
 
    void onConnect();
    void onDisconnect();
 
    void extractTimestamp(JsonDocument& message);
 
    SinricProDeviceInterface* getDevice(String deviceId);
 
    String joinDeviceIds(char separator);
 
    template <typename DeviceType>
    DeviceType& getDeviceInstance(String deviceId);
 
    std::vector<SinricProDeviceInterface*> devices;
 
    String appKey;
    String appSecret;
    String serverURL;
 
    WebsocketListener _websocketListener;
#ifndef SINRICPRO_NO_LOCAL_CONTROL
    UdpListener       _udpListener;
#endif
#ifdef SINRICPRO_MDNS_ENABLED
    SinricProMDNS     _mdnsListener;
    size_t            _mdnsDeviceCount = 0;
#endif
    SinricProQueue_t  receiveQueue;
    SinricProQueue_t  sendQueue;
 
    Timestamp timestamp;
 
    bool   _begin             = false;
    String responseMessageStr = "";
 
    SinricProModuleCommandHandler _moduleCommandHandler;
    EventLimiter _settingEventLimiter{EVENT_LIMIT_STATE};
};
 
class SinricProClass::Proxy {
  public:
    Proxy(SinricProClass* ptr, const String& deviceId);
 
    template <typename DeviceType>
    operator DeviceType&();
 
  protected:
    SinricProClass* ptr;
    String          deviceId;
};
 
SinricProClass::Proxy::Proxy(SinricProClass* ptr, const String& deviceId)
    : ptr(ptr), deviceId(deviceId) {}
 
template <typename DeviceType>
SinricProClass::Proxy::operator DeviceType&() {
    return ptr->getDeviceInstance<DeviceType>(deviceId);
}
 
SinricProDeviceInterface* SinricProClass::getDevice(String deviceId) {
    for (auto& device : devices) {
        if (deviceId == device->getDeviceId()) return device;
    }
    return nullptr;
}
 
template <typename DeviceType>
DeviceType& SinricProClass::getDeviceInstance(String deviceId) {
    DeviceType* tmp_device = (DeviceType*)getDevice(deviceId);
    if (tmp_device) return *tmp_device;
 
    DEBUG_SINRIC("[SinricPro]: Device \"%s\" does not exist in the internal device list. creating new device\r\n", deviceId.c_str());
    DeviceType& tmp_deviceInstance = add<DeviceType>(deviceId);
 
    if (isConnected()) {
        DEBUG_SINRIC("[SinricPro]: Reconnecting to server.\r\n");
        reconnect();
    }
 
    return tmp_deviceInstance;
}
 
void SinricProClass::begin(String appKey, String appSecret, String serverURL) {
    bool success = true;
 
    // Validate APP_KEY
    // - Must be 36 characters
    // - UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    if (appKey.length() != 36) {
        Serial.printf("[SinricPro:begin()]: Invalid App Key '%s' detected (Length: %d; Expected: 36). Initialization aborted! Please check your SinricPro credentials.\r\n", appKey.c_str(), appKey.length());
        success = false;
    } else if (appKey.charAt(8) != '-' || appKey.charAt(13) != '-' || appKey.charAt(18) != '-' || appKey.charAt(23) != '-') {
        Serial.printf("[SinricPro:begin()]: App Key '%s' is in an invalid format. Initialization aborted!\r\n", appKey.c_str());
        success = false;
    }
 
    // Validate APP_SECRET (73 characters)
    // - Must be 73 characters
    // - Double UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    if (appSecret.length() != 73) {
        Serial.printf("[SinricPro:begin()]: Invalid App Secret '%s' detected (Length: %d; Expected: 73). Initialization aborted! Please check your SinricPro credentials.\r\n", appSecret.c_str(), appSecret.length());
        success = false;
    } else if (appSecret.charAt(8) != '-' || appSecret.charAt(13) != '-' || appSecret.charAt(18) != '-' || appSecret.charAt(23) != '-' ||
               appSecret.charAt(36) != '-' || appSecret.charAt(45) != '-' || appSecret.charAt(50) != '-' || appSecret.charAt(55) != '-' || appSecret.charAt(60) != '-') {
        Serial.printf("[SinricPro:begin()]: App Secret '%s' is in an invalid format. Initialization aborted!\r\n", appSecret.c_str());
        success = false;
    }
 
    if (!success) {
        _begin = false;
        return;
    }
 
    this->appKey    = appKey;
    this->appSecret = appSecret;
    this->serverURL = serverURL;
    _begin          = true;
#ifndef SINRICPRO_NO_LOCAL_CONTROL
    _udpListener.begin(&receiveQueue);
#endif
#ifdef SINRICPRO_MDNS_ENABLED
    {
        String hostName = "sinricpro-" + WiFi.macAddress();
        hostName.replace(":", "");
        hostName.toLowerCase();
        _mdnsListener.begin(hostName, joinDeviceIds(',')); //mDNS TXT uses ',' (CSV).
        _mdnsDeviceCount = devices.size();
    }
#endif
}
 
template <typename DeviceType>
DeviceType& SinricProClass::add(String deviceId) {
    // Validate DEVICE_ID
    // - Must be 24 characters
    // - Hexadecimal only (0-9, a-f, A-F)
    // - Format: 695b4624f6e5944047661b8a
    if (deviceId.length() != 24) {
        Serial.printf("[SinricPro:add()]: Device Id \"%s\" is invalid (wrong length: expected 24, got %d)!! Please check your device-id!!\r\n", deviceId.c_str(), deviceId.length());
    }
 
    DeviceType* newDevice = new DeviceType(deviceId);
    DEBUG_SINRIC("[SinricPro:add()]: Adding device with id \"%s\".\r\n", deviceId.c_str());
    newDevice->begin(this);
 
    devices.push_back(newDevice);
    return *newDevice;
}
 
__attribute__((deprecated("Please use DeviceType& myDevice = SinricPro.add<DeviceType>(String);"))) void SinricProClass::add(SinricProDeviceInterface* newDevice) {
    newDevice->begin(this);
    devices.push_back(newDevice);
}
 
__attribute__((deprecated("Please use DeviceType& myDevice = SinricPro.add<DeviceType>(String);"))) void SinricProClass::add(SinricProDeviceInterface& newDevice) {
    newDevice.begin(this);
    devices.push_back(&newDevice);
}
 
void SinricProClass::handle() {
    static bool begin_error = false;
    if (!_begin) {
        if (!begin_error) {  // print this only once!
            DEBUG_SINRIC("[SinricPro:handle()]: ERROR! SinricPro.begin() failed or was not called prior to event handler\r\n");
            DEBUG_SINRIC("[SinricPro:handle()]:    -Reasons include an invalid app-key, invalid app-secret or no valid deviceIds)\r\n");
            DEBUG_SINRIC("[SinricPro:handle()]:    -SinricPro is disabled! Check earlier log messages for details.\r\n");
            begin_error = true;
        }
        return;
    }
 
    if (!isConnected()) connect();
    _websocketListener.handle();
#ifndef SINRICPRO_NO_LOCAL_CONTROL
    _udpListener.handle();
#endif
#ifdef SINRICPRO_MDNS_ENABLED
    _mdnsListener.handle();
#endif
 
    handleReceiveQueue();
    handleSendQueue();
}
 
JsonDocument SinricProClass::prepareRequest(String deviceId, const char* action) {
    JsonDocument requestMessage;
    JsonObject   header                     = requestMessage[FSTR_SINRICPRO_header].to<JsonObject>();
    header[FSTR_SINRICPRO_payloadVersion]   = 2;
    header[FSTR_SINRICPRO_signatureVersion] = 1;
 
    JsonObject payload                 = requestMessage[FSTR_SINRICPRO_payload].to<JsonObject>();
    payload[FSTR_SINRICPRO_action]     = action;
    payload[FSTR_SINRICPRO_createdAt]  = 0;
    payload[FSTR_SINRICPRO_deviceId]   = deviceId;
    payload[FSTR_SINRICPRO_replyToken] = MessageID().getID();
    payload[FSTR_SINRICPRO_type]       = FSTR_SINRICPRO_request;
    payload[FSTR_SINRICPRO_value].to<JsonObject>();
    return requestMessage;
}
 
void SinricProClass::handleResponse(JsonDocument& responseMessage) {
    (void)responseMessage;
    DEBUG_SINRIC("[SinricPro.handleResponse()]:\r\n");
 
#ifndef NODEBUG_SINRIC
    serializeJsonPretty(responseMessage, DEBUG_ESP_PORT);
    Serial.println();
#endif
}
 
void SinricProClass::handleModuleRequest(JsonDocument& requestMessage, const SinricProMessage* origin) {
    DEBUG_SINRIC("[SinricPro.handleModuleScopeRequest()]: handling module scope request\r\n");
#ifndef NODEBUG_SINRIC
    serializeJsonPretty(requestMessage, DEBUG_ESP_PORT);
#endif
 
    JsonDocument responseMessage = prepareResponse(requestMessage);
 
    String           action         = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_action] | "";
    JsonObject       request_value  = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
    JsonObject       response_value = responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
    SinricProRequest request{action, "", request_value, response_value};
 
    bool success = _moduleCommandHandler.handleRequest(request);
 
    responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_success] = success;
    responseMessage[FSTR_SINRICPRO_payload].remove(FSTR_SINRICPRO_deviceId);
    if (!success) {
        if (responseMessageStr.length() > 0) {
            responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_message] = responseMessageStr;
            responseMessageStr                                              = "";
        } else {
            responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_message] = "Module did not handle \"" + action + "\"";
        }
    }
 
    String responseString;
    serializeJson(responseMessage, responseString);
    sendQueue.push(new SinricProMessage(origin->getInterface(), responseString.c_str(),
                                       origin->getRemoteIP(), origin->getRemotePort()));
}
 
void SinricProClass::handleDeviceRequest(JsonDocument& requestMessage, const SinricProMessage* origin) {
    DEBUG_SINRIC("[SinricPro.handleDeviceRequest()]: handling device sope request\r\n");
#ifndef NODEBUG_SINRIC
    serializeJsonPretty(requestMessage, DEBUG_ESP_PORT);
#endif
 
    JsonDocument responseMessage = prepareResponse(requestMessage);
 
    // handle devices
    bool        success        = false;
    const char* deviceId       = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_deviceId];
    String      action         = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_action] | "";
    String      instance       = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_instanceId] | "";
    JsonObject  request_value  = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
    JsonObject  response_value = responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
 
    bool deviceIsOurs = false;
 
    for (auto& device : devices) {
        if (device->getDeviceId() == deviceId && success == false) {
            deviceIsOurs = true;
            SinricProRequest request{
                action,
                instance,
                request_value,
                response_value};
            success                                                         = device->handleRequest(request);
            responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_success] = success;
            if (!success) {
                if (responseMessageStr.length() > 0) {
                    responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_message] = responseMessageStr;
                    responseMessageStr                                              = "";
                } else {
                    responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_message] = "Device did not handle \"" + action + "\"";
                }
            }
        }
    }
 
    if (!deviceIsOurs && origin->getInterface() == IF_UDP) {
        DEBUG_SINRIC("[SinricPro.handleDeviceRequest()]: ignoring LAN request for unknown device \"%s\"\r\n", deviceId);
        return;
    }
 
    String responseString;
    serializeJson(responseMessage, responseString);
    sendQueue.push(new SinricProMessage(origin->getInterface(), responseString.c_str(),
                                       origin->getRemoteIP(), origin->getRemotePort()));
}
 
void SinricProClass::handleReceiveQueue() {
    if (receiveQueue.size() == 0) return;
 
    DEBUG_SINRIC("[SinricPro.handleReceiveQueue()]: %i message(s) in receiveQueue\r\n", receiveQueue.size());
    while (receiveQueue.size() > 0) {
        SinricProMessage* rawMessage = receiveQueue.front();
        receiveQueue.pop();
        JsonDocument jsonMessage;
        deserializeJson(jsonMessage, rawMessage->getMessage());
 
        bool sigMatch = false;
 
        if (strncmp(rawMessage->getMessage(), "{\"timestamp\":", 13) == 0 && strlen(rawMessage->getMessage()) <= 26) {
            sigMatch = true;  // timestamp message has no signature...ignore sigMatch for this!
        } else {
            String signature           = jsonMessage[FSTR_SINRICPRO_signature][FSTR_SINRICPRO_HMAC] | "";
            String payload             = extractPayload(rawMessage->getMessage());
            String calculatedSignature = calculateSignature(appSecret.c_str(), payload);
            sigMatch                   = (calculatedSignature == signature);
        }
 
        String messageType = jsonMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_type];
 
        if (sigMatch) {  // signature is valid process message
            DEBUG_SINRIC("[SinricPro.handleReceiveQueue()]: Signature is valid. Processing message...\r\n");
            extractTimestamp(jsonMessage);
            if (messageType == FSTR_SINRICPRO_response) handleResponse(jsonMessage);
            if (messageType == FSTR_SINRICPRO_request) {
                String scope = jsonMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_scope] | FSTR_SINRICPRO_device;
                if (strcmp(FSTR_SINRICPRO_module, scope.c_str()) == 0) {
                    handleModuleRequest(jsonMessage, rawMessage);
                } else {
                    handleDeviceRequest(jsonMessage, rawMessage);
                }
            };
        } else {
            handleInvalidSignatureRequest(jsonMessage, rawMessage);
        }
        delete rawMessage;
    }
}
 
void SinricProClass::handleInvalidSignatureRequest(JsonDocument& requestMessage, const SinricProMessage* origin) { 
    DEBUG_SINRIC("[SinricPro.handleInvalidSignatureRequest()]: Signature is invalid!\r\n");
    
#ifndef NODEBUG_SINRIC
    serializeJsonPretty(requestMessage, DEBUG_ESP_PORT);
#endif
 
    JsonDocument responseMessage = prepareResponse(requestMessage);    
    responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_success] = false;
    responseMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_message] = "Signature is invalid";
 
    String responseString;
    serializeJson(responseMessage, responseString);
    sendQueue.push(new SinricProMessage(origin->getInterface(), responseString.c_str(),
                                       origin->getRemoteIP(), origin->getRemotePort()));
}
 
void SinricProClass::handleSendQueue() {
    // Visit each pending message once so deferred cloud messages cannot block LAN replies.
    size_t pending = sendQueue.size();
    while (pending-- > 0) {
        DEBUG_SINRIC("[SinricPro:handleSendQueue()]: %i message(s) in sendQueue\r\n", sendQueue.size());
 
        SinricProMessage* rawMessage = sendQueue.front();
 
        if (rawMessage->getInterface() == IF_WEBSOCKET &&
            (!isConnected() || !timestamp.getTimestamp())) {
            sendQueue.pop();
            sendQueue.push(rawMessage);
            continue;
        }
 
        DEBUG_SINRIC("[SinricPro:handleSendQueue()]: Sending message...\r\n");
        sendQueue.pop();
 
        JsonDocument jsonMessage;
        deserializeJson(jsonMessage, rawMessage->getMessage());
        jsonMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_createdAt] = timestamp.getTimestamp();
        signMessage(appSecret, jsonMessage);
 
        String messageStr;
 
        serializeJson(jsonMessage, messageStr);
#ifndef NODEBUG_SINRIC
        serializeJsonPretty(jsonMessage, DEBUG_ESP_PORT);
        Serial.println();
#endif
 
        switch (rawMessage->getInterface()) {
            case IF_WEBSOCKET:
                if (isConnected()) {
                    DEBUG_SINRIC("[SinricPro:handleSendQueue]: Sending to websocket\r\n");
                    _websocketListener.sendMessage(messageStr);
                } else {
                    DEBUG_SINRIC("[SinricPro:handleSendQueue]: Dropping WS message — not connected\r\n");
                }
                break;
            case IF_UDP:
#ifndef SINRICPRO_NO_LOCAL_CONTROL
                DEBUG_SINRIC("[SinricPro:handleSendQueue]: Sending to UDP\r\n");
                _udpListener.sendMessage(messageStr, rawMessage->getRemoteIP(), rawMessage->getRemotePort());
#endif
                break;
            default:
                break;
        }
        delete rawMessage;
        DEBUG_SINRIC("[SinricPro:handleSendQueue()]: message sent.\r\n");
    }
}
 
String SinricProClass::joinDeviceIds(char separator) {
    String out;
    int i = 0;
    for (auto& device : devices) {
        if (i++ > 0) out += separator;
        out += device->getDeviceId();
    }
    return out;
}
 
void SinricProClass::connect() {
    _websocketListener.begin(serverURL, appKey, joinDeviceIds(';'), &receiveQueue);
 
#ifdef SINRICPRO_MDNS_ENABLED
    if (devices.size() != _mdnsDeviceCount) {
        _mdnsDeviceCount = devices.size();
        _mdnsListener.update(joinDeviceIds(','));
    }
#endif
}
 
void SinricProClass::stop() {
    _begin = false;
    DEBUG_SINRIC("[SinricPro:stop()\r\n");
    _websocketListener.stop();
}
 
bool SinricProClass::isConnected() {
    return _websocketListener.isConnected();
};
 
void SinricProClass::onOTAUpdate(OTAUpdateCallbackHandler cb) {
    _moduleCommandHandler.onOTAUpdate(cb);
}
 
void SinricProClass::onSetSetting(SetSettingCallbackHandler cb) {
    _moduleCommandHandler.onSetSetting(cb);
}
 
void SinricProClass::onReportHealth(ReportHealthCallbackHandler cb) {
    _moduleCommandHandler.onReportHealth(cb);
}
 
bool SinricProClass::sendSettingEvent(String settingId, SettingValue settingValue, String cause) {
    if (_settingEventLimiter) return false;
 
    JsonDocument eventMessage = prepareEvent("", FSTR_SETTING_setSetting, cause.c_str());
    JsonObject payload = eventMessage[FSTR_SINRICPRO_payload];
 
    payload.remove(FSTR_SINRICPRO_deviceId);
    payload[FSTR_SINRICPRO_scope] = FSTR_SINRICPRO_module;
 
    JsonObject event_value = payload[FSTR_SINRICPRO_value];
    event_value[FSTR_SETTING_id] = settingId;
 
    if (std::holds_alternative<int>(settingValue)) {
        event_value[FSTR_SETTING_value] = std::get<int>(settingValue);
    } else if (std::holds_alternative<float>(settingValue)) {
        event_value[FSTR_SETTING_value] = std::get<float>(settingValue);
    } else if (std::holds_alternative<bool>(settingValue)) {
        event_value[FSTR_SETTING_value] = std::get<bool>(settingValue);
    } else if (std::holds_alternative<String>(settingValue)) {
        event_value[FSTR_SETTING_value] = std::get<String>(settingValue);
    }
 
    sendMessage(eventMessage);
    return true;
}
 
void SinricProClass::onConnected(ConnectedCallbackHandler cb) {
    _websocketListener.onConnected(cb);
}
 
void SinricProClass::onDisconnected(DisconnectedCallbackHandler cb) {
    _websocketListener.onDisconnected(cb);
}
 
void SinricProClass::onPong(PongCallback cb) {
    _websocketListener.onPong(cb);
}
 
void SinricProClass::reconnect() {
    DEBUG_SINRIC("SinricPro:reconnect(): disconnecting\r\n");
    stop();
    DEBUG_SINRIC("SinricPro:reconnect(): connecting\r\n");
    connect();
}
 
void SinricProClass::onConnect() {
    DEBUG_SINRIC("[SinricPro]: Connected to \"%s\"!]\r\n", serverURL.c_str());
}
 
void SinricProClass::onDisconnect() {
    DEBUG_SINRIC("[SinricPro]: Disconnect\r\n");
}
 
void SinricProClass::extractTimestamp(JsonDocument& message) {
    unsigned long tempTimestamp = 0;
    // extract timestamp from timestamp message right after websocket connection is established
    tempTimestamp = message["timestamp"] | 0;
    if (tempTimestamp) {
        timestamp.setTimestamp(tempTimestamp);
        DEBUG_SINRIC("[SinricPro:extractTimestamp(): Got Timestamp %lu\r\n", tempTimestamp);
        return;
    }
 
    // extract timestamp from request message
    tempTimestamp = message[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_createdAt] | 0;
    if (tempTimestamp) {
        DEBUG_SINRIC("[SinricPro:extractTimestamp(): Got Timestamp %lu\r\n", tempTimestamp);
        timestamp.setTimestamp(tempTimestamp);
        return;
    }
}
 
void SinricProClass::sendMessage(JsonDocument& jsonMessage) {
    if (!isConnected()) {
        DEBUG_SINRIC("[SinricPro:sendMessage()]: device is offline, message has been dropped\r\n");
        return;
    }
    DEBUG_SINRIC("[SinricPro:sendMessage()]: pushing message into sendQueue\r\n");
    String messageString;
    serializeJson(jsonMessage, messageString);
    sendQueue.push(new SinricProMessage(IF_WEBSOCKET, messageString.c_str()));
}
 
__attribute__((deprecated("Use SinricPro Portal: Edit Device > Other > 'Restore Device State When Connect' instead"))) void SinricProClass::restoreDeviceStates(bool flag) {
    _websocketListener.setRestoreDeviceStates(flag);
}
 
SinricProClass::Proxy SinricProClass::operator[](const String deviceId) {
    return Proxy(this, deviceId);
}
 
void SinricProClass::setResponseMessage(String&& message) {
    responseMessageStr = message;
}
 
unsigned long SinricProClass::getTimestamp() {
    return timestamp.getTimestamp();
}
 
String SinricProClass::sign(const String& message) {
    return HMACbase64(message, appSecret);
}
 
JsonDocument SinricProClass::prepareResponse(JsonDocument& requestMessage) {
    JsonDocument responseMessage;
    JsonObject   header                     = responseMessage[FSTR_SINRICPRO_header].to<JsonObject>();
    header[FSTR_SINRICPRO_payloadVersion]   = 2;
    header[FSTR_SINRICPRO_signatureVersion] = 1;
 
    JsonObject payload                = responseMessage[FSTR_SINRICPRO_payload].to<JsonObject>();
    payload[FSTR_SINRICPRO_action]    = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_action];
    payload[FSTR_SINRICPRO_clientId]  = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_clientId];
    payload[FSTR_SINRICPRO_scope]     = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_scope];
    payload[FSTR_SINRICPRO_createdAt] = 0;
    payload[FSTR_SINRICPRO_deviceId]  = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_deviceId];
    if (requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_instanceId].is<String>()) payload[FSTR_SINRICPRO_instanceId] = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_instanceId];
    payload[FSTR_SINRICPRO_message]    = FSTR_SINRICPRO_OK;
    payload[FSTR_SINRICPRO_replyToken] = requestMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_replyToken];
    payload[FSTR_SINRICPRO_success]    = false;
    payload[FSTR_SINRICPRO_type]       = FSTR_SINRICPRO_response;
    payload[FSTR_SINRICPRO_value].to<JsonObject>();
    return responseMessage;
}
 
JsonDocument SinricProClass::prepareEvent(String deviceId, const char* action, const char* cause) {
    JsonDocument eventMessage;
    JsonObject   header                     = eventMessage[FSTR_SINRICPRO_header].to<JsonObject>();
    header[FSTR_SINRICPRO_payloadVersion]   = 2;
    header[FSTR_SINRICPRO_signatureVersion] = 1;
 
    JsonObject payload             = eventMessage[FSTR_SINRICPRO_payload].to<JsonObject>();
    payload[FSTR_SINRICPRO_action] = action;
    payload[FSTR_SINRICPRO_cause][FSTR_SINRICPRO_type].to<JsonObject>();
    payload[FSTR_SINRICPRO_cause][FSTR_SINRICPRO_type] = cause;
    payload[FSTR_SINRICPRO_createdAt]                  = 0;
    payload[FSTR_SINRICPRO_deviceId]                   = deviceId;
    payload[FSTR_SINRICPRO_replyToken]                 = MessageID().getID();
    payload[FSTR_SINRICPRO_type]                       = FSTR_SINRICPRO_event;
    payload[FSTR_SINRICPRO_value].to<JsonObject>();
    return eventMessage;
}
 
}  // namespace SINRICPRO_NAMESPACE
 
SINRICPRO_NAMESPACE::SinricProClass SinricPro;