kde-extraapps/kmix/backends/mixer_mpris2.cpp

/**
 * KMix -- MPRIS2 backend
 *
 * Copyright (C) 2011 Christian Esken <esken@kde.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this program; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */

#include "mixer_mpris2.h"
#include "core/mixer.h"
#include "core/ControlManager.h"
#include "core/GlobalConfig.h"

#include <QStringList>
#include <QDBusReply>
#include <QString>
#include <qvariant.h>

#include <KDebug>
#include <KLocale>

// Set the QDBUS_DEBUG env variable for debugging Qt DBUS calls.

Mixer_Backend* MPRIS2_getMixer(Mixer *mixer, int device )
{
    return new Mixer_MPRIS2(mixer, device );
}

Mixer_MPRIS2::Mixer_MPRIS2(Mixer *mixer, int device) : Mixer_Backend(mixer, device )
{
}


int Mixer_MPRIS2::open()
{
    if ( m_devnum !=  0 )
        return Mixer::ERR_OPEN;

    registerCard(i18n("Playback Streams"));
    _id = "Playback Streams";
    _mixer->setDynamic();
    return addAllRunningPlayersAndInitHotplug();
}

int Mixer_MPRIS2::close()
{
    m_isOpen = false;
    closeCommon();
    qDeleteAll(controls);
    controls.clear();
    return 0;
}

int Mixer_MPRIS2::mediaPlay(QString id)
{
    return mediaControl(id, "PlayPause");
}

int Mixer_MPRIS2::mediaPrev(QString id)
{
    return mediaControl(id, "Previous");
}

int Mixer_MPRIS2::mediaNext(QString id)
{
    return mediaControl(id, "Next");
}

/**
 * Sends a media control command to the given application.
 * @param applicationId The MPRIS applicationId
 * @returns Always 0. Hint: Currently nobody uses the return code
 */
int Mixer_MPRIS2::mediaControl(QString applicationId, QString commandName)
{
    MPrisControl* mad = controls.value(applicationId);
    if ( mad == 0 )
        return 0; // Might have disconnected recently => simply ignore command

    kDebug() << "Send " << commandName << " to id=" << applicationId;
    QDBusPendingReply<> repl2 = mad->playerIfc->asyncCall(commandName);


    QDBusPendingCallWatcher* watchMediaControlReply = new QDBusPendingCallWatcher(repl2, mad);
    connect(watchMediaControlReply, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(watcherMediaControl(QDBusPendingCallWatcher *)));

    return 0; // Presume everything went well. Can't do more for ASYNC calls
}

void Mixer_MPRIS2::watcherMediaControl(QDBusPendingCallWatcher* watcher)
{
    MPrisControl* mprisCtl = watcherHelperGetMPrisControl(watcher);
    if (mprisCtl == 0) {
            return; // Reply for unknown media player. Probably "unplugged" (or not yet plugged)
    }

    // Actually the code below in this method is more or less just debugging
    const QDBusMessage& msg = watcher->reply();
    QString id = mprisCtl->getId();
    QString busDestination = mprisCtl->getBusDestination();
    kDebug() << "Media control for id=" << id << ", path=" << msg.path() << ", interface=" << msg.interface() << ", busDestination" << busDestination;
}

/**
 * readVolumeFromHW() should be used only for hotplug (and even that should go away). Everything should operate via
 * the slot volumeChanged in the future.
 */
int Mixer_MPRIS2::readVolumeFromHW( const QString& /*id*/, std::shared_ptr<MixDevice> /*md*/)
{
    // Everything is done by notifications => no code neccessary
    return Mixer::OK_UNCHANGED;
}


/**
 * A slot that processes data from the MPrisControl that emit the signal.
 *
 * @param The  emitting MPrisControl
 * @param newVolume The new volume
 */
void Mixer_MPRIS2::playbackStateChanged(MPrisControl* mad, MediaController::PlayState playState)
{
    std::shared_ptr<MixDevice> md = m_mixDevices.get(mad->getId());
    md->getMediaController()->setPlayState(playState);
    QMetaObject::invokeMethod(this, "announceGUI", Qt::QueuedConnection);
//      ControlManager::instance().announce(_mixer->id(), ControlChangeType::GUI, QString("MixerMPRIS2.playbackStateChanged"));
}


