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

**

** 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 <QtCore/qcoreevent.h>

#include <QtCore/qmetaobject.h>

#include <QtCore/qtimer.h>

#include <QtCore/qdebug.h>

#include <QtCore/qpointer.h>

#include "qmediaplayer.h"

QT_BEGIN_NAMESPACE

/*!

    \class QMediaPlayer

    \brief The QMediaPlayer class allows the playing of a media source.

    \ingroup multimedia

    \preliminary

    The QMediaPlayer class is a high level media playback class. It can be used

    to playback such content as songs, movies and internet radio. The content

    to playback is specified as a QMediaContent, which can be thought of as a

    main or canonical URL with addition information attached. When provided

    with a QMediaContent playback may be able to commence.

    \code

        player = new QMediaPlayer;

        connect(player, SIGNAL(positionChanged(qint64)), this, SLOT(positionChanged(qint64)));

        player->setMedia(QUrl::fromLocalFile("/Users/me/Music/coolsong.mp3"));

        player->setVolume(50);

        player->play();

    \endcode

    QVideoWidget can be used with QMediaPlayer for video rendering and QMediaPlaylist

    for accessing playlist functionality.

    \code

        playlist = new QMediaPlaylist;

        playlist->append(QUrl("http://example.com/movie1.mp4"));

        playlist->append(QUrl("http://example.com/movie2.mp4"));

        widget = new QVideoWidget;

        widget->show();

        player->play();

    \endcode

    \sa QMediaObject, QMediaService, QVideoWidget, QMediaPlaylist

*/

namespace

{

class MediaPlayerRegisterMetaTypes

{

public:

    MediaPlayerRegisterMetaTypes()

    {

        qRegisterMetaType<QMediaPlayer::State>("QMediaPlayer::State");

        qRegisterMetaType<QMediaPlayer::MediaStatus>("QMediaPlayer::MediaStatus");

        qRegisterMetaType<QMediaPlayer::Error>("QMediaPlayer::Error");

    }

} _registerPlayerMetaTypes;

}

class QMediaPlayerPrivate : public QMediaObjectPrivate

{

    Q_DECLARE_NON_CONST_PUBLIC(QMediaPlayer)

public:

    QMediaPlayerPrivate()

        : provider(0)

        , control(0)

        , state(QMediaPlayer::StoppedState)

        , error(QMediaPlayer::NoError)

        , filterStates(false)

        , playlist(0)

    {}

    QMediaServiceProvider *provider;

    QMediaPlayerControl* control;

    QMediaPlayer::State state;

    QMediaPlayer::Error error;

    QString errorString;

    bool filterStates;

    QMediaPlaylist *playlist;

    void _q_stateChanged(QMediaPlayer::State state);

    void _q_mediaStatusChanged(QMediaPlayer::MediaStatus status);

    void _q_error(int error, const QString &errorString);

    void _q_updateMedia(const QMediaContent&);

    void _q_playlistDestroyed();

};

void QMediaPlayerPrivate::_q_stateChanged(QMediaPlayer::State ps)

{

    Q_Q(QMediaPlayer);

    if (filterStates)

        return;

    if (playlist

            && ps != state && ps == QMediaPlayer::StoppedState

            && control->mediaStatus() == QMediaPlayer::EndOfMedia) {

        playlist->next();

        ps = control->state();

    }

    if (ps != state) {

        state = ps;

        if (ps == QMediaPlayer::PlayingState)

            q->addPropertyWatch("position");

        else

            q->removePropertyWatch("position");

        emit q->stateChanged(ps);

    }

}

void QMediaPlayerPrivate::_q_mediaStatusChanged(QMediaPlayer::MediaStatus status)

{

    Q_Q(QMediaPlayer);

    switch (status) {

    case QMediaPlayer::StalledMedia:

    case QMediaPlayer::BufferingMedia:

        q->addPropertyWatch("bufferStatus");

        emit q->mediaStatusChanged(status);

        break;

    default:

        q->removePropertyWatch("bufferStatus");

        emit q->mediaStatusChanged(status);

        break;

    }

}

void QMediaPlayerPrivate::_q_error(int error, const QString &errorString)

{

    Q_Q(QMediaPlayer);

    this->error = QMediaPlayer::Error(error);

    this->errorString = errorString;

    emit q->error(this->error);

}

void QMediaPlayerPrivate::_q_updateMedia(const QMediaContent &media)

{

    const QMediaPlayer::State currentState = state;

    filterStates = true;

    control->setMedia(media, 0);

    if (!media.isNull()) {

        switch (currentState) {

        case QMediaPlayer::PlayingState:

            control->play();

            break;

        case QMediaPlayer::PausedState:

            control->pause();

            break;

        default:

            break;

        }

    }

    filterStates = false;

    state = control->state();

    if (state != currentState)

        emit q_func()->stateChanged(state);

}

void QMediaPlayerPrivate::_q_playlistDestroyed()

