ThermostatController.h

#pragma once
 
#include "../SinricProRequest.h"
#include "../EventLimiter.h"
#include "../SinricProStrings.h"
 
#include "../SinricProNamespace.h"
namespace SINRICPRO_NAMESPACE {
 
FSTR(THERMOSTAT, setThermostatMode);           // "setThermostatMode"
FSTR(THERMOSTAT, thermostatMode);              // "thermostatMode"
FSTR(THERMOSTAT, targetTemperature);           // "targetTemperature"
FSTR(THERMOSTAT, temperature);                 // "temperature"
FSTR(THERMOSTAT, adjustTargetTemperature);     // "adjustTargetTemperature"
 
using ThermostatModeCallback = std::function<bool(const String &, String &)>;
 
using SetTargetTemperatureCallback = std::function<bool(const String &, float &)>;
 
using AdjustTargetTemperatureCallback = std::function<bool(const String &, float &)>;
 
 
template <typename T>
class ThermostatController {
  public:
    ThermostatController();
 
    void onThermostatMode(ThermostatModeCallback cb);
    void onTargetTemperature(SetTargetTemperatureCallback cb);
    void onAdjustTargetTemperature(AdjustTargetTemperatureCallback cb);
 
    bool sendThermostatModeEvent(String thermostatMode, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
    bool sendTargetTemperatureEvent(float temperature, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
  protected:
    bool handleThermostatController(SinricProRequest &request);
 
  private:
    EventLimiter event_limiter_thermostatMode;
    EventLimiter event_limiter_targetTemperature;
    ThermostatModeCallback thermostatModeCallback;
    SetTargetTemperatureCallback targetTemperatureCallback;
    AdjustTargetTemperatureCallback adjustTargetTemperatureCallback;
};
 
template <typename T>
ThermostatController<T>::ThermostatController()
: event_limiter_thermostatMode(EVENT_LIMIT_STATE)
, event_limiter_targetTemperature(EVENT_LIMIT_STATE) { 
  T* device = static_cast<T*>(this);
  device->registerRequestHandler(std::bind(&ThermostatController<T>::handleThermostatController, this, std::placeholders::_1)); 
}
 
template <typename T>
void ThermostatController<T>::onThermostatMode(ThermostatModeCallback cb) {
  thermostatModeCallback = cb;
}
 
template <typename T>
void ThermostatController<T>::onTargetTemperature(SetTargetTemperatureCallback cb) {
  targetTemperatureCallback = cb;
}
 
template <typename T>
void ThermostatController<T>::onAdjustTargetTemperature(AdjustTargetTemperatureCallback cb) {
  adjustTargetTemperatureCallback = cb;
}
 
template <typename T>
bool ThermostatController<T>::sendThermostatModeEvent(String thermostatMode, String cause) {
  if (event_limiter_thermostatMode) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_THERMOSTAT_setThermostatMode, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_THERMOSTAT_thermostatMode] = thermostatMode;
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool ThermostatController<T>::sendTargetTemperatureEvent(float temperature, String cause) {
  if (event_limiter_targetTemperature) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_THERMOSTAT_targetTemperature, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_THERMOSTAT_temperature] = roundf(temperature * 10) / 10.0;
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool ThermostatController<T>::handleThermostatController(SinricProRequest &request) {
  T* device = static_cast<T*>(this);
 
  bool success = false;
 
  if (request.action == FSTR_THERMOSTAT_targetTemperature && targetTemperatureCallback) {
    float temperature;
    if (request.request_value.containsKey(FSTR_THERMOSTAT_temperature))  {
      temperature = request.request_value[FSTR_THERMOSTAT_temperature];
    }  else {
      temperature = 1;
    }
    success = targetTemperatureCallback(device->deviceId, temperature);
    request.response_value[FSTR_THERMOSTAT_temperature] = temperature;
    return success;
  }
 
  if (request.action == FSTR_THERMOSTAT_adjustTargetTemperature && adjustTargetTemperatureCallback) {
    float temperatureDelta = request.request_value[FSTR_THERMOSTAT_temperature];
    success = adjustTargetTemperatureCallback(device->deviceId, temperatureDelta);
    request.response_value[FSTR_THERMOSTAT_temperature] = temperatureDelta;
    return success;
  }
 
  if (request.action == FSTR_THERMOSTAT_setThermostatMode && thermostatModeCallback) {
    String thermostatMode = request.request_value[FSTR_THERMOSTAT_thermostatMode] | "";
    success = thermostatModeCallback(device->deviceId, thermostatMode);
    request.response_value[FSTR_THERMOSTAT_thermostatMode] = thermostatMode;
    return success;
  }
 
  return success;
}
 
} // SINRICPRO_NAMESPACE
 
template <typename T>
using ThermostatController = SINRICPRO_NAMESPACE::ThermostatController<T>;