/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qmobilityglobal.h>

#include <QtTest/QtTest>

#include <QtCore/qdir.h>

#include <qmediaimageviewer.h>

#include <qmediaimageviewerservice_p.h>

#include <qmediaplaylist.h>

#include <qmediaservice.h>

#include <qvideorenderercontrol.h>

#include <qvideowidgetcontrol.h>

#include <QtCore/qfile.h>

#include <QtNetwork/qnetworkaccessmanager.h>

#include <QtNetwork/qnetworkreply.h>

#include <qabstractvideosurface.h>

#include <qvideosurfaceformat.h>

#if defined(Q_OS_SYMBIAN)

# define TESTDATA_DIR "./tst_qmediaimageviewer_images"

#endif

QT_USE_NAMESPACE

class QtTestNetworkAccessManager;

class tst_QMediaImageViewer : public QObject

{

    Q_OBJECT

private slots:

    void initTestCase();

    void isValid();

    void timeout();

    void setMedia_data();

    void setMedia();

    void setConsecutiveMedia();

    void setInvalidMedia();

    void playlist();

    void multiplePlaylists();

    void invalidPlaylist();

    void elapsedTime();

    void rendererControl();

public:

    tst_QMediaImageViewer() : m_network(0), m_imageDir(QLatin1String(TESTDATA_DIR)) {}

private:

    QUrl imageUrl(const char *fileName) const {

        return QUrl::fromLocalFile(m_imageDir.absoluteFilePath(QLatin1String(fileName))); }

    QString imageFileName(const char *fileName) {

        return m_imageDir.absoluteFilePath(QLatin1String(fileName)); }

    QtTestNetworkAccessManager *m_network;

    QDir m_imageDir;

    QString m_fileProtocol;

};

Q_DECLARE_METATYPE(QMediaImageViewer::State)

Q_DECLARE_METATYPE(QMediaImageViewer::MediaStatus)

class QtTestVideoSurface : public QAbstractVideoSurface

{

public:

    QList<QVideoFrame::PixelFormat> supportedPixelFormats(

            QAbstractVideoBuffer::HandleType handleType) const {

        QList<QVideoFrame::PixelFormat> formats;

        if (handleType == QAbstractVideoBuffer::NoHandle) {

            formats << QVideoFrame::Format_RGB32;

        }

        return formats;

    }

    QVideoFrame frame() const { return m_frame;  }

    bool present(const QVideoFrame &frame) { m_frame = frame; return true; }

private:

    QVideoFrame m_frame;

};

class QtTestNetworkReply : public QNetworkReply

{

public:

    QtTestNetworkReply(

            const QNetworkRequest &request,

            const QByteArray &mimeType,

            QObject *parent)

        : QNetworkReply(parent)

    {

        setRequest(request);

        setOperation(QNetworkAccessManager::HeadOperation);

        setRawHeader("content-type", mimeType);

        QCoreApplication::postEvent(this, new QEvent(QEvent::User));

    }

    QtTestNetworkReply(

            const QNetworkRequest &request,

            const QByteArray &mimeType,

            const QString &fileName,

            QObject *parent)

        : QNetworkReply(parent)

        , m_file(fileName)

    {

        setRequest(request);

        setOperation(QNetworkAccessManager::GetOperation);

        setRawHeader("content-type", mimeType);

        if (m_file.open(QIODevice::ReadOnly | QIODevice::Unbuffered)) {

            setOpenMode(QIODevice::ReadOnly);

        }

        QCoreApplication::postEvent(this, new QEvent(QEvent::User));

    }

    void abort() { m_file.close(); }

    bool atEnd () const { return m_file.atEnd(); }

    qint64 bytesAvailable() const { return m_file.bytesAvailable() + QIODevice::bytesAvailable(); }

    void close() { m_file.close(); setOpenMode(QIODevice::NotOpen); }

    bool isSequential() const { return true; }

    bool open(OpenMode) { return false; }

    qint64 pos() const { return 0; }

    bool seek(qint64) { return false; }

    qint64 size() const { return m_file.size(); }

    qint64 readData(char * data, qint64 maxSize) { return m_file.read(data, maxSize); }

    qint64 writeData(const char *, qint64) { return -1; }

protected:

    void customEvent(QEvent *event)

    {

        if (event->type() == QEvent::User) {

            event->accept();

            emit finished();

        }

    }

private:

    QFile m_file;

};

class QtTestNetworkAccessManager : public QNetworkAccessManager

{

public:

    QtTestNetworkAccessManager(QObject *parent = 0)

        : QNetworkAccessManager(parent)

    {

    }

    void appendDocument(const QUrl &url, const QByteArray &mimeType, const QString &fileName)