{

    playlist = 0;

    control->setMedia(QMediaContent(), 0);

}

static QMediaService *playerService(QMediaPlayer::Flags flags, QMediaServiceProvider *provider)

{

    if (flags) {

        QMediaServiceProviderHint::Features features = 0;

        if (flags & QMediaPlayer::LowLatency)

            features |= QMediaServiceProviderHint::LowLatencyPlayback;

        if (flags & QMediaPlayer::StreamPlayback)

            features |= QMediaServiceProviderHint::StreamPlayback;

        return provider->requestService(Q_MEDIASERVICE_MEDIAPLAYER,

                                        QMediaServiceProviderHint(features));

    } else

        return provider->requestService(Q_MEDIASERVICE_MEDIAPLAYER);

}

/*!

    Construct a QMediaPlayer that uses the playback service from \a provider,

    parented to \a parent and with \a flags.

    If a playback service is not specified the system default will be used.

*/

QMediaPlayer::QMediaPlayer(QObject *parent, QMediaPlayer::Flags flags, QMediaServiceProvider *provider):

    QMediaObject(*new QMediaPlayerPrivate,

                 parent,

                 playerService(flags,provider))

{

    Q_D(QMediaPlayer);

    d->provider = provider;

    if (d->service == 0) {

        d->error = ServiceMissingError;

    } else {

        if (d->control != 0) {

            connect(d->control, SIGNAL(mediaChanged(QMediaContent)), SIGNAL(mediaChanged(QMediaContent)));

            connect(d->control, SIGNAL(stateChanged(QMediaPlayer::State)), SLOT(_q_stateChanged(QMediaPlayer::State)));

            connect(d->control, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),

                    SLOT(_q_mediaStatusChanged(QMediaPlayer::MediaStatus)));

            connect(d->control, SIGNAL(error(int,QString)), SLOT(_q_error(int,QString)));

            connect(d->control, SIGNAL(durationChanged(qint64)), SIGNAL(durationChanged(qint64)));

            connect(d->control, SIGNAL(positionChanged(qint64)), SIGNAL(positionChanged(qint64)));

            connect(d->control, SIGNAL(audioAvailableChanged(bool)), SIGNAL(audioAvailableChanged(bool)));

            connect(d->control, SIGNAL(videoAvailableChanged(bool)), SIGNAL(videoAvailableChanged(bool)));

            connect(d->control, SIGNAL(volumeChanged(int)), SIGNAL(volumeChanged(int)));

            connect(d->control, SIGNAL(mutedChanged(bool)), SIGNAL(mutedChanged(bool)));

            connect(d->control, SIGNAL(seekableChanged(bool)), SIGNAL(seekableChanged(bool)));

            connect(d->control, SIGNAL(playbackRateChanged(qreal)), SIGNAL(playbackRateChanged(qreal)));

            if (d->control->state() == PlayingState)

                addPropertyWatch("position");

            if (d->control->mediaStatus() == StalledMedia || d->control->mediaStatus() == BufferingMedia)

                addPropertyWatch("bufferStatus");

        }

    }

}

/*!

    Destroys the player object.

*/

QMediaPlayer::~QMediaPlayer()

{

    Q_D(QMediaPlayer);

    d->provider->releaseService(d->service);

}

QMediaContent QMediaPlayer::media() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->media();

    return QMediaContent();

}

/*!

    Returns the stream source of media data.

    This is only valid if a stream was passed to setMedia().

    \sa setMedia()

*/

const QIODevice *QMediaPlayer::mediaStream() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->mediaStream();

    return 0;

}

QMediaPlayer::State QMediaPlayer::state() const

{

    return d_func()->state;

}

QMediaPlayer::MediaStatus QMediaPlayer::mediaStatus() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->mediaStatus();

    return QMediaPlayer::UnknownMediaStatus;

}

qint64 QMediaPlayer::duration() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->duration();

    return -1;

}

qint64 QMediaPlayer::position() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->position();

    return 0;

}

int QMediaPlayer::volume() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->volume();

    return 0;

}

bool QMediaPlayer::isMuted() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->isMuted();

    return false;

}

int QMediaPlayer::bufferStatus() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->bufferStatus();

    return 0;

}

bool QMediaPlayer::isAudioAvailable() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->isAudioAvailable();

    return false;

}

bool QMediaPlayer::isVideoAvailable() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->isVideoAvailable();

    return false;

}

bool QMediaPlayer::isSeekable() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->isSeekable();

    return false;

}

qreal QMediaPlayer::playbackRate() const

{

    Q_D(const QMediaPlayer);

    if (d->control != 0)

        return d->control->playbackRate();

    return 0.0;

}

/*!

    Returns the current error state.

*/

QMediaPlayer::Error QMediaPlayer::error() const

{

    return d_func()->error;

}

QString QMediaPlayer::errorString() const

{

    return d_func()->errorString;

}

//public Q_SLOTS:

/*!