Open Source Projects Europe

// This libupnpp sample does about the same thing as rdcvolume, but it defines

// its own control classes instead of the ones predefined by libupnpp.

#include <termios.h>

#include <string>

#include <iostream>

#include <mutex>

#include <condition_variable>

#include <functional>

#include "libupnpp/upnpplib.hxx"

#include "libupnpp/soaphelp.hxx"

#include "libupnpp/control/discovery.hxx"

#include "libupnpp/control/device.hxx"

#include "libupnpp/control/service.hxx"

using namespace std;

using namespace std::placeholders;

//using namespace UPnPClient;

//using namespace UPnPP;

// Locally defined control class for the Rendering Control

// service. We're just copying code from the libupnpp actually, this is

// just to show that it can be done outside the library.

class MyRDC : public UPnPClient::Service {

public:

    /* Construct by copying data from device and service objects.*/

    MyRDC(const UPnPClient::UPnPDeviceDesc& device,

          const UPnPClient::UPnPServiceDesc& service)

        : UPnPClient::Service(device, service) {

        // We want to have a look at our service description file

        // (xml) to retrieve the min/max/step values for the

        // volume. Not all services need to do this.

        UPnPClient::UPnPServiceDesc::Parsed sdesc;

        if (service.fetchAndParseDesc(device.URLBase, sdesc)) {

            auto it = sdesc.stateTable.find("Volume");

            if (it != sdesc.stateTable.end() && it->second.hasValueRange) {

                m_volmin = it->second.minimum;

                m_volmax = it->second.maximum;

                m_volstep = it->second.step;

            } else {

                // ??

                m_volmin = 0;

                m_volmax = 100;

                m_volstep = 1;

            }

        }

        // Say that we want to receive events. This is not mandatory

        registerCallback();

    }

    virtual ~MyRDC() {

        unregisterCallback();

    }

    /* Test that a service type matches ours. This can be used

       with the directory traversal routine */

    static bool isRDCService(const std::string& st) {

        // Note that we do not care about the version

        return st.find("urn:schemas-upnp-org:service:RenderingControl") == 0;

    }

    int setVolume(int volume, const std::string& channel = "Master");

    int getVolume(const std::string& channel = "Master");

    /* Volume settings params */

    int m_volmin;

    int m_volmax;

    int m_volstep;

private:

    void evtCallback(const unordered_map<string, string>& props) {

        // The callback gets a map of changed properties as

        // parameter. In turn, the classes defined by libupnpp

        // (e.g. RenderingControl) call a client event reporter in an

        // uniform way, and after massaging the data a bit, but you

        // can do whatever you like here. UPnP AV is special

        // because it coalesces the values inside a LastChange XML

        // string. Many services just report them individually.

        cerr << "evtCallback: props size " << props.size() << endl;

        for (const auto& ent : props) {

            cout << ent.first << " -> " << ent.second << endl;

        }

    }

    // Register our member function callback. It's just an

    // std::function, other approaches may be possible.

    void registerCallback() {

        UPnPClient::Service::registerCallback(

            std::bind(&MyRDC::evtCallback, this, _1));

    }

};

// The libupnpp equivalent checks and converts the range, and also

// that a volume change is actually required, and does appropriate

// rounding. We're just showing how to send a parameter here.  The arg

// names are defined by the service description XML file, so it would

// be possible to construct the call after the XML data (a la

// upnp-inspector), there is nothing in libupnpp to prevent it.

int MyRDC::setVolume(int ivol, const string& channel)

{

    // Outgoing parameters. The object is constructed with the service

    // type (comes from the description we were built on), and the

    // action name. This is sufficient for some actions (ie stop())

    UPnPP::SoapOutgoing args(getServiceType(), "SetVolume");

    // This call needs further outgoing arguments, which goes in there

    // through an operator() overload

    args("InstanceID", "0")("Channel", channel)

        ("DesiredVolume", UPnPP::SoapHelp::i2s(ivol));

    // We have to declare a return parameter, even if we don't care

    // about the contents.

    UPnPP::SoapIncoming data;

    return runAction(args, data);

}

// Same as setVolume really, except that we look at the return data.

int MyRDC::getVolume(const string& channel)

