ControlPoint.h

Go to the documentation of this file.

/****
 * ControlPoint.h
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 * Copyright 2020 slaff <slaff@attachix.com>
 *
 * This file is part of the Sming UPnP 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 "Object.h"
#include "ObjectList.h"
#include "ClassGroup.h"
#include <Network/SSDP/Message.h>
#include <Network/HttpClient.h>
#include "Constants.h"
#include "DeviceControl.h"
#include "Search.h"
#include <memory>
 
namespace UPnP
{
class ControlPoint : public ObjectTemplate<ControlPoint, BaseObject>
{
public:
    ControlPoint(size_t maxResponseSize = 2048) : maxResponseSize(maxResponseSize)
    {
        controlPoints.add(this);
    }
 
    ~ControlPoint()
    {
        controlPoints.remove(this);
    }
 
    void reset()
    {
        cancelSearch();
        uniqueServiceNames.clear();
    }
 
    void clear()
    {
        reset();
        rootDevices.clear();
    }
 
    bool beginSearch(const Urn& urn, SsdpSearch::Callback callback)
    {
        return submitSearch(new SsdpSearch(urn, callback));
    }
 
    bool beginSearch(const Urn& urn, DescriptionSearch::Callback callback)
    {
        return submitSearch(new DescriptionSearch(urn, callback));
    }
 
    bool beginSearch(const ObjectClass& cls, DeviceSearch::Callback callback)
    {
        return submitSearch(new DeviceSearch(cls, callback));
    }
 
    bool beginSearch(const ObjectClass& cls, ServiceSearch::Callback callback)
    {
        return submitSearch(new ServiceSearch(cls, callback));
    }
 
    template <typename Device> bool beginSearch(Delegate<bool(Device&)> callback)
    {
        return beginSearch(Device().getClass(),
                           [callback](DeviceControl& device) { return callback(reinterpret_cast<Device&>(device)); });
    }
 
    bool isSearchActive() const
    {
        return bool(activeSearch);
    }
 
    bool cancelSearch();
 
    virtual void onNotify(BasicMessage& msg);
 
    bool formatMessage(Message& msg, MessageSpec& ms) override;
 
    bool sendRequest(HttpRequest* request);
 
    bool requestDescription(const String& url, DescriptionSearch::Callback callback);
 
    static void onSsdpMessage(BasicMessage& msg);
 
    static const ObjectClass* findClass(const Urn& objectType);
 
    static void registerClasses(const FlashString& domain, const ObjectClass::List& classes)
    {
        objectClasses.add(domain, classes);
    }
 
private:
    using List = ObjectList<ControlPoint>;
 
    bool submitSearch(Search* search);
    static bool processDescriptionResponse(HttpConnection& connection, String& buffer, XML::Document& description);
 
    static List controlPoints;
    static ClassGroup::List objectClasses;
    DeviceControl::OwnedList rootDevices;
    static HttpClient http;
    size_t maxResponseSize; // <<< Maximum size of XML description that can be processed
    CStringArray uniqueServiceNames;
    std::unique_ptr<Search> activeSearch;
};
 
} // namespace UPnP