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