ColorTemperatureController.h

#pragma once
 
#include "../SinricProRequest.h"
#include "../EventLimiter.h"
#include "../SinricProStrings.h"
 
#include "../SinricProNamespace.h"
namespace SINRICPRO_NAMESPACE {
 
FSTR(COLORTEMPERATURE, colorTemperature);            // "colorTemperature"
FSTR(COLORTEMPERATURE, setColorTemperature);         // "setColorTemperature"
FSTR(COLORTEMPERATURE, increaseColorTemperature);    // "increaseColorTemperature"
FSTR(COLORTEMPERATURE, decreaseColorTemperature);    // "decreaseColorTemperature"
 
using ColorTemperatureCallback = std::function<bool(const String &, int &)>;
 
using IncreaseColorTemperatureCallback = std::function<bool(const String &, int &)>;
 
using DecreaseColorTemperatureCallback = std::function<bool(const String &, int &)>;
 
 
template <typename T>
class ColorTemperatureController {
  public:
    ColorTemperatureController();
 
    void onColorTemperature(ColorTemperatureCallback cb);
    void onIncreaseColorTemperature(IncreaseColorTemperatureCallback cb);
    void onDecreaseColorTemperature(DecreaseColorTemperatureCallback cb);
 
    bool sendColorTemperatureEvent(int colorTemperature, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
  protected:
    bool handleColorTemperatureController(SinricProRequest &request);
 
  private: 
    EventLimiter event_limiter;
//    SinricProDeviceInterface *device;
    ColorTemperatureCallback colorTemperatureCallback;
    IncreaseColorTemperatureCallback increaseColorTemperatureCallback;
    DecreaseColorTemperatureCallback decreaseColorTemperatureCallback;
};
 
template <typename T>
ColorTemperatureController<T>::ColorTemperatureController() 
: event_limiter(EVENT_LIMIT_STATE) { 
  T* device = static_cast<T*>(this);
  device->registerRequestHandler(std::bind(&ColorTemperatureController<T>::handleColorTemperatureController, this, std::placeholders::_1)); 
}
 
template <typename T>
void ColorTemperatureController<T>::onColorTemperature(ColorTemperatureCallback cb) {
  colorTemperatureCallback = cb;
}
 
template <typename T>
void ColorTemperatureController<T>::onIncreaseColorTemperature(IncreaseColorTemperatureCallback cb) {
  increaseColorTemperatureCallback = cb;
}
 
template <typename T>
void ColorTemperatureController<T>::onDecreaseColorTemperature(DecreaseColorTemperatureCallback cb) {
  decreaseColorTemperatureCallback = cb;
}
 
template <typename T>
bool ColorTemperatureController<T>::sendColorTemperatureEvent(int colorTemperature, String cause) {
  if (event_limiter) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_COLORTEMPERATURE_setColorTemperature, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_COLORTEMPERATURE_colorTemperature] = colorTemperature;
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool ColorTemperatureController<T>::handleColorTemperatureController(SinricProRequest &request) {
  T* device = static_cast<T*>(this);
 
  bool success = false;
 
  if (colorTemperatureCallback && request.action == FSTR_COLORTEMPERATURE_setColorTemperature) {
    int colorTemperature = request.request_value[FSTR_COLORTEMPERATURE_colorTemperature];
    success = colorTemperatureCallback(device->deviceId, colorTemperature);
    request.response_value[FSTR_COLORTEMPERATURE_colorTemperature] = colorTemperature;
  }
 
  if (increaseColorTemperatureCallback && request.action == FSTR_COLORTEMPERATURE_increaseColorTemperature) {
    int colorTemperature = 1;
    success = increaseColorTemperatureCallback(device->deviceId, colorTemperature);
    request.response_value[FSTR_COLORTEMPERATURE_colorTemperature] = colorTemperature;
  }
 
  if (decreaseColorTemperatureCallback && request.action == FSTR_COLORTEMPERATURE_decreaseColorTemperature) {
    int colorTemperature = -1;
    success = decreaseColorTemperatureCallback(device->deviceId, colorTemperature);
    request.response_value[FSTR_COLORTEMPERATURE_colorTemperature] = colorTemperature;
  }
 
  return success;
}
 
} // SINRICPRO_NAMESPACE
 
template <typename T>
using ColorTemperatureController = SINRICPRO_NAMESPACE::ColorTemperatureController<T>;