VolumeController.h

#pragma once
 
#include "../SinricProRequest.h"
#include "../EventLimiter.h"
#include "../SinricProStrings.h"
 
#include "../SinricProNamespace.h"
namespace SINRICPRO_NAMESPACE {
 
FSTR(VOLUME, setVolume);         // "setVolume"
FSTR(VOLUME, volume);            // "volume"
FSTR(VOLUME, adjustVolume);      // "adjustVolume"
FSTR(VOLUME, volumeDefault);     // "volumeDefault"
 
using SetVolumeCallback = std::function<bool(const String &, int &)>;
 
using AdjustVolumeCallback = std::function<bool(const String &, int &, bool)>;
 
 
template <typename T>
class VolumeController {
  public:
    VolumeController();
 
    void onSetVolume(SetVolumeCallback cb);
    void onAdjustVolume(AdjustVolumeCallback cb);
 
    bool sendVolumeEvent(int volume, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
  protected:
    bool handleVolumeController(SinricProRequest &request);
 
  private:
    EventLimiter event_limiter;
    SetVolumeCallback volumeCallback;
    AdjustVolumeCallback adjustVolumeCallback;
};
 
template <typename T>
VolumeController<T>::VolumeController()
: event_limiter(EVENT_LIMIT_STATE) { 
  T* device = static_cast<T*>(this);
  device->registerRequestHandler(std::bind(&VolumeController<T>::handleVolumeController, this, std::placeholders::_1)); 
}
 
template <typename T>
void VolumeController<T>::onSetVolume(SetVolumeCallback cb) { volumeCallback = cb; }
 
template <typename T>
void VolumeController<T>::onAdjustVolume(AdjustVolumeCallback cb) { adjustVolumeCallback = cb; }
 
template <typename T>
bool VolumeController<T>::sendVolumeEvent(int volume, String cause) {
  if (event_limiter) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_VOLUME_setVolume, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_VOLUME_volume] = volume;
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool VolumeController<T>::handleVolumeController(SinricProRequest &request) {
  T* device = static_cast<T*>(this);
 
  bool success = false;
 
  if (volumeCallback && request.action == FSTR_VOLUME_setVolume) {
    int volume = request.request_value[FSTR_VOLUME_volume];
    success = volumeCallback(device->deviceId, volume);
    request.response_value[FSTR_VOLUME_volume] = volume;
    return success;
  }
 
  if (adjustVolumeCallback && request.action == FSTR_VOLUME_adjustVolume) {
    int volume = request.request_value[FSTR_VOLUME_volume];
    bool volumeDefault = request.request_value[FSTR_VOLUME_volumeDefault] | false;
    success = adjustVolumeCallback(device->deviceId, volume, volumeDefault);
    request.response_value[FSTR_VOLUME_volume] = volume;
    return success;
  }
  return success;
}
 
} // SINRICPRO_NAMESPACE
 
template <typename T>
using VolumeController = SINRICPRO_NAMESPACE::VolumeController<T>;