Bridge.h

Go to the documentation of this file.

/****
 * Bridge.h
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the HueEmulator Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/

#pragma once

#include "Device.h"
#include "Stats.h"
#include <Network/HttpServer.h>
#include <Data/WebConstants.h>
#include <SimpleTimer.h>
#include <Network/UPnP/schemas-upnp-org/ClassGroup.h>

namespace Hue
{
enum class Model {
    LWB004, 
    LWB007, 
};

struct User {
    String deviceType;      
    uint16_t count{0};      
    bool authorized{false}; 
};

using UserMap = HashMap<String, User>;

class Bridge : public UPnP::schemas_upnp_org::device::Basic1Template<Bridge>
{
public:
    struct Config {
        enum class Type {
            AuthorizeUser,
            RevokeUser,
        };

        Type type;         
        String deviceType; 
        String name;       
    };

    using ConfigDelegate = Delegate<void(const Config& config)>;

    using StateChangeDelegate = Delegate<void(const Hue::Device& device, Hue::Device::Attributes attr)>;

    Bridge(Hue::Device::Enumerator& devices) : Basic1Template(), devices(devices)
    {
    }

    void configure(const Config& config);

    void enablePairing(bool enable)
    {
        pairingEnabled = enable;
    }

    void onConfigChange(ConfigDelegate delegate)
    {
        configDelegate = delegate;
    }

    void onStateChanged(StateChangeDelegate delegate)
    {
        stateChangeDelegate = delegate;
    }

    void begin();

    const Stats& getStats()
    {
        return stats;
    }

    void resetStats()
    {
        memset(&stats, 0, sizeof(stats));
    }

    const UserMap& getUsers() const
    {
        return users;
    }

    void getStatusInfo(JsonObject json);

    void deviceStateChanged(const Hue::Device& device, Hue::Device::Attributes changed)
    {
        if(stateChangeDelegate) {
            stateChangeDelegate(device, changed);
        }
    }

    /* UPnP::Device */

    String getField(Field desc) const override;

    bool formatMessage(SSDP::Message& msg, SSDP::MessageSpec& ms) override;
    bool onHttpRequest(HttpServerConnection& connection) override;

private:
    void createUser(JsonObjectConst request, JsonDocument& result, const String& path);
    bool validateUser(const char* userName);
    void handleApiRequest(HttpServerConnection& connection);

private:
    UserMap users;
    bool pairingEnabled = false;
    Hue::Device::Enumerator& devices;
    ConfigDelegate configDelegate;
    StateChangeDelegate stateChangeDelegate;
    Stats stats;
};

} // namespace Hue