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

**

** 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 "qmediarecorder.h"

#include <QtCore/qdebug.h>

#include <QtCore/qurl.h>

#include <QtCore/qstringlist.h>

#include <QtCore/qmetaobject.h>

QT_BEGIN_NAMESPACE

/*!

    \class QMediaRecorder

    \ingroup multimedia

    \preliminary

    \brief The QMediaRecorder class is used for the recording of media content.

    \code

    // Audio only recording

    audioSource = new QAudioCaptureSource;

    recorder = new QMediaRecorder(audioSource);

    QAudioEncoderSettings audioSettings;

    audioSettings.setCodec("audio/vorbis");

    recorder->setEncodingSettings(audioSettings);

    recorder->setOutputLocation(QUrl::fromLocalFile(fileName));

    recorder->record();

    \endcode

    \sa

*/

namespace

{

class MediaRecorderRegisterMetaTypes

{

public:

    MediaRecorderRegisterMetaTypes()

    {

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

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

    }

} _registerRecorderMetaTypes;

}

{

    Q_DECLARE_NON_CONST_PUBLIC(QMediaRecorder)

public:

    QMediaRecorderPrivate();

    QMediaRecorderControl *control;

    QMediaContainerControl *formatControl;

    QAudioEncoderControl *audioControl;

    QVideoEncoderControl *videoControl;

    QMediaRecorder::State state;

    QMediaRecorder::Error error;

    QString errorString;

    void _q_stateChanged(QMediaRecorder::State state);

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

};

QMediaRecorderPrivate::QMediaRecorderPrivate():

     control(0),

     formatControl(0),

     audioControl(0),

     videoControl(0),

     state(QMediaRecorder::StoppedState),

     error(QMediaRecorder::NoError)

{

}

#define ENUM_NAME(c,e,v) (c::staticMetaObject.enumerator(c::staticMetaObject.indexOfEnumerator(e)).valueToKey((v)))

void QMediaRecorderPrivate::_q_stateChanged(QMediaRecorder::State ps)

{

    Q_Q(QMediaRecorder);

    if (ps == QMediaRecorder::RecordingState)

        q->addPropertyWatch("duration");

    else

        q->removePropertyWatch("duration");

//    qDebug() << "Recorder state changed:" << ENUM_NAME(QMediaRecorder,"State",ps);

    if (state != ps) {

        emit q->stateChanged(ps);

    }

    state = ps;

}

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

{

    Q_Q(QMediaRecorder);

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

    this->errorString = errorString;

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

}

/*!

    Constructs a media recorder which records the media produced by \a mediaObject.

    The \a parent is passed to QMediaObject.

*/

QMediaRecorder::QMediaRecorder(QMediaObject *mediaObject, QObject *parent):

{

    Q_D(QMediaRecorder);

}

/*!

    Destroys a media recorder object.

*/

QMediaRecorder::~QMediaRecorder()

{

}

/*!

    \property QMediaRecorder::outputLocation

    \brief the destination location of media content.

*/

/*!

    Returns true if media recorder service ready to use.

*/

bool QMediaRecorder::isAvailable() const

{

    if (d_func()->control != NULL)

        return true;

    else

        return false;

}

/*!

    Returns the availability error code.

*/

{

    if (d_func()->control != NULL)

    else

}

QUrl QMediaRecorder::outputLocation() const

{

    return d_func()->control ? d_func()->control->outputLocation() : QUrl();

}

bool QMediaRecorder::setOutputLocation(const QUrl &location)

{

    Q_D(QMediaRecorder);

    return d->control ? d->control->setOutputLocation(location) : false;

}

/*!

    Returns the current media recorder state.

    \sa QMediaRecorder::State

*/

QMediaRecorder::State QMediaRecorder::state() const

{

    return d_func()->control ? QMediaRecorder::State(d_func()->control->state()) : StoppedState;

}

/*!

    Returns the current error state.

    \sa errorString()

*/

QMediaRecorder::Error QMediaRecorder::error() const

{

    return d_func()->error;

}

/*!

    Returns a string describing the current error state.

    \sa error()

*/

QString QMediaRecorder::errorString() const

{

    return d_func()->errorString;

}

/*!

    \property QMediaRecorder::duration

    \brief the recorded media duration in milliseconds.

*/

qint64 QMediaRecorder::duration() const

{

    return d_func()->control ? d_func()->control->duration() : 0;

}

/*!

    Returns a list of MIME types of supported container formats.

*/

QStringList QMediaRecorder::supportedContainers() const

{

    return d_func()->formatControl ?

           d_func()->formatControl->supportedContainers() : QStringList();

}

/*!

    Returns a description of a container format \a mimeType.

*/

QString QMediaRecorder::containerDescription(const QString &mimeType) const

{

    return d_func()->formatControl ?

           d_func()->formatControl->containerDescription(mimeType) : QString();

}

/*!

    Returns the MIME type of the selected container format.

*/

QString QMediaRecorder::containerMimeType() const

{

    return d_func()->formatControl ?

           d_func()->formatControl->containerMimeType() : QString();

}

/*!

    Returns a list of supported audio codecs.

*/

QStringList QMediaRecorder::supportedAudioCodecs() const

{

    return d_func()->audioControl ?

           d_func()->audioControl->supportedAudioCodecs() : QStringList();

}

/*!

    Returns a description of an audio \a codec.

*/

QString QMediaRecorder::audioCodecDescription(const QString &codec) const

{

    return d_func()->audioControl ?

           d_func()->audioControl->codecDescription(codec) : QString();

}

/*!

    Returns a list of supported audio sample rates.

*/

QList<int> QMediaRecorder::supportedAudioSampleRates(const QAudioEncoderSettings &settings, bool *continuous) const

{

    if (continuous)

        *continuous = false;

    return d_func()->audioControl ?

           d_func()->audioControl->supportedSampleRates(settings, continuous) : QList<int>();

}

/*!

    Returns a list of resolutions video can be encoded at.

    If the encoder supports arbitrary resolutions within the supported range,

    *\a continuous is set to true, otherwise *\a continuous is set to false.

    \sa QVideoEncoderSettings::resolution()

*/

QList<QSize> QMediaRecorder::supportedResolutions(const QVideoEncoderSettings &settings, bool *continuous) const

{

    if (continuous)

        *continuous = false;