/**
 * A slot that processes data from the MPrisControl that emit the signal.
 *
 * @param The  emitting MPrisControl
 * @param newVolume The new volume
 */
void Mixer_MPRIS2::volumeChanged(MPrisControl* mad, double newVolume)
{
    std::shared_ptr<MixDevice> md = m_mixDevices.get(mad->getId());
    int volInt = newVolume *100;
    if (GlobalConfig::instance().data.debugVolume)
        kDebug() << "changed" << volInt;
    volumeChangedInternal(md, volInt);
}

void Mixer_MPRIS2::volumeChangedInternal(std::shared_ptr<MixDevice> md, int volumePercentage)
{
    if ( md->isVirtuallyMuted() && volumePercentage == 0) {
        // Special code path for virtual mute switches. Don't write back the volume if it is muted in the KMix GUI
        return;
    }

    Volume& vol = md->playbackVolume();
    vol.setVolume( Volume::LEFT, volumePercentage);
    md->setMuted(volumePercentage == 0);
    QMetaObject::invokeMethod(this, "announceVolume", Qt::QueuedConnection);
//	ControlManager::instance().announce(_mixer->id(), ControlChangeType::Volume, QString("MixerMPRIS2.volumeChanged"));
}

// The following is an example message for an incoming volume change:
/*
signal sender=:1.125 -> dest=(null destination) serial=503 path=/org/mpris/MediaPlayer2; interface=org.freedesktop.DBus.Properties; member=PropertiesChanged
   string "org.mpris.MediaPlayer2.Player"
   array [
      dict entry(
         string "Volume"
         variant             double 0.81
      )
   ]
   array [
   ]
 */

/**
 * @overload
 *
 * @param id
 * @param md
 * @return
 */
int Mixer_MPRIS2::writeVolumeToHW( const QString& id, std::shared_ptr<MixDevice> md )
{
    Volume& vol = md->playbackVolume();
    double volFloat = 0;
    if ( ! md->isMuted() ) {
        int volInt = vol.getVolume(Volume::LEFT);
        volFloat = volInt/100.0;
    }

    QList<QVariant> arg;
    arg.append(QString("org.mpris.MediaPlayer2.Player"));
    arg.append(QString("Volume"));
    arg << QVariant::fromValue(QDBusVariant(volFloat));

    MPrisControl* mad = controls.value(id);

    QVariant v1 = QVariant(QString("org.mpris.MediaPlayer2.Player"));
    QVariant v2 = QVariant(QString("Volume"));
    QVariant v3 = QVariant::fromValue(QDBusVariant(volFloat));
//      QVariant v3 = QVariant(volFloat);

    // I don't care too much for the reply, as I won't receive a result. Thus fire-and-forget here.
    mad->propertyIfc->asyncCall("Set", v1, v2, v3);
    return 0;
}

void Mixer_MPRIS2::setEnumIdHW(const QString&, unsigned int)
{
    // no enums in MPRIS
}

unsigned int Mixer_MPRIS2::enumIdHW(const QString&)
{
    // no enums in MPRIS
    return 0;
}

bool Mixer_MPRIS2::moveStream( const QString&, const QString&  )
{
    // not supported in MPRIS
    return false;
}


/**
 * Adds all currently running players and then starts listening
 * for changes (new players, and disappearing players).<br>
 *
 * @return int
 **/