{

    UPnPP::SoapOutgoing args(getServiceType(), "GetVolume");

    args("InstanceID", "0")("Channel", channel);

    UPnPP::SoapIncoming data;

    int ret = runAction(args, data);

    if (ret != UPNP_E_SUCCESS) {

        return ret;

    }

    int volume;

    if (!data.get("CurrentVolume", &volume)) {

        cerr << "MyRDC:getVolume: missing CurrentVolume in response\n";

        return UPNP_E_BAD_RESPONSE;

    }

    return volume;

}

// Device discovery part. We do it the easy way here: use a blocking

// call which will wait for the initial window to complete.  We could

// traverse the device directory in search, for example of a device of

// a specific kind instead of using a device name like we do here (there is

// an example of UPnPDeviceDirectory::traverse() usage in uplistdir.cpp).

//

// See rdcvolume.cpp for a version using callbacks to get the device asap

shared_ptr<MyRDC> getService(const string& name)

{

    // Initialize and get a discovery directory handle.

    auto *superdir = UPnPClient::UPnPDeviceDirectory::getTheDir();

    if (nullptr == superdir) {

        cerr << "Discovery init failed\n";

        return shared_ptr<MyRDC>();

    }

    UPnPClient::UPnPDeviceDesc devicedesc;

    // We look-up the device by either friendlyname or udn as the 2

    // namespaces are unlikely to overlap, no need to complicate things

    if (!superdir->getDevByUDN(name, devicedesc) && 

        !superdir->getDevByFName(name, devicedesc)) {

        cerr << "Can't connect to " << name << endl;

        return shared_ptr<MyRDC>();

    }

    // UPnPClient::Device does nothing really interesting actually. It

    // just holds the device description. Derived device

    // implementations, for example for a MediaRenderer, add a bit of

    // value by creating objects for the well-known services. Here we

    // just dispense with the device creation, and directly create a

    // service object.

    // Walk the device description service list, looking for ours

    for (const auto& ent : devicedesc.services) {

        if (MyRDC::isRDCService(ent.serviceType)) {

            cout << ent.dump() << endl;

            return make_shared<MyRDC>(devicedesc, ent);

        }

    }

    cerr << name << " has no rendering control service\n";

    return shared_ptr<MyRDC>();

}

// nothing to see here: character reading, one at a time.

int mygetch()

{

    struct termios oldt, newt;

    int ch;

    tcgetattr(STDIN_FILENO, &oldt);

    newt = oldt;

    newt.c_lflag &= ~(ICANON | ECHO);

    tcsetattr(STDIN_FILENO, TCSANOW, &newt);

    ch = getchar();

    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);

    return ch;

}

int main(int argc, char **argv)

{

    argv++;argc--;

    if (argc != 1) {

        cerr << "Usage: rdcvolume rendererNameOrUid\n";

        return 1;

    }

    string devname(*argv++); 

    argc--;

    // Initialize libupnpp logging

    Logger::getTheLog("")->setLogLevel(Logger::LLERR);

    // Explicitely initialize libupnpp so that we can display a

    // possible error

    UPnPP::LibUPnP *mylib = UPnPP::LibUPnP::getLibUPnP();

    if (!mylib) {

        cerr << "Can't get LibUPnP" << endl;

        return 1;

    }

    if (!mylib->ok()) {

        cerr << "Lib init failed: " <<

            mylib->errAsString("main", mylib->getInitError()) << endl;

        return 1;

    }

    shared_ptr<MyRDC> rdc = getService(devname);

    if (!rdc) {

        cerr << "Device " << devname << 

            " has no RenderingControl service" << endl;

        return 1;

    }

    cout << "q = quit, 'u' = up, 'd' = down\n";

    for (;;) {

        int vol = rdc->getVolume();

        cout << "Volume now " << vol << endl;

        int key = mygetch();

        if (key == 'q') {

            cout << "QUIT\n";

            break;

        } else if (key == 'u') {

            vol += 5;

            if (vol > 100) {

                vol = 100;

            }

        } else if (key == 'd') {

            vol -= 5;

            if (vol < 0) {

                vol = 0;

            }

        } else {

            cout << "Bad key: " << (char)key << endl;

            continue;

        }

        if (rdc->setVolume(vol)) {

            cerr << "setVolume(" << vol << ") failed\n";

        }

    }

    return 0;

}