Bridge.h

Go to the documentation of this file.

 
#ifndef INCLUDE_HUEPLUSPLUS_HUE_H
#define INCLUDE_HUEPLUSPLUS_HUE_H
 
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "APICache.h"
#include "BridgeConfig.h"
#include "BrightnessStrategy.h"
#include "ColorHueStrategy.h"
#include "ColorTemperatureStrategy.h"
#include "Group.h"
#include "HueCommandAPI.h"
#include "HueDeviceTypes.h"
#include "IHttpHandler.h"
#include "Light.h"
#include "ResourceList.h"
#include "Rule.h"
#include "Scene.h"
#include "Schedule.h"
#include "Sensor.h"
#include "SensorList.h"
#include "Utils.h"
 
#include <nlohmann/json.hpp>
 
namespace hueplusplus
{
// forward declarations
class Bridge;
 
class BridgeFinder
{
public:
    struct BridgeIdentification
    {
        std::string ip;
        int port = 80;
        std::string mac;
    };
 
public:
    BridgeFinder(std::shared_ptr<const IHttpHandler> handler);
 
    std::vector<BridgeIdentification> findBridges() const;
 
    Bridge getBridge(const BridgeIdentification& identification, bool sharedState = false);
 
    void addUsername(const std::string& mac, const std::string& username);
 
    void addClientKey(const std::string& mac, const std::string& clientkey);
 
    const std::map<std::string, std::string>& getAllUsernames() const;
 
    static std::string normalizeMac(std::string input);
 
private:
    static std::string parseDescription(const std::string& description);
 
    std::map<std::string, std::string> usernames; 
    std::map<std::string, std::string> clientkeys; 
    std::shared_ptr<const IHttpHandler> http_handler;
};
 
class Bridge
{
    friend class BridgeFinder;
 
public:
    using LightList = SearchableResourceList<Light>;
    using GroupList = GroupResourceList<Group, CreateGroup>;
    using ScheduleList = CreateableResourceList<ResourceList<Schedule, int>, CreateSchedule>;
    using SceneList = CreateableResourceList<ResourceList<Scene, std::string>, CreateScene>;
    using RuleList = CreateableResourceList<ResourceList<Rule, int>, CreateRule>;
 
public:
    Bridge(const std::string& ip, const int port, const std::string& username,
        std::shared_ptr<const IHttpHandler> handler, const std::string& clientkey = "",
        std::chrono::steady_clock::duration refreshDuration = std::chrono::seconds(10), bool sharedState = false);
 
    void refresh();
 
    void setRefreshDuration(std::chrono::steady_clock::duration refreshDuration);
 
    std::string getBridgeIP() const;
 
    bool startStreaming(std::string group_identifier);
 
    bool stopStreaming(std::string group_identifier);
 
    int getBridgePort() const;
 
    std::string requestUsername();
 
    std::string getUsername() const;
 
    std::string getClientKey() const;
 
    void setIP(const std::string& ip);
 
    void setPort(const int port);
 
    BridgeConfig& config();
    const BridgeConfig& config() const;
 
    LightList& lights();
    const LightList& lights() const;
 
    GroupList& groups();
    const GroupList& groups() const;
 
    ScheduleList& schedules();
    const ScheduleList& schedules() const;
 
    SceneList& scenes();
    const SceneList& scenes() const;
 
    SensorList& sensors();
    const SensorList& sensors() const;
 
    RuleList& rules();
    const RuleList& rules() const;
 
private:
    void setHttpHandler(std::shared_ptr<const IHttpHandler> handler);
 
private:
    std::string ip; 
    std::string username; 
    std::string clientkey; 
    int port;
 
    std::shared_ptr<const IHttpHandler> http_handler; 
    std::chrono::steady_clock::duration refreshDuration;
    std::shared_ptr<APICache> stateCache;
    detail::MakeCopyable<LightList> lightList;
    detail::MakeCopyable<GroupList> groupList;
    detail::MakeCopyable<ScheduleList> scheduleList;
    detail::MakeCopyable<SceneList> sceneList;
    detail::MakeCopyable<SensorList> sensorList;
    detail::MakeCopyable<RuleList> ruleList;
    detail::MakeCopyable<BridgeConfig> bridgeConfig;
    bool sharedState;
};
} // namespace hueplusplus
 
#endif