int Mixer_MPRIS2::addAllRunningPlayersAndInitHotplug()
{
    QDBusConnection dbusConn = QDBusConnection::sessionBus();
    if (! dbusConn.isConnected() ) {
        kError(67100) <<  "Cannot connect to the D-Bus session bus.\n"
                      << "To start it, run:\n"
                      <<"\teval `dbus-launch --auto-syntax`\n";
        return Mixer::ERR_OPEN;
    }

    // Start listening for new Mediaplayers
    bool connected = dbusConn.connect("", QString("/org/freedesktop/DBus"), "org.freedesktop.DBus", "NameOwnerChanged", this, SLOT(newMediaPlayer(QString,QString,QString)) );
    if (!connected) {
        kWarning() << "MPRIS2 hotplug init failure. New Media Players will not be detected.";
    }

    /* Here is a small concurrency issue.
    * If new players appear between registeredServiceNames() below and the connect() above these players *might* show up doubled in KMix.
    * There is no simple solution (reversing could have the problem of not-adding), so we live for now with it.
    */
        
    /*
    * Bug 311189: Introspecting via "dbusConn.interface()->registeredServiceNames()" does not work too well.
    * Comment: I am not so sure that registeredServiceNames() is really an issue. It is more likely
    *  in a later step, when talking to the probed apps. Still, I now do a hand crafted 3-line version of
    *  registeredServiceNames() via "ListNames", so I can later more easily change to async.
    */
    QDBusInterface dbusIfc("org.freedesktop.DBus", "/org/freedesktop/DBus",
                                "org.freedesktop.DBus", dbusConn);
    QDBusPendingReply<QStringList> repl = dbusIfc.asyncCall("ListNames");
    repl.waitForFinished();

    if (! repl.isValid() ) {
        kError() << "Invalid reply while listing Media Players. MPRIS2 players will not be available." << repl.error();
        return 1;
    }

    foreach (QString busDestination , repl.value() ) {
        if ( busDestination.startsWith("org.mpris.MediaPlayer2") ){
            addMprisControlAsync(busDestination);
            kDebug() << "MPRIS2: Attached media player on busDestination=" << busDestination;
        }
    }

    return 0;
}

QString Mixer_MPRIS2::busDestinationToControlId(const QString& busDestination)
{
    const QString prefix = "org.mpris.MediaPlayer2.";
    if (! busDestination.startsWith(prefix)) {
        kWarning() << "Ignoring unsupported control, busDestination=" << busDestination;
        return QString();
    }

    return busDestination.mid(prefix.length());
}

/**
 * Asynchronously add the MPRIS control designated by the DBUS busDestination.
 * to the internal apps list.
 *
 * @param conn An open connection to the DBUS Session Bus
 * @param busDestination The DBUS busDestination, e.g. "org.mpris.MediaPlayer2.amarok"
 */
void Mixer_MPRIS2::addMprisControlAsync(QString busDestination)
{
    // -1- Create a MPrisControl. Its fields will be filled partially here, partially via ASYNC DUBUS replies
    QString id = busDestinationToControlId(busDestination);
    kDebug() << "Get control of busDestination=" << busDestination << "id=" << id;

    QDBusConnection conn = QDBusConnection::sessionBus();
    QDBusInterface *qdbiProps  = new QDBusInterface(QString(busDestination), QString("/org/mpris/MediaPlayer2"), "org.freedesktop.DBus.Properties", conn, this);
    QDBusInterface *qdbiPlayer = new QDBusInterface(QString(busDestination), QString("/org/mpris/MediaPlayer2"), "org.mpris.MediaPlayer2.Player", conn, this);

    // -2- Add the control to our official control list
    MPrisControl* mad = new MPrisControl(id, busDestination);
    mad->propertyIfc = qdbiProps;
    mad->playerIfc = qdbiPlayer;
    controls.insert(id, mad);


    /*
    * WTF: - asyncCall("Get", arg)                          : returns an error message (see below)
    *      - asyncCallWithArgumentList("Get", arg)          : returns an error message (see below)
    *      - callWithArgumentList(QDBus::Block, "Get", arg) : works
    *      - syncCall("Get", v1, v2)                        : works
    *
    * kmix(13543) Mixer_MPRIS2::addMPrisControl: (marok), msg2= QDBusMessage(type=Error, service=":1.44", error name="org.freedesktop.DBus.Error.UnknownMethod", error message="No such method 'Get' in interface 'org.freedesktop.DBus.Properties' at object path '/org/mpris/MediaPlayer2' (signature 'av')", signature="s", contents=("No such method 'Get' in interface 'org.freedesktop.DBus.Properties' at object path '/org/mpris/MediaPlayer2' (signature 'av')") ) , isValid= false , isFinished= true , isError= true
    *
    * This behavior is total counter-intuitive :-(((
    */

    // Create ASYNC DBUS queries for the new control. This effectively starts a chain of async DBUS commands.
    QVariant v1 = QVariant(QString("org.mpris.MediaPlayer2"));
    QVariant v2 = QVariant(QString("Identity"));
    QDBusPendingReply<QVariant > repl2 = mad->propertyIfc->asyncCall("Get", v1, v2);
    QDBusPendingCallWatcher* watchIdentity = new QDBusPendingCallWatcher(repl2, mad);
    connect(watchIdentity, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(watcherPlugControlId(QDBusPendingCallWatcher *)));
}

