m3uplayer/metadataloader.cpp

#include <QDebug>
#include <QApplication>
#include <QMediaPlayer>
#include "metadataloader.h"

using namespace Mobility;

MetaDataLoader::MetaDataLoader(QObject* parent) :
    Abstract::MetaDataLoader(parent) {
    setObjectName("MetaDataLoader");
    m_player = new QMediaPlayer(this);
    m_fetched = false;
    m_isRunning = false;
    m_timeOut.setSingleShot(true);
    connect (m_player, SIGNAL(metaDataChanged()), this, SLOT(fetch()));
    connect (&m_timeOut, SIGNAL(timeout()), this, SLOT(timeOutSlot()));
}


MetaDataLoader* MetaDataLoader::clone(QObject *parent) {
    return new MetaDataLoader(parent);
}

MetaDataLoader* MetaDataLoader::instance() {
    static MetaDataLoader* retval = 0;
    if (retval == 0) {
        qDebug() << "Mobility::MetaDataLoader";
        retval = new MetaDataLoader(qApp);
    }
    return retval;
}

void MetaDataLoader::get(QUrl url) {
    m_queue << url;
    if (!m_isRunning) {
         m_timer.singleShot(20, this, SLOT(checkForWork()));
    }
    else {
        m_timer.singleShot(2000, this, SLOT(checkForWork()));
    }
}


void MetaDataLoader::fetch() {
    static int numFields = 0;
    static int oldNumFields = 0;
    numFields = m_player->availableMetaData().count() + m_player->availableExtendedMetaData().count();
    // qDebug() << "NumFields: " << numFields;
    // qDebug() << "extended: " << m_player->availableExtendedMetaData().join(",");

    if (m_fetched) return;
    if (m_player->error() != QMediaPlayer::NoError) {
        qDebug() << "fetch error: " << m_player->errorString() << m_player->error();
        failed();
    }
    if (!m_player->metaData(QtMultimediaKit::AlbumArtist).isNull())
        m_current.setArtist(m_player->metaData(QtMultimediaKit::AlbumArtist).toString());
    if (!m_player->metaData(QtMultimediaKit::AlbumTitle).isNull())
        m_current.setAlbumTitle(m_player->metaData(QtMultimediaKit::AlbumTitle).toString());
    if (!m_player->metaData(QtMultimediaKit::TrackNumber).isNull())
        m_current.setTrackNumber(m_player->metaData(QtMultimediaKit::TrackNumber).toString());
    if (!m_player->metaData(QtMultimediaKit::Comment).isNull())
        m_current.setComment(m_player->metaData(QtMultimediaKit::Comment).toString());
    if (!m_player->metaData(QtMultimediaKit::Title).isNull())
        m_current.setTrackTitle(m_player->metaData(QtMultimediaKit::Title).toString());
    if (!m_player->metaData(QtMultimediaKit::Genre).isNull())
        m_current.setGenre(m_player->metaData(QtMultimediaKit::Genre).toString());
    // QVariant imgvar = m_player->metaData(QtMultimediaKit::CoverArtImage);
//    QList<QtMultimediaKit::MetaData> metadata = m_player->availableMetaData ();
//    QStringList sl = m_player->availableExtendedMetaData();
/*    if (!imgvar.isNull())
        m_current.setImage(qVariantValue<QImage>(imgvar)); */

    if (m_player->duration() > 0) {
        QTime t;
        t = t.addMSecs(m_player->duration());
        m_current.setTrackTime(t);
        timeOutSlot();
    }
}

void MetaDataLoader::checkForWork() {
    if (m_isRunning || m_queue.isEmpty()) return;
    m_isRunning = true;

    QUrl url = m_queue.first();
    m_queue.pop_front();
    m_current = MetaDataValue();
    m_current.setUrl(url);
//    qDebug() << " Fetching: " << url.toString();
    QMediaContent mc(url);
    m_fetched = false;
    m_player->setMedia(mc);
    if (m_player->error() == QMediaPlayer::ServiceMissingError ||m_player->error() == QMediaPlayer::ResourceError ) {
//        qDebug() << "media player error: " << m_player->errorString() << m_player->error();
        m_player->deleteLater();
        qDebug() << "MetaDataLoader starting new Media Player.";
        m_player = new QMediaPlayer(this);
        connect (m_player, SIGNAL(metaDataChanged()), this, SLOT(fetch()));
        m_player->setMedia(mc);
    }
    if (m_player->error() != QMediaPlayer::NoError) {
        qDebug() << "2nd media player error (fatal): " << m_player->errorString() << m_player->error();
        failed();
        return;
    }
    m_timeOut.singleShot(3000, this, SLOT(timeOutSlot()));
//    qDebug() << "checkExited";
}

void MetaDataLoader::cancel() {
    m_cancelled = true;
    m_queue.clear();
}

void MetaDataLoader::get(QList<QUrl> fns) {
    m_queue << fns;
    checkForWork();
}
const QStringList& MetaDataLoader::supportedExtensions() {
    // TODO: get from QMediaServiceProvider::supportedMimeTypes ()
    static QStringList sl;
    if (sl.isEmpty()) {
        sl << "*.mp3" << "*.flac" << "*.wma" << "*.ogg" << "*.aiff";
    }
    return sl;
}

void MetaDataLoader::timeOutSlot() {
    if (m_fetched) return;
    m_timeOut.stop();    
    m_isRunning = false;
    m_fetched = true;
    m_player->stop();
    emit fetched(m_current);
    // Give a short delay so we don't thrash the player
    m_timer.singleShot(400, this, SLOT(checkForWork()));
}

void MetaDataLoader::failed() {
    if (!m_isRunning) return;
    m_isRunning = false;
    qDebug() << "Failed to fetch: " << m_current.url();
    m_timer.singleShot(400, this, SLOT(checkForWork()));
}

bool MetaDataLoader::isRunning() const {
    return m_isRunning;
}