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 "json/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