    {

        m_documents.append(Document(url, mimeType, fileName));

    }

protected:

    QNetworkReply *createRequest(

            Operation op, const QNetworkRequest &request, QIODevice *outgoingData = 0)

    {

        foreach (const Document &document, m_documents) {

            if (document.url == request.url()) {

                if (op == GetOperation) {

                    return new QtTestNetworkReply(

                            request, document.mimeType, document.fileName, this);

                } else if (op == HeadOperation) {

                    return new QtTestNetworkReply(request, document.mimeType, this);

                }

            }

        }

        return QNetworkAccessManager::createRequest(op, request, outgoingData);

    }

private:

    struct Document

    {

        Document(const QUrl url, const QByteArray mimeType, const QString &fileName)

            : url(url), mimeType(mimeType), fileName(fileName)

        {

        }

        QUrl url;

        QByteArray mimeType;

        QString fileName;

    };

    QList<Document> m_documents;

};

void tst_QMediaImageViewer::initTestCase()

{

    qRegisterMetaType<QMediaImageViewer::State>();

    qRegisterMetaType<QMediaImageViewer::MediaStatus>();

    m_network = new QtTestNetworkAccessManager(this);

    m_network->appendDocument(

            QUrl(QLatin1String("test://image/png?id=1")),

            "image/png",

            imageFileName("image.png"));

    m_network->appendDocument(

            QUrl(QLatin1String("test://image/png?id=2")),

            QByteArray(),

            imageFileName("image.png"));

    m_network->appendDocument(

            QUrl(QLatin1String("test://image/invalid?id=1")),

            "image/png",

            imageFileName("invalid.png"));

    m_network->appendDocument(

            QUrl(QLatin1String("test://image/invalid?id=2")),

            QByteArray(),

            imageFileName("invalid.png"));

#ifdef QTEST_HAVE_JPEG

    m_network->appendDocument(

            QUrl(QLatin1String("test://image/jpeg?id=1")),

            "image/jpeg",

            imageFileName("image.jpg"));

#endif

    m_network->appendDocument(

            QUrl(QLatin1String("test://music/songs/mp3?id=1")),

             "audio/mpeg",

             QString());

    m_network->appendDocument(

            QUrl(QLatin1String("test://music/covers/small?id=1")),

            "image/png",

            imageFileName("coverart.png"));

    m_network->appendDocument(

            QUrl(QLatin1String("test://music/covers/large?id=1")),

            "image/png",

            imageFileName("coverart.png"));

    m_network->appendDocument(

            QUrl(QLatin1String("test://video/movies/mp4?id=1")),

            "video/mp4",

            QString());

    m_network->appendDocument(

            QUrl(QLatin1String("test://video/posters/png?id=1")),

            "image/png",

            imageFileName("poster.png"));

}

void tst_QMediaImageViewer::isValid()

{

    QMediaImageViewer viewer;

    QVERIFY(viewer.service() != 0);

}

void tst_QMediaImageViewer::timeout()

{

    QMediaImageViewer viewer;

    QCOMPARE(viewer.timeout(), 3000);

    viewer.setTimeout(0);

    QCOMPARE(viewer.timeout(), 0);

    viewer.setTimeout(45);

    QCOMPARE(viewer.timeout(), 45);

    viewer.setTimeout(-3000);

    QCOMPARE(viewer.timeout(), 0);

}

void tst_QMediaImageViewer::setMedia_data()

{

    QTest::addColumn<QMediaContent>("media");

    {

        QMediaContent media(imageUrl("image.png"));

        QTest::newRow("file: png image")

                << media;

    } {

        QMediaContent media(QUrl(QLatin1String("test://image/png?id=1")));

        QTest::newRow("network: png image")

                << media;

    } {

        QMediaContent media(QMediaResource(

                QUrl(QLatin1String("test://image/png?id=1")), QLatin1String("image/png")));

        QTest::newRow("network: png image, explicit mime type")

                << media;

    } {

        QMediaContent media(QUrl(QLatin1String("test://image/png?id=2")));

        QTest::newRow("network: png image, no mime type")

                << media;

#ifdef QTEST_HAVE_JPEG

    } {

        QMediaContent media(imageUrl("image.jpg"));

        QTest::newRow("file: jpg image")

                << media;

    } {

        QMediaContent media(QUrl(QLatin1String("test://image/jpeg?id=1")));

        QTest::newRow("network: jpg image")

                << media;

#endif

    }

}

void tst_QMediaImageViewer::setMedia()

