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