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

**

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

#include "qmediaobject_p.h"

QT_BEGIN_NAMESPACE

void QMediaObjectPrivate::_q_notify()

{

    Q_Q(QMediaObject);

    const QMetaObject* m = q->metaObject();

    foreach (int pi, notifyProperties) {

        QMetaProperty p = m->property(pi);

        p.notifySignal().invoke(

            q, QGenericArgument(QMetaType::typeName(p.userType()), p.read(q).data()));

    }

}

/*!

    \class QMediaObject

    \preliminary

    \brief The QMediaObject class provides a common base for multimedia objects.

    \ingroup multimedia

    QMediaObject derived classes provide access to the functionality of a

    QMediaService.  Each media object hosts a QMediaService and uses the

    QMediaControl interfaces implemented by the service to implement its

    API.  Most media objects when constructed will request a new

    QMediaService instance from a QMediaServiceProvider, but some like

    QMediaRecorder will share a service with another object.

    QMediaObject itself provides an API for accessing a media service's \l {metaData()}{meta-data} and a means of connecting other media objects,

    and peripheral classes like QVideoWidget and QMediaPlaylist.

    \sa QMediaService, QMediaControl

*/

/*!

    Destroys a media object.

*/

QMediaObject::~QMediaObject()

{

    delete d_ptr;

}

/*!

    Returns the service availability error state.

*/

{

}

/*!

    Returns true if the service is available for use.

*/

bool QMediaObject::isAvailable() const

{

    return false;

}

/*!

    Returns the media service that provides the functionality of a multimedia object.

*/

QMediaService* QMediaObject::service() const

{

    return d_func()->service;

}

int QMediaObject::notifyInterval() const

{

    return d_func()->notifyTimer->interval();

}

void QMediaObject::setNotifyInterval(int milliSeconds)

{

    Q_D(QMediaObject);

    if (d->notifyTimer->interval() != milliSeconds) {

        d->notifyTimer->setInterval(milliSeconds);

        emit notifyIntervalChanged(milliSeconds);

    }

}

/*!

*/

{

}

/*!

*/

{

}

/*!

    Constructs a media object which uses the functionality provided by a media \a service.

    The \a parent is passed to QObject.

    This class is meant as a base class for Multimedia objects so this

    constructor is protected.

*/

QMediaObject::QMediaObject(QObject *parent, QMediaService *service):

    QObject(parent),

    d_ptr(new QMediaObjectPrivate)

{

    Q_D(QMediaObject);

    d->q_ptr = this;

    d->notifyTimer = new QTimer(this);

    d->notifyTimer->setInterval(1000);

    connect(d->notifyTimer, SIGNAL(timeout()), SLOT(_q_notify()));

    d->service = service;

    setupMetaData();

}

/*!

    \internal

*/

QMediaObject::QMediaObject(QMediaObjectPrivate &dd, QObject *parent,

                                            QMediaService *service):

    QObject(parent),

    d_ptr(&dd)

{

    Q_D(QMediaObject);

    d->q_ptr = this;

    d->notifyTimer = new QTimer(this);

    d->notifyTimer->setInterval(1000);

    connect(d->notifyTimer, SIGNAL(timeout()), SLOT(_q_notify()));

    d->service = service;

    setupMetaData();

}

/*!

    Watch the property \a name. The property's notify signal will be emitted

    once every notifyInterval milliseconds.

    \sa notifyInterval

*/

void QMediaObject::addPropertyWatch(QByteArray const &name)

{

    Q_D(QMediaObject);

    const QMetaObject* m = metaObject();

    int index = m->indexOfProperty(name.constData());

    if (index != -1 && m->property(index).hasNotifySignal()) {

        d->notifyProperties.insert(index);

        if (!d->notifyTimer->isActive())

            d->notifyTimer->start();

    }

}

/*!

    Remove property \a name from the list of properties whose changes are

    regularly signaled.

    \sa notifyInterval

*/

void QMediaObject::removePropertyWatch(QByteArray const &name)

{

    Q_D(QMediaObject);

    int index = metaObject()->indexOfProperty(name.constData());

    if (index != -1) {

        d->notifyProperties.remove(index);

        if (d->notifyProperties.isEmpty())

            d->notifyTimer->stop();

    }

}

/*!

    \property QMediaObject::notifyInterval

    The interval at which notifiable properties will update.

    The interval is expressed in milliseconds, the default value is 1000.

    \sa addPropertyWatch(), removePropertyWatch()

*/

/*!

    \fn void QMediaObject::notifyIntervalChanged(int milliseconds)

    Signal a change in the notify interval period to \a milliseconds.

*/

/*!

    \property QMediaObject::metaDataAvailable

    \brief whether access to a media object's meta-data is available.

    If this is true there is meta-data available, otherwise there is no meta-data available.

*/

bool QMediaObject::isMetaDataAvailable() const

{

    Q_D(const QMediaObject);

    return d->metaDataControl

            ? d->metaDataControl->isMetaDataAvailable()

            : false;

}

/*!

    \fn QMediaObject::metaDataAvailableChanged(bool available)

    Signals that the \a available state of a media object's meta-data has changed.

*/

/*!

    Returns the value associated with a meta-data \a key.

*/

{

    Q_D(const QMediaObject);

    return d->metaDataControl

            ? d->metaDataControl->metaData(key)

            : QVariant();

}

/*!

    Returns a list of keys there is meta-data available for.

*/

{

    Q_D(const QMediaObject);

    return d->metaDataControl

            ? d->metaDataControl->availableMetaData()

}

/*!

    \fn QMediaObject::metaDataChanged()

    Signals that a media object's meta-data has changed.

*/

/*!

    Returns the value associated with a meta-data \a key.

    The naming and type of extended meta-data is not standardized, so the values and meaning

    of keys may vary between backends.

*/

QVariant QMediaObject::extendedMetaData(const QString &key) const

{

    Q_D(const QMediaObject);

    return d->metaDataControl

            ? d->metaDataControl->extendedMetaData(key)

            : QVariant();

}

/*!

    Returns a list of keys there is extended meta-data available for.

*/

QStringList QMediaObject::availableExtendedMetaData() const

{

    Q_D(const QMediaObject);

    return d->metaDataControl

            ? d->metaDataControl->availableExtendedMetaData()

            : QStringList();

}

void QMediaObject::setupMetaData()

{

    Q_D(QMediaObject);

    if (d->service != 0) {

        if (d->metaDataControl) {

            connect(d->metaDataControl, SIGNAL(metaDataChanged()), SIGNAL(metaDataChanged()));

            connect(d->metaDataControl,

                    SIGNAL(metaDataAvailableChanged(bool)),

                    SIGNAL(metaDataAvailableChanged(bool)));

        }

    }

}

/*!

    \fn QMediaObject::availabilityChanged(bool available)

    Signal emitted when the availability state has changed to \a available

*/

#include "moc_qmediaobject.cpp"

QT_END_NAMESPACE