MixDevice::ChannelType Mixer_MPRIS2::getChannelTypeFromPlayerId(const QString& id)
{
    // TODO This hardcoded application list is a quick hack. It should be generalized.
    MixDevice::ChannelType ct = MixDevice::APPLICATION_STREAM;
    if (id.startsWith("amarok")) {
        ct = MixDevice::APPLICATION_AMAROK;
    } else if (id.startsWith("banshee")) {
        ct = MixDevice::APPLICATION_BANSHEE;
    } else if (id.startsWith("vlc")) {
        ct = MixDevice::APPLICATION_VLC;
    } else if (id.startsWith("xmms")) {
        ct = MixDevice::APPLICATION_XMM2;
    } else if (id.startsWith("tomahawk")) {
        ct = MixDevice::APPLICATION_TOMAHAWK;
    } else if (id.startsWith("clementine")) {
        ct = MixDevice::APPLICATION_CLEMENTINE;
    }

    return ct;
}

void Mixer_MPRIS2::watcherInitialVolume(QDBusPendingCallWatcher* watcher)
{
    MPrisControl* mprisCtl = watcherHelperGetMPrisControl(watcher);
    if (mprisCtl == 0)
        return; // Reply for unknown media player. Probably "unplugged" (or not yet plugged)

    const QDBusMessage& msg = watcher->reply();
    QList<QVariant> repl = msg.arguments();
    if ( ! repl.isEmpty() ) {
        QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(repl.at(0));
        QVariant result2 = dbusVariant.variant();
        double volume = result2.toDouble();
        volumeChanged(mprisCtl, volume);
    }

    watcher->deleteLater();
}

void Mixer_MPRIS2::watcherInitialPlayState(QDBusPendingCallWatcher* watcher)
{
    MPrisControl* mprisCtl = watcherHelperGetMPrisControl(watcher);
    if (mprisCtl == 0)
        return; // Reply for unknown media player. Probably "unplugged" (or not yet plugged)

    const QDBusMessage& msg = watcher->reply();
    QList<QVariant> repl = msg.arguments();
    if ( ! repl.isEmpty() ) {
        QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(repl.at(0));
        QVariant result2 = dbusVariant.variant();
        QString playbackStateString = result2.toString();

        MediaController::PlayState playState = Mixer_MPRIS2::mprisPlayStateString2PlayState(playbackStateString);
        playbackStateChanged(mprisCtl, playState);
    }

    watcher->deleteLater();
}


/**
 * Convenience method for the watcher*() methods.
 * Returns the MPrisControl that is parent of the given watcher, if the reply is valid. In this case you can
 * use the result and call watcher->deleteLater() after processing the result.
 *
 * Otherwise 0 is returned, and watcher->deleteLater() is called. <b>Important</b> You must call watcher->deleteLater()
 * yourself for the other (normal/good) case.
 *
 * @param watcher
 * @return
 */
MPrisControl* Mixer_MPRIS2::watcherHelperGetMPrisControl(QDBusPendingCallWatcher* watcher)
{
    const QDBusMessage& msg = watcher->reply();
    if ( msg.type() == QDBusMessage::ReplyMessage ) {
        QObject* obj = watcher->parent();
        MPrisControl* mad = qobject_cast<MPrisControl*>(obj);
        if (mad != 0) {
            return mad;
        }
            kWarning() << "Ignoring unexpected Control Id. object=" << obj;
    } else if ( msg.type() == QDBusMessage::ErrorMessage ) {
        kError() << "ERROR in Media control operation, path=" << msg.path() << ", msg=" << msg;
    }

    watcher->deleteLater();
    return 0;
}