{

    QFETCH(QMediaContent, media);

    QMediaImageViewer viewer;

    QMediaImageViewerService *service = qobject_cast<QMediaImageViewerService *>(viewer.service());

    service->setNetworkManager(m_network);

    connect(&viewer, SIGNAL(mediaStatusChanged(QMediaImageViewer::MediaStatus)),

            &QTestEventLoop::instance(), SLOT(exitLoop()));

    viewer.setMedia(media);

    QCOMPARE(viewer.media(), media);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

    QTestEventLoop::instance().enterLoop(2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadedMedia);

}

void tst_QMediaImageViewer::setConsecutiveMedia()

{

    QMediaContent fileMedia1(imageUrl("image.png"));

    QMediaContent fileMedia2(imageUrl("coverart.png"));

    QMediaContent networkMedia1(QUrl(QLatin1String("test://image/png?id=1")));

    QMediaContent networkMedia2(QUrl(QLatin1String("test://image/png?id=2")));

    QMediaImageViewer viewer;

    connect(&viewer, SIGNAL(mediaStatusChanged(QMediaImageViewer::MediaStatus)),

            &QTestEventLoop::instance(), SLOT(exitLoop()));

    viewer.setMedia(fileMedia1);

    viewer.setMedia(fileMedia2);

    QCOMPARE(viewer.media(), fileMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

    QTestEventLoop::instance().enterLoop(2);

    QCOMPARE(viewer.media(), fileMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadedMedia);

    QMediaImageViewerService *service = qobject_cast<QMediaImageViewerService *>(viewer.service());

    service->setNetworkManager(m_network);

    viewer.setMedia(networkMedia1);

    viewer.setMedia(networkMedia2);

    QCOMPARE(viewer.media(), networkMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

    QTestEventLoop::instance().enterLoop(2);

    QCOMPARE(viewer.media(), networkMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadedMedia);

    viewer.setMedia(fileMedia1);

    viewer.setMedia(networkMedia2);

    QCOMPARE(viewer.media(), networkMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

    QTestEventLoop::instance().enterLoop(2);

    QCOMPARE(viewer.media(), networkMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadedMedia);

    viewer.setMedia(networkMedia1);

    viewer.setMedia(fileMedia2);

    QCOMPARE(viewer.media(), fileMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

    QTestEventLoop::instance().enterLoop(2);

    QCOMPARE(viewer.media(), fileMedia2);

    QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadedMedia);

}

void tst_QMediaImageViewer::setInvalidMedia()

{

    QMediaImageViewer viewer;

    QMediaImageViewerService *service = qobject_cast<QMediaImageViewerService *>(viewer.service());

    service->setNetworkManager(m_network);

    connect(&viewer, SIGNAL(mediaStatusChanged(QMediaImageViewer::MediaStatus)),

            &QTestEventLoop::instance(), SLOT(exitLoop()));

    {

        QMediaContent media(imageUrl("invalid.png"));

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaContent media(imageUrl("deleted.png"));

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaResource invalidResource(imageUrl("invalid.png"));

        QMediaResource deletedResource(imageUrl("deleted.png"));

        QMediaContent media(QMediaResourceList() << invalidResource << deletedResource);

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaResource resource(imageUrl("image.png"), QLatin1String("audio/mpeg"));

        QMediaContent media(resource);

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaResource audioResource(imageUrl("image.png"), QLatin1String("audio/mpeg"));

        QMediaResource invalidResource(imageUrl("invalid.png"));

        QMediaContent media(QMediaResourceList() << audioResource << invalidResource);

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaContent media(QUrl(QLatin1String("test://image/invalid?id=1")));

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaContent media(QUrl(QLatin1String("test://image/invalid?id=2")));

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    } {

        QMediaContent media(QUrl(QLatin1String("test://image/invalid?id=3")));

        viewer.setMedia(media);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::LoadingMedia);

        QTestEventLoop::instance().enterLoop(2);

        QCOMPARE(viewer.mediaStatus(), QMediaImageViewer::InvalidMedia);

        QCOMPARE(viewer.media(), media);

    }

}

void tst_QMediaImageViewer::playlist()

{

    QMediaContent imageMedia(imageUrl("image.png"));

    QMediaContent posterMedia(imageUrl("poster.png"));

    QMediaContent coverArtMedia(imageUrl("coverart.png"));

    QMediaImageViewer viewer;

    viewer.setTimeout(250);

    connect(&viewer, SIGNAL(mediaStatusChanged(QMediaImageViewer::MediaStatus)),

            &QTestEventLoop::instance(), SLOT(exitLoop()));

    QSignalSpy stateSpy(&viewer, SIGNAL(stateChanged(QMediaImageViewer::State)));

    QCOMPARE(viewer.state(), QMediaImageViewer::StoppedState);

    // No playlist so can't exit stopped state.

    viewer.play();

    QCOMPARE(viewer.state(), QMediaImageViewer::StoppedState);

    QCOMPARE(stateSpy.count(), 0);