webradio/radio.cpp

#include "radio.h"
#include "yaml-cpp/yaml.h"
#include <QDebug>
#include <QUrlQuery>

Radio::Radio(QObject *parent) : QObject(parent), logo(0, 0)
{
    mgr = 0;
    logoTries = 0;
    currentSong = 0;
    songsTries = 0;
    streamTries = 0;
    stream = 0;
    songTimer = new QTimer(this);
    songTimer->setSingleShot(true);
    connect(songTimer, SIGNAL(timeout()), this, SLOT(songEnded()));
}

QString Radio::getName()
{
    return name;
}

QString Radio::getClaim()
{
    return claim;
}

QColor Radio::getTextColor()
{
    return textColor;
}

QUrl Radio::getLogoUrl()
{
    return logoUrl;
}

QUrl Radio::getStreamUrl()
{
    return streamUrl;
}

int Radio::getId()
{
    return id;
}

QUrl Radio::getApiBase()
{
    return apiBase;
}

QUrl Radio::getCoverBase()
{
    return coverBase;
}

Song *Radio::getCurrentSong()
{
    return currentSong;
}

QNetworkReply *Radio::getStream()
{
    return stream;
}

void Radio::setName(QString n)
{
    name = n;
}

void Radio::setClaim(QString c)
{
    claim = c;
}

void Radio::setTextColor(QColor c)
{
    textColor = c;
}

void Radio::setLogoUrl(QUrl u)
{
    logoUrl = u;
}

void Radio::setStreamUrl(QUrl u)
{
    streamUrl = u;
}

void Radio::setId(int i)
{
    id = i;
}

void Radio::setApiBase(QUrl u)
{
    apiBase = u;
}

void Radio::setCoverBase(QUrl u)
{
    coverBase = u;
}

void Radio::setCurrentSong(Song *s)
{
    if(currentSong != 0)
        currentSong->deleteLater();
    currentSong = s;
    songTimer->stop();
    if(s->getDuration() < 0)
        qDebug()<<s->getDuration()<<name;
    songTimer->setInterval(s->getDuration());
    songTimer->start();
    nextSongs.removeOne(currentSong);
    updateNextSongs();
    emit songChanged(currentSong);
}

void Radio::updateNextSongs()
{
    songsTries = 0;
    QUrl url = apiBase;
    QUrlQuery query;
    query.addQueryItem("act", "get_plist");
    query.addQueryItem("id_wr", QString::number(id));
    url.setQuery(query);
    QNetworkReply* reply = mgr->get(QNetworkRequest(url));
    connect(reply, SIGNAL(finished()), this, SLOT(songsFinished()));
    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(songsError(QNetworkReply::NetworkError)));
}

void Radio::downloadLogo()
{
    if(logo.isNull())
    {
        logoTries = 0;
        QNetworkReply* reply = mgr->get(QNetworkRequest(logoUrl));
        connect(reply, SIGNAL(finished()), this, SLOT(logoFinished()));
        connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(logoError(QNetworkReply::NetworkError)));
    }
    else
        emit logoDownloaded(logo);
}

void Radio::startStream()
{
    stopStream();
    streamTries = 0;
    stream = mgr->get(QNetworkRequest(streamUrl));
    stream->setReadBufferSize(128);
    connect(stream, SIGNAL(readyRead()), this, SLOT(streamRead()));
    emit streamChanged(stream);
}

void Radio::stopStream()
{
    if(stream != 0)
    {
        stream->abort();
        stream->deleteLater();
        stream = 0;
    }
}

void Radio::logoFinished()
{
    QNetworkReply* reply = (QNetworkReply*)sender();

    if(logo.loadFromData(reply->readAll()) && !logo.isNull())
        emit logoDownloaded(logo);
}

void Radio::logoError(QNetworkReply::NetworkError)
{
    if(logoTries < 3)
    {
        ++logoTries;
        downloadLogo();
    }
}

void Radio::songsFinished()
{
    QNetworkReply* reply = (QNetworkReply*)sender();
    YAML::Node itms = YAML::Load(reply->readAll().constData())["itms"];
    qDeleteAll(nextSongs);
    for(unsigned i = 1;i < itms.size(); ++i)
    {
        YAML::Node itm = itms[i];
        if(itm["id"].as<int>() == -1)
            continue;
        Song* song = new Song(this);
        song->setDuration(itm["t_dur"].as<int>());
        song->setArtist(itm["art"].as<std::string>().c_str());
        song->setTitle(itm["tit"].as<std::string>().c_str());
        QUrl url = coverBase;
        url.setPath(url.path() + itm["cov"].as<std::string>().c_str());
        song->setCoverUrl(url);
        nextSongs.append(song);
    }
}

void Radio::songsError(QNetworkReply::NetworkError)
{
    if(songsTries < 3)
    {
        ++songsTries;
        updateNextSongs();
    }
}

void Radio::streamRead()
{
    if(stream->header(QNetworkRequest::LocationHeader).toUrl().isEmpty())
        emit streamData(stream->readAll());
    else
    {
        streamUrl = stream->header(QNetworkRequest::LocationHeader).toUrl();
        stopStream();
        startStream();
    }
}

void Radio::streamError()
{
    if(streamTries < 3)
    {
        ++streamTries;
        stopStream();
        startStream();
    }
}

void Radio::songEnded()
{
    if(!nextSongs.isEmpty())
        setCurrentSong(nextSongs.at(0));
}

void Radio::setNetworkManager(QNetworkAccessManager *m)
{
    mgr = m;
}