void Mixer_MPRIS2::watcherPlugControlId(QDBusPendingCallWatcher* watcher)
{
    MPrisControl* mprisCtl = watcherHelperGetMPrisControl(watcher);
    if (mprisCtl == 0) {
        return; // Reply for unknown media player. Probably "unplugged" (or not yet plugged)
    }

    const QDBusMessage& msg = watcher->reply();
    QString id = mprisCtl->getId();
    QString busDestination = mprisCtl->getBusDestination();
    QString readableName = id; // Start with ID, but replace with reply (if exists)

    kDebug() << "Plugging id=" << id << ", busDestination" << busDestination << ", name= " << readableName;

    QList<QVariant> repl = msg.arguments();
    if ( ! repl.isEmpty() ) {
        // We have to do some very ugly casting from QVariant to QDBusVariant to QVariant. This API totally sucks.
        QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(repl.at(0));
        QVariant result2 = dbusVariant.variant();
        readableName = result2.toString();

//      kDebug() << "REPLY " << result2.type() << ": " << readableName;

        MixDevice::ChannelType ct = getChannelTypeFromPlayerId(id);
        MixDevice* mdNew = new MixDevice(_mixer, id, readableName, ct);
        // MPRIS2 doesn't support an actual mute switch. Mute is defined as volume = 0.0
        // Thus we won't add the playback switch
        Volume* vol = new Volume( 100, 0, false, false);
        vol->addVolumeChannel(VolumeChannel(Volume::LEFT)); // MPRIS is only one control ("Mono")
        MediaController* mediaContoller = mdNew->getMediaController();
        mediaContoller->addMediaPlayControl();
        mediaContoller->addMediaNextControl();
        mediaContoller->addMediaPrevControl();
        mdNew->setApplicationStream(true);
        mdNew->addPlaybackVolume(*vol);

        m_mixDevices.append( mdNew->addToPool() );

        delete vol; // vol is only temporary. mdNew has its own volume object. => delete

        QDBusConnection sessionBus = QDBusConnection::sessionBus();
        sessionBus.connect(busDestination, QString("/org/mpris/MediaPlayer2"), "org.freedesktop.DBus.Properties", "PropertiesChanged", mprisCtl, SLOT(onPropertyChange(QString,QVariantMap,QStringList)) );
        connect(mprisCtl, SIGNAL(volumeChanged(MPrisControl*,double)), this, SLOT(volumeChanged(MPrisControl*,double)) );
        connect(mprisCtl, SIGNAL(playbackStateChanged(MPrisControl*,MediaController::PlayState)), SLOT (playbackStateChanged(MPrisControl*,MediaController::PlayState)) );

        sessionBus.connect(busDestination, QString("/Player"), "org.freedesktop.MediaPlayer", "TrackChange", mprisCtl, SLOT(trackChangedIncoming(QVariantMap)) );

        // The following line is evil: mad->playerIfc->property("Volume") is in fact a synchronous call, and
        // sync calls are strictly forbidden, see bug 317926
        // volumeChanged(mad, mad->playerIfc->property("Volume").toDouble());


        // --- Query initial state --------------------------------------------------------------------------------
        QVariant v1 = QVariant(QString("org.mpris.MediaPlayer2.Player"));

        QVariant v2 = QVariant(QString("Volume"));
        QDBusPendingReply<QVariant > repl2 = mprisCtl->propertyIfc->asyncCall("Get", v1, v2);
        QDBusPendingCallWatcher* watcherOutgoing = new QDBusPendingCallWatcher(repl2, mprisCtl);
        connect(watcherOutgoing, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(watcherInitialVolume(QDBusPendingCallWatcher *)));

        v2 = QVariant(QString("PlaybackStatus"));
        repl2 = mprisCtl->propertyIfc->asyncCall("Get", v1, v2);
        watcherOutgoing = new QDBusPendingCallWatcher(repl2, mprisCtl);
        connect(watcherOutgoing, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(watcherInitialPlayState(QDBusPendingCallWatcher *)));

        // Push notifyToReconfigureControls to stack, so it will not be executed synchronously
        announceControlListAsync(id);
    }

    watcher->deleteLater();
}


// -----------------------------------------------------------------------------------------------------------
// ASYNC announce slots, including convenience wrappers
// -----------------------------------------------------------------------------------------------------------
/**
 * Convenience wrapper to do the ASYNC call to #announceControlList()
 * @param
 */
void Mixer_MPRIS2::announceControlListAsync(QString /*streamId*/)
{
    // currently we do not use the streamId
    QMetaObject::invokeMethod(this, "announceControlList", Qt::QueuedConnection);
}

