StartStopController.h

#pragma once
 
#include "../SinricProRequest.h"
#include "../EventLimiter.h"
#include "../SinricProStrings.h"
 
#include "../SinricProNamespace.h"
namespace SINRICPRO_NAMESPACE {
 
FSTR(START_STOP, start);            // "start"
FSTR(START_STOP, pause);            // "pause"
FSTR(START_STOP, setStartStop);     // "setStartStop"
FSTR(START_STOP, setPauseUnpause);  // "setPauseUnpause"
 
using StartStopCallback = std::function<bool(const String &, bool &)>;
 
using PauseUnpauseCallback = std::function<bool(const String &, bool &)>;
 
template <typename T>
class StartStopController {
  public:
    StartStopController();
 
    void onStartStop(StartStopCallback cb);
 
    void onPauseUnpause(StartStopCallback cb);
 
    bool sendStartStopEvent(bool start, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
    bool sendPauseUnpauseEvent(bool pause, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
  protected:
    bool handleStartStopController(SinricProRequest &request);
 
  private:
    EventLimiter event_limiter;
    StartStopCallback startStopCallbackCallback;
    PauseUnpauseCallback pauseUnpauseCallback;
};
 
template <typename T>
StartStopController<T>::StartStopController()
:event_limiter(EVENT_LIMIT_STATE) { 
  T* device = static_cast<T*>(this);
  device->registerRequestHandler(std::bind(&StartStopController<T>::handleStartStopController, this, std::placeholders::_1)); 
}
 
template <typename T>
void StartStopController<T>::onStartStop(StartStopCallback cb) { startStopCallbackCallback = cb; }
 
template <typename T>
void StartStopController<T>::onPauseUnpause(PauseUnpauseCallback cb) { pauseUnpauseCallback = cb; }
 
template <typename T>
bool StartStopController<T>::sendStartStopEvent(bool start, String cause) {
  if (event_limiter) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_START_STOP_setStartStop, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_START_STOP_start] = start;
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool StartStopController<T>::sendPauseUnpauseEvent(bool pause, String cause) {
  if (event_limiter) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_START_STOP_setPauseUnpause, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_START_STOP_pause] = pause;
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool StartStopController<T>::handleStartStopController(SinricProRequest &request) {
  T* device = static_cast<T*>(this);
 
  bool success = false;
 
  if (startStopCallbackCallback && request.action == FSTR_START_STOP_setStartStop) {
    bool start = request.request_value[FSTR_START_STOP_start];
    success = startStopCallbackCallback(device->deviceId, start);
    request.response_value[FSTR_START_STOP_start] = start;
    return success;
  }
  
  if (pauseUnpauseCallback && request.action == FSTR_START_STOP_setPauseUnpause) {
    bool pause = request.request_value[FSTR_START_STOP_pause];
    success = pauseUnpauseCallback(device->deviceId, pause);
    request.response_value[FSTR_START_STOP_pause] = pause;
    return success;
  }
 
  return false;
}
 
} // SINRICPRO_NAMESPACE
 
template <typename T>
using StartStopController = SINRICPRO_NAMESPACE::StartStopController<T>;