Light.h

Go to the documentation of this file.

 
#ifndef INCLUDE_HUEPLUSPLUS_HUE_LIGHT_H
#define INCLUDE_HUEPLUSPLUS_HUE_LIGHT_H
 
#include <memory>
 
#include "APICache.h"
#include "BaseDevice.h"
#include "BrightnessStrategy.h"
#include "ColorHueStrategy.h"
#include "ColorTemperatureStrategy.h"
#include "HueCommandAPI.h"
#include "StateTransaction.h"
 
#include <nlohmann/json.hpp>
 
namespace hueplusplus
{
 
enum class ColorType
{
    UNDEFINED, 
    NONE, 
    GAMUT_A, 
    GAMUT_B, 
    GAMUT_C, 
    TEMPERATURE, 
    GAMUT_A_TEMPERATURE, 
    GAMUT_B_TEMPERATURE, 
    GAMUT_C_TEMPERATURE, 
    GAMUT_OTHER, 
    GAMUT_OTHER_TEMPERATURE 
};
 
class Light : public BaseDevice
{
    friend class LightFactory;
    friend class SimpleBrightnessStrategy;
    friend class SimpleColorHueStrategy;
    friend class ExtendedColorHueStrategy;
    friend class SimpleColorTemperatureStrategy;
    friend class ExtendedColorTemperatureStrategy;
 
public:
 
    virtual std::string getLuminaireUId() const;
 
    virtual ColorType getColorType() const;
 
    ColorGamut getColorGamut() const;
 
 
    virtual bool on(uint8_t transition = 4);
 
    virtual bool off(uint8_t transition = 4);
 
    virtual bool isOn();
 
    virtual bool isOn() const;
 
    virtual bool hasBrightnessControl() const { return brightnessStrategy != nullptr; };
 
    virtual bool hasTemperatureControl() const { return colorTemperatureStrategy != nullptr; };
 
    virtual bool hasColorControl() const { return colorHueStrategy != nullptr; };
 
    virtual bool setBrightness(unsigned int bri, uint8_t transition = 4)
    {
        if (brightnessStrategy)
        {
            return brightnessStrategy->setBrightness(bri, transition, *this);
        }
        return false;
    };
 
    virtual unsigned int getBrightness() const
    {
        if (brightnessStrategy)
        {
            return brightnessStrategy->getBrightness(*this);
        }
        return 0;
    };
 
    virtual unsigned int getBrightness()
    {
        if (brightnessStrategy)
        {
            return brightnessStrategy->getBrightness(*this);
        }
        return 0;
    };
 
    virtual bool setColorTemperature(unsigned int mired, uint8_t transition = 4)
    {
        if (colorTemperatureStrategy)
        {
            return colorTemperatureStrategy->setColorTemperature(mired, transition, *this);
        }
        return false;
    };
 
    virtual unsigned int getColorTemperature() const
    {
        if (colorTemperatureStrategy)
        {
            return colorTemperatureStrategy->getColorTemperature(*this);
        }
        return 0;
    };
 
    virtual unsigned int getColorTemperature()
    {
        if (colorTemperatureStrategy)
        {
            return colorTemperatureStrategy->getColorTemperature(*this);
        }
        return 0;
    };
 
    virtual bool setColorHue(uint16_t hue, uint8_t transition = 4)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->setColorHue(hue, transition, *this);
        }
        return false;
    };
 
    virtual bool setColorSaturation(uint8_t sat, uint8_t transition = 4)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->setColorSaturation(sat, transition, *this);
        }
        return false;
    };
 
    virtual bool setColorHueSaturation(const HueSaturation& hueSat, uint8_t transition = 4)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->setColorHueSaturation(hueSat, transition, *this);
        }
        return false;
    };
 
    virtual HueSaturation getColorHueSaturation() const
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->getColorHueSaturation(*this);
        }
        return {};
    };
 
    virtual HueSaturation getColorHueSaturation()
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->getColorHueSaturation(*this);
        }
        return {};
    };
 
    virtual bool setColorXY(const XYBrightness& xy, uint8_t transition = 4)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->setColorXY(xy, transition, *this);
        }
        return false;
    };
 
    virtual XYBrightness getColorXY() const
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->getColorXY(*this);
        }
        return {};
    };
 
    virtual XYBrightness getColorXY()
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->getColorXY(*this);
        }
        return {};
    }
 
    virtual bool setColorRGB(const RGB& rgb, uint8_t transition = 4)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->setColorXY(rgb.toXY(getColorGamut()), transition, *this);
        }
        return false;
    }
 
    virtual bool alert();
 
    virtual bool alertTemperature(unsigned int mired)
    {
        if (colorTemperatureStrategy)
        {
            return colorTemperatureStrategy->alertTemperature(mired, *this);
        }
        return false;
    }
 
    virtual bool alertHueSaturation(const HueSaturation& hueSat)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->alertHueSaturation(hueSat, *this);
        }
        return false;
    }
 
    virtual bool alertXY(const XYBrightness& xy)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->alertXY(xy, *this);
        }
        return false;
    }
 
    virtual bool setColorLoop(bool on)
    {
        if (colorHueStrategy)
        {
            return colorHueStrategy->setColorLoop(on, *this);
        }
        return false;
    }
 
    virtual StateTransaction transaction();
 
 
protected:
    Light(int id, const HueCommandAPI& commands);
 
    Light(int id, const std::shared_ptr<APICache>& baseCache);
 
    Light(int id, const HueCommandAPI& commands, std::shared_ptr<const BrightnessStrategy> brightnessStrategy,
        std::shared_ptr<const ColorTemperatureStrategy> colorTempStrategy,
        std::shared_ptr<const ColorHueStrategy> colorHueStrategy, std::chrono::steady_clock::duration refreshDuration,
        const nlohmann::json& currentState);
 
    virtual void setBrightnessStrategy(std::shared_ptr<const BrightnessStrategy> strat)
    {
        brightnessStrategy = std::move(strat);
    };
 
    virtual void setColorTemperatureStrategy(std::shared_ptr<const ColorTemperatureStrategy> strat)
    {
        colorTemperatureStrategy = std::move(strat);
    };
 
    virtual void setColorHueStrategy(std::shared_ptr<const ColorHueStrategy> strat)
    {
        colorHueStrategy = std::move(strat);
    };
 
protected:
    ColorType colorType; 
 
    std::shared_ptr<const BrightnessStrategy>
        brightnessStrategy; 
    std::shared_ptr<const ColorTemperatureStrategy>
        colorTemperatureStrategy; 
    std::shared_ptr<const ColorHueStrategy>
        colorHueStrategy; 
};
} // namespace hueplusplus
 
#endif