void Mixer_MPRIS2::announceControlList()
{
    ControlManager::instance().announce(_mixer->id(), ControlChangeType::ControlList, getDriverName());
}

void Mixer_MPRIS2::announceGUI()
{
    ControlManager::instance().announce(_mixer->id(), ControlChangeType::GUI, getDriverName());
}

void Mixer_MPRIS2::announceVolume()
{
    ControlManager::instance().announce(_mixer->id(), ControlChangeType::Volume, getDriverName());
}

// -----------------------------------------------------------------------------------------------------------


/**
 * Handles the hotplug of new MPRIS2 enabled Media Players
 */
void Mixer_MPRIS2::newMediaPlayer(QString name, QString oldOwner, QString newOwner)
{
    if ( name.startsWith("org.mpris.MediaPlayer2") ) {
        if ( oldOwner.isEmpty() && !newOwner.isEmpty()) {
            kDebug() << "Mediaplayer registers: " << name;
            addMprisControlAsync(name);
        } else if ( !oldOwner.isEmpty() && newOwner.isEmpty()) {
            QString id = busDestinationToControlId(name);
            kDebug() << "Mediaplayer unregisters: " << name << " , id=" << id;

            // -1- Remove Mediaplayer connection
            if (controls.contains(id)) {
                const MPrisControl *control = controls.value(id);
                QObject::disconnect(control,0,0,0);
                controls.remove(id);
            }

            // -2- Remove MixDevice from internal list
            std::shared_ptr<MixDevice> md = m_mixDevices.get(id);
            if (md) {
                // We know about the player that is unregistering => remove internally
                md->close();
                m_mixDevices.removeById(id);
                announceControlListAsync(id);
                kDebug() << "MixDevice 4 useCount=" << md.use_count();
            }
        } else {
            kWarning() << "Mediaplayer has registered under a new name. This is currently not supported by KMix";
        }
    }
}

/**
 * This slot is a simple proxy that enriches the DBUS signal with our data, which especially contains the id of the MixDevice.
 */
void MPrisControl::trackChangedIncoming(QVariantMap /*msg*/)
{
    kDebug() << "Track changed";
}

MediaController::PlayState Mixer_MPRIS2::mprisPlayStateString2PlayState(const QString& playbackStatus)
{
    MediaController::PlayState playState = MediaController::PlayUnknown;
    if (playbackStatus == "Playing") {
        playState = MediaController::PlayPlaying;
    } else if (playbackStatus == "Stopped") {
        playState = MediaController::PlayStopped;
    } else if (playbackStatus == "Paused") {
        playState = MediaController::PlayPaused;
    }

    return playState;
}

/**
 * This slot is a simple proxy that enriches the DBUS signal with our data, which especially contains the id of the MixDevice.
 */
void MPrisControl::onPropertyChange(QString /*ifc*/,QVariantMap msg ,QStringList /*sl*/)
{
    QMap<QString, QVariant>::iterator v = msg.find("Volume");
    if (v != msg.end() ) {
        double volDouble = v.value().toDouble();
        kDebug(67100) << "volumeChanged incoming: vol=" << volDouble;
        emit volumeChanged( this, volDouble);
    }

    v = msg.find("PlaybackStatus");
    if (v != msg.end() ) {
        QString playbackStatus = v.value().toString();
        MediaController::PlayState playState = Mixer_MPRIS2::mprisPlayStateString2PlayState(playbackStatus);
        kDebug() << "PlaybackStatus is now " << playbackStatus;

        emit playbackStateChanged(this, playState);
    }
}


Mixer_MPRIS2::~Mixer_MPRIS2()
{
    close();
}

MPrisControl::MPrisControl(QString id, QString busDestination)
    : propertyIfc(0)
    , playerIfc(0)
{
    volume = 0;
    this->id = id;
    this->busDestination = busDestination;
    retrievedElems = MPrisControl::NONE;
}

MPrisControl::~MPrisControl()
{
    delete propertyIfc;
    delete playerIfc;
}

QString Mixer_MPRIS2::getDriverName()
{
    return "MPRIS2";
}

QString MPRIS2_getDriverName()
{
    return "MPRIS2";
}

#include "moc_mixer_mpris2.cpp"