--- a
+++ b/src/ohradio.cxx
@@ -0,0 +1,439 @@
+/* Copyright (C) 2014 J.F.Dockes
+ *   This program 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; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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 program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#include "ohradio.hxx"
+
+#include <stdlib.h>
+
+#include <upnp/upnp.h>
+
+#include <functional>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "libupnpp/base64.hxx"
+#include "libupnpp/log.hxx"
+#include "libupnpp/soaphelp.hxx"
+#include "libupnpp/upnpavutils.hxx"
+
+#include "ohmetacache.hxx"
+#include "mpdcli.hxx"
+#include "upmpd.hxx"
+#include "upmpdutils.hxx"
+#include "conftree.hxx"
+
+using namespace std;
+using namespace std::placeholders;
+
+static const string sTpProduct("urn:av-openhome-org:service:Radio:1");
+static const string sIdProduct("urn:av-openhome-org:serviceId:Radio");
+
+struct RadioMeta {
+    RadioMeta(const string& t, const string& u)
+        : title(t), uri(u) {
+    }
+    string title;
+    string uri;
+};
+
+static vector<RadioMeta> o_radios;
+
+OHRadio::OHRadio(UpMpd *dev)
+    : UpnpService(sTpProduct, sIdProduct, dev), m_dev(dev), m_id(0)
+{
+    dev->addActionMapping(this, "Channel",
+                          bind(&OHRadio::channel, this, _1, _2));
+    dev->addActionMapping(this, "ChannelsMax",
+                          bind(&OHRadio::channelsMax, this, _1, _2));
+    dev->addActionMapping(this, "Id",
+                          bind(&OHRadio::id, this, _1, _2));
+    dev->addActionMapping(this, "IdArray",
+                          bind(&OHRadio::idArray, this, _1, _2));
+    dev->addActionMapping(this, "IdArrayChanged",
+                          bind(&OHRadio::idArrayChanged, this, _1, _2));
+    dev->addActionMapping(this, "Pause",
+                          bind(&OHRadio::pause, this, _1, _2));
+    dev->addActionMapping(this, "Play",
+                          bind(&OHRadio::play, this, _1, _2));
+    dev->addActionMapping(this, "ProtocolInfo",
+                          bind(&OHRadio::protocolInfo, this, _1, _2));
+    dev->addActionMapping(this, "Read",
+                          bind(&OHRadio::ohread, this, _1, _2));
+    dev->addActionMapping(this, "ReadList",
+                          bind(&OHRadio::readList, this, _1, _2));
+    dev->addActionMapping(this, "SeekSecondAbsolute",
+                          bind(&OHRadio::seekSecondAbsolute, this, _1, _2));
+    dev->addActionMapping(this, "SeekSecondRelative",
+                          bind(&OHRadio::seekSecondRelative, this, _1, _2));
+    dev->addActionMapping(this, "SetChannel",
+                          bind(&OHRadio::setChannel, this, _1, _2));
+    dev->addActionMapping(this, "SetId",
+                          bind(&OHRadio::setId, this, _1, _2));
+    dev->addActionMapping(this, "Stop",
+                          bind(&OHRadio::stop, this, _1, _2));
+    dev->addActionMapping(this, "TransportState",
+                          bind(&OHRadio::transportState, this, _1, _2));
+    readRadios();
+}
+
+void OHRadio::readRadios()
+{
+    // Id 0 means no selection
+    o_radios.push_back(RadioMeta("Unknown radio", ""));
+    
+    vector<string> allsubk = g_config->getSubKeys();
+    for (auto it = allsubk.begin(); it != allsubk.end(); it++) {
+        LOGDEB("OHRadio::readRadios: subk " << *it << endl);
+        if (it->find("radio ") == 0) {
+            string uri;
+            string title = it->substr(6);
+            bool ok = g_config->get("url", uri, *it);
+            if (ok && !uri.empty()) {
+                o_radios.push_back(RadioMeta(title, uri));
+                LOGDEB("OHRadio::readRadios:RADIO: [" <<
+                       title << "] uri [" << uri << "]\n");
+            }
+        }
+    }
+    LOGDEB("OHRadio::readRadios: " << o_radios.size() << " radios found\n")
+}
+
+static const int channelsmax = 200;
+
+static string mpdstatusToTransportState(MpdStatus::State st)
+{
+    string tstate;
+    switch (st) {
+    case MpdStatus::MPDS_PLAY:
+        tstate = "Playing";
+        break;
+    case MpdStatus::MPDS_PAUSE:
+        tstate = "Paused";
+        break;
+    default:
+        tstate = "Stopped";
+    }
+    return tstate;
+}
+
+// The data format for id lists is an array of msb 32 bits ints
+// encoded in base64...
+bool OHRadio::makeIdArray(string& out)
+{
+    LOGDEB1("OHRadio::makeIdArray\n");
+    string out1;
+    string sdeb;
+    for (unsigned int val = 1; val < o_radios.size(); val++) {
+        out1 += (unsigned char) ((val & 0xff000000) >> 24);
+        out1 += (unsigned char) ((val & 0x00ff0000) >> 16);
+        out1 += (unsigned char) ((val & 0x0000ff00) >> 8);
+        out1 += (unsigned char) ((val & 0x000000ff));
+        sdeb += SoapHelp::i2s(val) + " ";
+    }
+    LOGDEB("OHRadio::translateIdArray: current ids: " << sdeb << endl);
+    out = base64_encode(out1);
+    return true;
+}
+
+bool OHRadio::makestate(unordered_map<string, string>& st)
+{
+    st.clear();
+
+    const MpdStatus& mpds = m_dev->getMpdStatusNoUpdate();
+
+    st["ChannelsMax"] = SoapHelp::i2s(channelsmax);
+    st["Id"] = SoapHelp::i2s(m_id);
+    makeIdArray(st["IdArray"]);
+    if (m_id && m_id < o_radios.size()) {
+        UpSong song;
+        song.album = o_radios[m_id].title;
+        song.uri = o_radios[m_id].uri;
+        st["Metadata"] =  didlmake(song);
+    } else {
+        st["Metadata"] =  "";
+    }
+    st["ProtocolInfo"] = g_protocolInfo;
+    st["TransportState"] =  mpdstatusToTransportState(mpds.state);
+    st["Uri"] = mpds.currentsong.uri;
+    return true;
+}
+
+bool OHRadio::getEventData(bool all, std::vector<std::string>& names,
+                           std::vector<std::string>& values)
+{
+    //LOGDEB("OHRadio::getEventData" << endl);
+
+    unordered_map<string, string> state;
+
+    makestate(state);
+
+    unordered_map<string, string> changed;
+    if (all) {
+        changed = state;
+    } else {
+        changed = diffmaps(m_state, state);
+    }
+    m_state = state;
+
+    for (auto it = changed.begin(); it != changed.end(); it++) {
+        names.push_back(it->first);
+        values.push_back(it->second);
+    }
+
+    return true;
+}
+
+void OHRadio::maybeWakeUp(bool ok)
+{
+    if (ok && m_dev) {
+        m_dev->loopWakeup();
+    }
+}
+
+int OHRadio::channel(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::channel" << endl);
+    const MpdStatus& mpds = m_dev->getMpdStatusNoUpdate();
+    string metadata = didlmake(mpds.currentsong);
+    data.addarg("Uri", mpds.currentsong.uri);
+    data.addarg("Metadata", metadata);
+
+    return UPNP_E_SUCCESS;
+}
+
+int OHRadio::channelsMax(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::channelsMax" << endl);
+    data.addarg("Value", SoapHelp::i2s(channelsmax));
+    return UPNP_E_SUCCESS;
+}
+
+int OHRadio::play(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::play" << endl);
+    m_dev->m_mpdcli->consume(false);
+    m_dev->m_mpdcli->single(false);
+    bool ok = m_dev->m_mpdcli->play();
+    maybeWakeUp(ok);
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+int OHRadio::pause(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::pause" << endl);
+    bool ok = m_dev->m_mpdcli->pause(true);
+    maybeWakeUp(ok);
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+int OHRadio::iStop()
+{
+    bool ok = m_dev->m_mpdcli->stop();
+    maybeWakeUp(ok);
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+int OHRadio::stop(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::stop" << endl);
+    return iStop();
+}
+
+int OHRadio::seekSecondAbsolute(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::seekSecondAbsolute" << endl);
+    int seconds;
+    bool ok = sc.get("Value", &seconds);
+    if (ok) {
+        ok = m_dev->m_mpdcli->seek(seconds);
+        maybeWakeUp(ok);
+    }
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+int OHRadio::seekSecondRelative(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::seekSecondRelative" << endl);
+    int seconds;
+    bool ok = sc.get("Value", &seconds);
+    if (ok) {
+        const MpdStatus& mpds =  m_dev->getMpdStatusNoUpdate();
+        bool is_song = (mpds.state == MpdStatus::MPDS_PLAY) ||
+                       (mpds.state == MpdStatus::MPDS_PAUSE);
+        if (is_song) {
+            seconds += mpds.songelapsedms / 1000;
+            ok = m_dev->m_mpdcli->seek(seconds);
+        } else {
+            ok = false;
+        }
+        maybeWakeUp(ok);
+    }
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+int OHRadio::transportState(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::transportState" << endl);
+    const MpdStatus& mpds = m_dev->getMpdStatusNoUpdate();
+    string tstate;
+    switch (mpds.state) {
+    case MpdStatus::MPDS_PLAY:
+        tstate = "Playing";
+        break;
+    case MpdStatus::MPDS_PAUSE:
+        tstate = "Paused";
+        break;
+    default:
+        tstate = "Stopped";
+    }
+    data.addarg("Value", tstate);
+    return UPNP_E_SUCCESS;
+}
+
+int OHRadio::setChannel(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::setId" << endl);
+    string uri, metadata;
+    bool ok = sc.get("Uri", &uri);
+    if (ok) {
+        ok = sc.get("Metadata", &metadata);
+        m_id = 0;
+        // Do something
+        maybeWakeUp(ok);
+    }
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+int OHRadio::setId(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::setId" << endl);
+    int id;
+    bool ok = sc.get("Value", &id);
+    if (ok) {
+        m_id = id;
+        maybeWakeUp(ok);
+    }
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+// Return current Id. Not the same as for playlist, this is our internal channel
+// id, nothing to do with mpd's
+int OHRadio::id(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::id" << endl);
+    const MpdStatus& mpds = m_dev->getMpdStatusNoUpdate();
+    data.addarg("Value", mpds.songid == -1 ? "0" : SoapHelp::i2s(mpds.songid));
+    return UPNP_E_SUCCESS;
+}
+
+// Report the uri and metadata for a given channel id.
+int OHRadio::ohread(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    int id;
+    bool ok = sc.get("Id", &id);
+    LOGDEB("OHRadio::ohread id " << id << endl);
+    if (ok) {
+        if (id > 0 && id  < int(o_radios.size())) {
+            data.addarg("Uri", o_radios[id].uri);
+            UpSong song;
+            song.album = o_radios[id].title;
+            song.uri = o_radios[id].uri;
+            data.addarg("Metadata", didlmake(song));
+        } else {
+            ok = false;
+        }
+    }
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+// Given a space separated list of track Id's, report their associated
+// uri and metadata in the following xml form:
+//
+//  <TrackList>
+//    <Entry>
+//      <Id></Id>
+//      <Uri></Uri>
+//      <Metadata></Metadata>
+//    </Entry>
+//  </TrackList>
+//
+// Any ids not in the radio are ignored.
+int OHRadio::readList(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    string sids;
+    UpSong song;
+
+    bool ok = sc.get("IdList", &sids);
+    LOGDEB("OHRadio::readList: [" << sids << "]" << endl);
+
+    vector<string> ids;
+    string out("<ChannelList>");
+    if (ok) {
+        stringToTokens(sids, ids);
+        for (auto it = ids.begin(); it != ids.end(); it++) {
+            int id = atoi(it->c_str());
+            if (id <= 0 || id >= int(o_radios.size())) {
+                LOGDEB("OHRadio::readlist: bad id " << id << endl);
+                continue;
+            }
+            song.title = o_radios[id].title;
+            song.uri = o_radios[id].uri;
+            LOGDEB("OHRadio::readlist: get data for  " << id << " alb " <<
+                   song.album << " uri " << song.uri << endl);
+            out += "<Entry><Id>";
+            out += *it;
+            out += "</Id><Metadata>";
+            out += SoapHelp::xmlQuote(didlmake(song));
+            out += "</Metadata></Entry>";
+        }
+        out += "</ChannelList>";
+        LOGDEB("OHRadio::readList: out: [" << out << "]" << endl);
+        data.addarg("ChannelList", out);
+    }
+    return ok ? UPNP_E_SUCCESS : UPNP_E_INTERNAL_ERROR;
+}
+
+// Returns current list of id as array of big endian 32bits integers,
+// base-64-encoded.
+int OHRadio::idArray(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::idArray" << endl);
+    string idarray;
+    if (makeIdArray(idarray)) {
+        data.addarg("Token", SoapHelp::i2s(1));
+        data.addarg("Array", idarray);
+        return UPNP_E_SUCCESS;
+    }
+    return UPNP_E_INTERNAL_ERROR;
+}
+
+// Check if id array changed since last call (which returned a gen token)
+int OHRadio::idArrayChanged(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::idArrayChanged" << endl);
+    data.addarg("Value", SoapHelp::i2s(0));
+
+    return UPNP_E_SUCCESS;
+}
+
+int OHRadio::protocolInfo(const SoapIncoming& sc, SoapOutgoing& data)
+{
+    LOGDEB("OHRadio::protocolInfo" << endl);
+    data.addarg("Value", g_protocolInfo);
+    return UPNP_E_SUCCESS;
+}