Added QMediaRecorder::status property

QMediaRecorder::state property represents the user request and
changed synchronously during record(), pause() or stop() calls.

Recorder status is changed asynchronously
and represents the actual status of media recorder.

This also makes API more consistent with QMediaPlayer and QCamera.

Change-Id: I80b4aaa70bb88e555c492908da8c29d0fc5ed5ea
Reviewed-by: Ling Hu <ling.hu@nokia.com>

12 files changed, 315 insertions, 28 deletions

diff --git a/src/imports/multimedia/qdeclarativecamerarecorder.cpp b/src/imports/multimedia/qdeclarativecamerarecorder.cpp
index 294a499db..ce83598cf 100644
--- a/src/imports/multimedia/qdeclarativecamerarecorder.cpp
+++ b/src/imports/multimedia/qdeclarativecamerarecorder.cpp
@@ -81,6 +81,8 @@ QDeclarativeCameraRecorder::QDeclarativeCameraRecorder(QCamera *camera, QObject
     m_recorder = new QMediaRecorder(camera, this);
     connect(m_recorder, SIGNAL(stateChanged(QMediaRecorder::State)),
             SLOT(updateRecorderState(QMediaRecorder::State)));
+    connect(m_recorder, SIGNAL(statusChanged(QMediaRecorder::Status)),
+            SIGNAL(recorderStatusChanged()));
     connect(m_recorder, SIGNAL(error(QMediaRecorder::Error)),
             SLOT(updateRecorderError(QMediaRecorder::Error)));
     connect(m_recorder, SIGNAL(mutedChanged(bool)), SIGNAL(mutedChanged(bool)));
@@ -383,6 +385,38 @@ QDeclarativeCameraRecorder::RecorderState QDeclarativeCameraRecorder::recorderSt
     return RecorderState(state);
 }
 
+
+/*!
+    \qmlproperty enumeration QtMultimedia5::CameraRecorder::recorderStatus
+
+    The actual current status of media recording.
+
+    \table
+    \header \li Value \li Description
+    \row \li UnavailableStatus
+         \li Recording is not supported by the camera.
+    \row \li UnloadedStatus
+         \li The recorder is available but not loaded.
+    \row \li LoadingStatus
+         \li The recorder is initializing.
+    \row \li LoadedStatus
+         \li The recorder is initialized and ready to record media.
+    \row \li StartingStatus
+         \li Recording is requested but not active yet.
+    \row \li RecordingStatus
+         \li Recording is active.
+    \row \li PausedStatus
+         \li Recording is paused.
+    \row \li FinalizingStatus
+         \li Recording is stopped with media being finalized.
+    \endtable
+*/
+
+QDeclarativeCameraRecorder::RecorderStatus QDeclarativeCameraRecorder::recorderStatus() const
+{
+    return RecorderStatus(m_recorder->status());
+}
+
 /*!
     \qmlmethod QtMultimedia5::CameraRecorder::record()
 
diff --git a/src/imports/multimedia/qdeclarativecamerarecorder_p.h b/src/imports/multimedia/qdeclarativecamerarecorder_p.h
index dbafbabbd..e896b7a41 100644
--- a/src/imports/multimedia/qdeclarativecamerarecorder_p.h
+++ b/src/imports/multimedia/qdeclarativecamerarecorder_p.h
@@ -67,9 +67,11 @@ class QDeclarativeCameraRecorder : public QObject
 {
     Q_OBJECT
     Q_ENUMS(RecorderState)
+    Q_ENUMS(RecorderStatus)
     Q_ENUMS(EncodingMode)
 
     Q_PROPERTY(RecorderState recorderState READ recorderState WRITE setRecorderState NOTIFY recorderStateChanged)
+    Q_PROPERTY(RecorderStatus recorderStatus READ recorderStatus NOTIFY recorderStatusChanged)
 
     Q_PROPERTY(QString videoCodec READ videoCodec WRITE setVideoCodec NOTIFY videoCodecChanged)
     Q_PROPERTY(QSize resolution READ captureResolution WRITE setCaptureResolution NOTIFY captureResolutionChanged)
@@ -98,6 +100,18 @@ public:
         RecordingState = QMediaRecorder::RecordingState
     };
 
+    enum RecorderStatus
+    {
+        UnavailableStatus = QMediaRecorder::UnavailableStatus,
+        UnloadedStatus = QMediaRecorder::UnloadedStatus,
+        LoadingStatus = QMediaRecorder::LoadingStatus,
+        LoadedStatus = QMediaRecorder::LoadedStatus,
+        StartingStatus = QMediaRecorder::StartingStatus,
+        RecordingStatus = QMediaRecorder::RecordingStatus,
+        PausedStatus = QMediaRecorder::PausedStatus,
+        FinalizingStatus = QMediaRecorder::FinalizingStatus
+    };
+
     enum EncodingMode
     {
         ConstantQualityEncoding = QtMultimedia::ConstantQualityEncoding,
@@ -108,6 +122,7 @@ public:
     ~QDeclarativeCameraRecorder();
 
     RecorderState recorderState() const;
+    RecorderStatus recorderStatus() const;
 
     QSize captureResolution();
 
@@ -159,6 +174,7 @@ public Q_SLOTS:
 
 Q_SIGNALS:
     void recorderStateChanged(QDeclarativeCameraRecorder::RecorderState state);
+    void recorderStatusChanged();
     void durationChanged(qint64 duration);
     void mutedChanged(bool muted);
     void outputLocationChanged(const QString &location);
diff --git a/src/multimedia/controls/qmediarecordercontrol.cpp b/src/multimedia/controls/qmediarecordercontrol.cpp
index e952c7dcb..3e56a5b89 100644
--- a/src/multimedia/controls/qmediarecordercontrol.cpp
+++ b/src/multimedia/controls/qmediarecordercontrol.cpp
@@ -117,12 +117,18 @@ QMediaRecorderControl::~QMediaRecorderControl()
 */
 
 /*!
-    \fn int QMediaRecorderControl::state() const
+    \fn QMediaRecorder::State QMediaRecorderControl::state() const
 
     Return the current recording state.
 */
 
 /*!
+    \fn QMediaRecorder::Status QMediaRecorderControl::status() const
+
+    Return the current recording status.
+*/
+
+/*!
     \fn qint64 QMediaRecorderControl::duration() const
 
     Return the current duration in milliseconds.
@@ -173,6 +179,13 @@ QMediaRecorderControl::~QMediaRecorderControl()
 */
 
 /*!
+    \fn void QMediaRecorderControl::statusChanged(QMediaRecorder::Status status)
+
+    Signals that the \a status of a media recorder has changed.
+*/
+
+
+/*!
     \fn void QMediaRecorderControl::durationChanged(qint64 duration)
 
     Signals that the \a duration of the recorded media has changed.
diff --git a/src/multimedia/controls/qmediarecordercontrol.h b/src/multimedia/controls/qmediarecordercontrol.h
index d8e7ea5b1..dccca6fe5 100644
--- a/src/multimedia/controls/qmediarecordercontrol.h
+++ b/src/multimedia/controls/qmediarecordercontrol.h
@@ -67,6 +67,7 @@ public:
     virtual bool setOutputLocation(const QUrl &location) = 0;
 
     virtual QMediaRecorder::State state() const = 0;
+    virtual QMediaRecorder::Status status() const = 0;
 
     virtual qint64 duration() const = 0;
 
@@ -76,6 +77,7 @@ public:
 
 Q_SIGNALS:
     void stateChanged(QMediaRecorder::State state);
+    void statusChanged(QMediaRecorder::Status status);
     void durationChanged(qint64 position);
     void mutedChanged(bool muted);
     void actualLocationChanged(const QUrl &location);
diff --git a/src/multimedia/recording/qmediarecorder.cpp b/src/multimedia/recording/qmediarecorder.cpp
index 78d518b7b..82f5133a0 100644
--- a/src/multimedia/recording/qmediarecorder.cpp
+++ b/src/multimedia/recording/qmediarecorder.cpp
@@ -88,6 +88,7 @@ public:
     MediaRecorderRegisterMetaTypes()
     {
         qRegisterMetaType<QMediaRecorder::State>("QMediaRecorder::State");
+        qRegisterMetaType<QMediaRecorder::State>("QMediaRecorder::Status");
         qRegisterMetaType<QMediaRecorder::Error>("QMediaRecorder::Error");
     }
 } _registerRecorderMetaTypes;
@@ -278,6 +279,9 @@ bool QMediaRecorder::setMediaObject(QMediaObject *object)
             disconnect(d->control, SIGNAL(stateChanged(QMediaRecorder::State)),
                        this, SLOT(_q_stateChanged(QMediaRecorder::State)));
 
+            disconnect(d->control, SIGNAL(statusChanged(QMediaRecorder::Status)),
+                       this, SIGNAL(statusChanged(QMediaRecorder::Status)));
+
             disconnect(d->control, SIGNAL(mutedChanged(bool)),
                        this, SIGNAL(mutedChanged(bool)));
 
@@ -378,6 +382,9 @@ bool QMediaRecorder::setMediaObject(QMediaObject *object)
                 connect(d->control, SIGNAL(stateChanged(QMediaRecorder::State)),
                         this, SLOT(_q_stateChanged(QMediaRecorder::State)));
 
+                connect(d->control, SIGNAL(statusChanged(QMediaRecorder::Status)),
+                        this, SIGNAL(statusChanged(QMediaRecorder::Status)));
+
                 connect(d->control, SIGNAL(mutedChanged(bool)),
                         this, SIGNAL(mutedChanged(bool)));
 
@@ -483,6 +490,17 @@ QMediaRecorder::State QMediaRecorder::state() const
 }
 
 /*!
+    Returns the current media recorder status.
+
+    \sa QMediaRecorder::Status
+*/
+
+QMediaRecorder::Status QMediaRecorder::status() const
+{
+    return d_func()->control ? QMediaRecorder::Status(d_func()->control->status()) : UnavailableStatus;
+}
+
+/*!
     Returns the current error state.
 
     \sa errorString()
@@ -801,9 +819,12 @@ void QMediaRecorder::setEncodingSettings(const QAudioEncoderSettings &audio,
 /*!
     Start recording.
 
-    This is an asynchronous call, with signal
-    stateChanged(QMediaRecorder::RecordingState) being emitted when recording
-    started, otherwise the error() signal is emitted.
+    While the recorder state is changed immediately to QMediaRecorder::RecordingState,
+    recording may start asynchronously, with statusChanged(QMediaRecorder::RecordingStatus)
+    signal emitted when recording starts.
+
+    If recording fails error() signal is emitted
+    with recorder state being reset back to QMediaRecorder::StoppedState.
 */
 
 void QMediaRecorder::record()
@@ -825,6 +846,11 @@ void QMediaRecorder::record()
 
 /*!
     Pause recording.
+
+    The recorder state is changed to QMediaRecorder::PausedState.
+
+    Depending on platform recording pause may be not supported,
+    in this case the recorder state stays unchanged.
 */
 
 void QMediaRecorder::pause()
@@ -836,6 +862,8 @@ void QMediaRecorder::pause()
 
 /*!
     Stop recording.
+
+    The recorder state is changed to QMediaRecorder::StoppedState.
 */
 
 void QMediaRecorder::stop()
@@ -849,11 +877,32 @@ void QMediaRecorder::stop()
     \enum QMediaRecorder::State
 
     \value StoppedState    The recorder is not active.
-    \value RecordingState  The recorder is currently active and producing data.
+    \value RecordingState  The recording is requested.
     \value PausedState     The recorder is paused.
 */
 
 /*!
+    \enum QMediaRecorder::Status
+
+    \value UnavailableStatus
+        The recorder is not available or not supported by connected media object.
+    \value UnloadedStatus
+        The recorder is avilable but not loaded.
+    \value LoadingStatus
+        The recorder is initializing.
+    \value LoadedStatus
+        The recorder is initialized and ready to record media.
+    \value StartingStatus
+        Recording is requested but not active yet.
+    \value RecordingStatus
+        Recording is active.
+    \value PausedStatus
+        Recording is paused.
+    \value FinalizingStatus
+        Recording is stopped with media being finalized.
+*/
+
+/*!
     \enum QMediaRecorder::Error
 
     \value NoError         No Errors.
@@ -862,6 +911,23 @@ void QMediaRecorder::stop()
 */
 
 /*!
+    \property QMediaRecorder::state
+    \brief The current state of the media recorder.
+
+    The state property represents the user request and is changed synchronously
+    during record(), pause() or stop() calls.
+    Recorder state may also change asynchronously when recording fails.
+*/
+
+/*!
+    \property QMediaRecorder::status
+    \brief The current status of the media recorder.
+
+    The status is changed asynchronously and represents the actual status
+    of media recorder.
+*/
+
+/*!
     \fn QMediaRecorder::stateChanged(State state)
 
     Signals that a media recorder's \a state has changed.
diff --git a/src/multimedia/recording/qmediarecorder.h b/src/multimedia/recording/qmediarecorder.h
index 84a6eca63..882334c80 100644
--- a/src/multimedia/recording/qmediarecorder.h
+++ b/src/multimedia/recording/qmediarecorder.h
@@ -73,7 +73,10 @@ class Q_MULTIMEDIA_EXPORT QMediaRecorder : public QObject, public QMediaBindable
     Q_OBJECT
     Q_INTERFACES(QMediaBindableInterface)
     Q_ENUMS(State)
+    Q_ENUMS(Status)
     Q_ENUMS(Error)
+    Q_PROPERTY(QMediaRecorder::State state READ state NOTIFY stateChanged)
+    Q_PROPERTY(QMediaRecorder::Status status READ status NOTIFY statusChanged)
     Q_PROPERTY(qint64 duration READ duration NOTIFY durationChanged)
     Q_PROPERTY(QUrl outputLocation READ outputLocation WRITE setOutputLocation)
     Q_PROPERTY(QUrl actualLocation READ actualLocation NOTIFY actualLocationChanged)
@@ -89,6 +92,17 @@ public:
         PausedState
     };
 
+    enum Status {
+        UnavailableStatus,
+        UnloadedStatus,
+        LoadingStatus,
+        LoadedStatus,
+        StartingStatus,
+        RecordingStatus,
+        PausedStatus,
+        FinalizingStatus
+    };
+
     enum Error
     {
         NoError,
@@ -110,6 +124,7 @@ public:
     QUrl actualLocation() const;
 
     State state() const;
+    Status status() const;
 
     Error error() const;
     QString errorString() const;
@@ -163,6 +178,7 @@ public Q_SLOTS:
 
 Q_SIGNALS:
     void stateChanged(QMediaRecorder::State state);
+    void statusChanged(QMediaRecorder::Status status);
     void durationChanged(qint64 duration);
     void mutedChanged(bool muted);
     void actualLocationChanged(const QUrl &location);
@@ -198,9 +214,11 @@ private:
 QT_END_NAMESPACE
 
 Q_DECLARE_METATYPE(QMediaRecorder::State)
+Q_DECLARE_METATYPE(QMediaRecorder::Status)
 Q_DECLARE_METATYPE(QMediaRecorder::Error)
 
 Q_MEDIA_ENUM_DEBUG(QMediaRecorder, State)
+Q_MEDIA_ENUM_DEBUG(QMediaRecorder, Status)
 Q_MEDIA_ENUM_DEBUG(QMediaRecorder, Error)
 
 QT_END_HEADER
diff --git a/src/plugins/audiocapture/audiomediarecordercontrol.cpp b/src/plugins/audiocapture/audiomediarecordercontrol.cpp
index e1fb14d35..e17157c6a 100644
--- a/src/plugins/audiocapture/audiomediarecordercontrol.cpp
+++ b/src/plugins/audiocapture/audiomediarecordercontrol.cpp
@@ -46,11 +46,13 @@
 
 AudioMediaRecorderControl::AudioMediaRecorderControl(QObject *parent)
     :QMediaRecorderControl(parent)
+    , m_state(QMediaRecorder::StoppedState)
+    , m_prevStatus(QMediaRecorder::UnloadedStatus)
 {
     m_session = qobject_cast<AudioCaptureSession*>(parent);
     connect(m_session,SIGNAL(positionChanged(qint64)),this,SIGNAL(durationChanged(qint64)));
-    connect(m_session,SIGNAL(stateChanged(QMediaRecorder::State)),this,SIGNAL(stateChanged(QMediaRecorder::State)));
-    connect(m_session,SIGNAL(error(int,QString)),this,SIGNAL(error(int,QString)));
+    connect(m_session,SIGNAL(stateChanged(QMediaRecorder::State)), this,SLOT(updateStatus()));
+    connect(m_session,SIGNAL(error(int,QString)),this,SLOT(handleSessionError(int,QString)));
 }
 
 AudioMediaRecorderControl::~AudioMediaRecorderControl()
@@ -72,6 +74,20 @@ QMediaRecorder::State AudioMediaRecorderControl::state() const
     return (QMediaRecorder::State)m_session->state();
 }
 
+QMediaRecorder::Status AudioMediaRecorderControl::status() const
+{
+    static QMediaRecorder::Status statusTable[3][3] = {
+        //Stopped recorder state:
+        { QMediaRecorder::LoadedStatus, QMediaRecorder::FinalizingStatus, QMediaRecorder::FinalizingStatus },
+        //Recording recorder state:
+        { QMediaRecorder::StartingStatus, QMediaRecorder::RecordingStatus, QMediaRecorder::PausedStatus },
+        //Paused recorder state:
+        { QMediaRecorder::StartingStatus, QMediaRecorder::RecordingStatus, QMediaRecorder::PausedStatus }
+    };
+
+    return statusTable[m_state][m_session->state()];
+}
+
 qint64 AudioMediaRecorderControl::duration() const
 {
     return m_session->position();
@@ -79,17 +95,29 @@ qint64 AudioMediaRecorderControl::duration() const
 
 void AudioMediaRecorderControl::record()
 {
-    m_session->record();
+    if (m_state != QMediaRecorder::RecordingState) {
+        m_state = QMediaRecorder::RecordingState;
+        m_session->record();
+        updateStatus();
+    }
 }
 
 void AudioMediaRecorderControl::pause()
 {
-    m_session->stop();
+    if (m_state != QMediaRecorder::PausedState) {
+        m_state = QMediaRecorder::PausedState;
+        m_session->pause();
+        updateStatus();
+    }
 }
 
 void AudioMediaRecorderControl::stop()
 {
-    m_session->stop();
+    if (m_state != QMediaRecorder::StoppedState) {
+        m_state = QMediaRecorder::StoppedState;
+        m_session->pause();
+        updateStatus();
+    }
 }
 
 bool AudioMediaRecorderControl::isMuted() const
@@ -100,3 +128,18 @@ bool AudioMediaRecorderControl::isMuted() const
 void AudioMediaRecorderControl::setMuted(bool)
 {
 }
+
+void AudioMediaRecorderControl::updateStatus()
+{
+    QMediaRecorder::Status newStatus = status();
+    if (m_prevStatus != newStatus) {
+        m_prevStatus = newStatus;
+        emit statusChanged(m_prevStatus);
+    }
+}
+
+void AudioMediaRecorderControl::handleSessionError(int code, const QString &description)
+{
+    emit error(code, description);
+    stop();
+}
diff --git a/src/plugins/audiocapture/audiomediarecordercontrol.h b/src/plugins/audiocapture/audiomediarecordercontrol.h
index 10e20d793..edd54ec83 100644
--- a/src/plugins/audiocapture/audiomediarecordercontrol.h
+++ b/src/plugins/audiocapture/audiomediarecordercontrol.h
@@ -62,6 +62,7 @@ public:
     bool setOutputLocation(const QUrl &sink);
 
     QMediaRecorder::State state() const;
+    QMediaRecorder::Status status() const;
 
     qint64 duration() const;
 
@@ -75,8 +76,14 @@ public slots:
     void stop();
     void setMuted(bool);
 
+private slots:
+    void updateStatus();
+    void handleSessionError(int code, const QString &description);
+
 private:
     AudioCaptureSession* m_session;
+    QMediaRecorder::State m_state;
+    QMediaRecorder::Status m_prevStatus;
 };
 
 #endif
diff --git a/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.cpp b/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.cpp
index c9e8d454c..700517a1c 100644
--- a/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.cpp
+++ b/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.cpp
@@ -46,10 +46,13 @@
 #include <QtCore/QDebug>
 
 QGstreamerRecorderControl::QGstreamerRecorderControl(QGstreamerCaptureSession *session)
-    :QMediaRecorderControl(session), m_session(session), m_state(QMediaRecorder::StoppedState)
+    :QMediaRecorderControl(session),
+      m_session(session),
+      m_state(QMediaRecorder::StoppedState),
+      m_status(QMediaRecorder::UnloadedStatus)
 {
-    connect(m_session, SIGNAL(stateChanged(QGstreamerCaptureSession::State)), SLOT(updateState()));
-    connect(m_session, SIGNAL(error(int,QString)), SIGNAL(error(int,QString)));
+    connect(m_session, SIGNAL(stateChanged(QGstreamerCaptureSession::State)), SLOT(updateStatus()));
+    connect(m_session, SIGNAL(error(int,QString)), SLOT(handleSessionError(int,QString)));
     connect(m_session, SIGNAL(durationChanged(qint64)), SIGNAL(durationChanged(qint64)));
     connect(m_session, SIGNAL(mutedChanged(bool)), SIGNAL(mutedChanged(bool)));
     m_hasPreviewState = m_session->captureMode() != QGstreamerCaptureSession::Audio;
@@ -74,29 +77,50 @@ bool QGstreamerRecorderControl::setOutputLocation(const QUrl &sink)
 
 QMediaRecorder::State QGstreamerRecorderControl::state() const
 {
+    return m_state;
+}
+
+QMediaRecorder::Status QGstreamerRecorderControl::status() const
+{
+    static QMediaRecorder::Status statusTable[3][3] = {
+        //Stopped recorder state:
+        { QMediaRecorder::LoadedStatus, QMediaRecorder::FinalizingStatus, QMediaRecorder::FinalizingStatus },
+        //Recording recorder state:
+        { QMediaRecorder::StartingStatus, QMediaRecorder::RecordingStatus, QMediaRecorder::PausedStatus },
+        //Paused recorder state:
+        { QMediaRecorder::StartingStatus, QMediaRecorder::RecordingStatus, QMediaRecorder::PausedStatus }
+    };
+
+    QMediaRecorder::State sessionState = QMediaRecorder::StoppedState;
+
     switch ( m_session->state() ) {
         case QGstreamerCaptureSession::RecordingState:
-            return QMediaRecorder::RecordingState;
+            sessionState = QMediaRecorder::RecordingState;
         case QGstreamerCaptureSession::PausedState:
-            return QMediaRecorder::PausedState;
+            sessionState = QMediaRecorder::PausedState;
         case QGstreamerCaptureSession::PreviewState:
         case QGstreamerCaptureSession::StoppedState:
-            return QMediaRecorder::StoppedState;
+            sessionState = QMediaRecorder::StoppedState;
     }
 
-    return QMediaRecorder::StoppedState;
-
+    return statusTable[m_state][sessionState];
 }
 
-void QGstreamerRecorderControl::updateState()
+void QGstreamerRecorderControl::updateStatus()
 {
-    QMediaRecorder::State newState = state();
-    if (m_state != newState) {
-        m_state = newState;
-        emit stateChanged(m_state);
+    QMediaRecorder::Status newStatus = status();
+    if (m_status != newStatus) {
+        m_status = newStatus;
+        emit statusChanged(m_status);
     }
 }
 
+void QGstreamerRecorderControl::handleSessionError(int code, const QString &description)
+{
+    emit error(code, description);
+    stop();
+}
+
 qint64 QGstreamerRecorderControl::duration() const
 {
     return m_session->duration();
@@ -104,6 +128,11 @@ qint64 QGstreamerRecorderControl::duration() const
 
 void QGstreamerRecorderControl::record()
 {
+    if (m_state == QMediaRecorder::RecordingState)
+        return;
+
+    m_state = QMediaRecorder::RecordingState;
+
     if (m_outputLocation.isEmpty()) {
         QString container = m_session->mediaContainerControl()->containerExtension();
         if (container.isEmpty())
@@ -119,25 +148,44 @@ void QGstreamerRecorderControl::record()
         emit error(QMediaRecorder::ResourceError, tr("Service has not been started"));
 
     m_session->dumpGraph("after-record");
+
+    emit stateChanged(m_state);
+    updateStatus();
 }
 
 void QGstreamerRecorderControl::pause()
 {
+    if (m_state == QMediaRecorder::PausedState)
+        return;
+
+    m_state = QMediaRecorder::PausedState;
+
     m_session->dumpGraph("before-pause");
     if (!m_hasPreviewState || m_session->state() != QGstreamerCaptureSession::StoppedState) {
         m_session->setState(QGstreamerCaptureSession::PausedState);
     } else
         emit error(QMediaRecorder::ResourceError, tr("Service has not been started"));
+
+    emit stateChanged(m_state);
+    updateStatus();
 }
 
 void QGstreamerRecorderControl::stop()
 {
+    if (m_state == QMediaRecorder::StoppedState)
+        return;
+
+    m_state = QMediaRecorder::StoppedState;
+
     if (!m_hasPreviewState) {
         m_session->setState(QGstreamerCaptureSession::StoppedState);
     } else {
         if (m_session->state() != QGstreamerCaptureSession::StoppedState)
             m_session->setState(QGstreamerCaptureSession::PreviewState);
     }
+
+    emit stateChanged(m_state);
+    updateStatus();
 }
 
 void QGstreamerRecorderControl::applySettings()
diff --git a/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.h b/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.h
index 799a9a28e..c765c55fd 100644
--- a/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.h
+++ b/src/plugins/gstreamer/mediacapture/qgstreamerrecordercontrol.h
@@ -62,6 +62,7 @@ public:
     bool setOutputLocation(const QUrl &sink);
 
     QMediaRecorder::State state() const;
+    QMediaRecorder::Status status() const;
 
     qint64 duration() const;
 
@@ -76,7 +77,8 @@ public slots:
     void setMuted(bool);
 
 private slots:
-    void updateState();
+    void updateStatus();
+    void handleSessionError(int code, const QString &description);
 
 private:
     QDir defaultDir() const;
@@ -85,6 +87,7 @@ private:
     QUrl m_outputLocation;
     QGstreamerCaptureSession *m_session;
     QMediaRecorder::State m_state;
+    QMediaRecorder::Status m_status;
     bool m_hasPreviewState;
 };
 
diff --git a/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp b/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
index b26164d0c..aad7b873d 100644
--- a/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
+++ b/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
@@ -307,26 +307,50 @@ void tst_QMediaRecorder::testSink()
 void tst_QMediaRecorder::testRecord()
 {
     QSignalSpy stateSignal(capture,SIGNAL(stateChanged(QMediaRecorder::State)));
+    QSignalSpy statusSignal(capture,SIGNAL(statusChanged(QMediaRecorder::Status)));
     QSignalSpy progressSignal(capture, SIGNAL(durationChanged(qint64)));
     capture->record();
     QCOMPARE(capture->state(), QMediaRecorder::RecordingState);
     QCOMPARE(capture->error(), QMediaRecorder::NoError);
     QCOMPARE(capture->errorString(), QString());
-    QTestEventLoop::instance().enterLoop(1);
+
     QCOMPARE(stateSignal.count(), 1);
     QCOMPARE(stateSignal.last()[0].value<QMediaRecorder::State>(), QMediaRecorder::RecordingState);
+
+    QTestEventLoop::instance().enterLoop(1);
+
+    QCOMPARE(capture->status(), QMediaRecorder::RecordingStatus);
+    QVERIFY(!statusSignal.isEmpty());
+    QCOMPARE(statusSignal.last()[0].value<QMediaRecorder::Status>(), QMediaRecorder::RecordingStatus);
+    statusSignal.clear();
+
     QVERIFY(progressSignal.count() > 0);
+
     capture->pause();
+
     QCOMPARE(capture->state(), QMediaRecorder::PausedState);
-    QTestEventLoop::instance().enterLoop(1);
+
     QCOMPARE(stateSignal.count(), 2);
+
+    QTestEventLoop::instance().enterLoop(1);
+    QCOMPARE(capture->status(), QMediaRecorder::PausedStatus);
+    QVERIFY(!statusSignal.isEmpty());
+    QCOMPARE(statusSignal.last()[0].value<QMediaRecorder::Status>(), QMediaRecorder::PausedStatus);
+    statusSignal.clear();
+
     capture->stop();
+
     QCOMPARE(capture->state(), QMediaRecorder::StoppedState);
-    QTestEventLoop::instance().enterLoop(1);
     QCOMPARE(stateSignal.count(), 3);
+
+    QTestEventLoop::instance().enterLoop(1);
+    QCOMPARE(capture->status(), QMediaRecorder::LoadedStatus);
+    QVERIFY(!statusSignal.isEmpty());
+    QCOMPARE(statusSignal.last()[0].value<QMediaRecorder::Status>(), QMediaRecorder::LoadedStatus);
+    statusSignal.clear();
+
     mock->stop();
     QCOMPARE(stateSignal.count(), 3);
-
 }
 
 void tst_QMediaRecorder::testMute()
diff --git a/tests/auto/unit/qmultimedia_common/mockmediarecordercontrol.h b/tests/auto/unit/qmultimedia_common/mockmediarecordercontrol.h
index 3f622fe61..68723a714 100644
--- a/tests/auto/unit/qmultimedia_common/mockmediarecordercontrol.h
+++ b/tests/auto/unit/qmultimedia_common/mockmediarecordercontrol.h
@@ -54,6 +54,7 @@ public:
     MockMediaRecorderControl(QObject *parent = 0):
         QMediaRecorderControl(parent),
         m_state(QMediaRecorder::StoppedState),
+        m_status(QMediaRecorder::LoadedStatus),
         m_position(0),
         m_muted(false),
         m_settingAppliedCount(0)
@@ -76,6 +77,11 @@ public:
         return m_state;
     }
 
+    QMediaRecorder::Status status() const
+    {
+        return m_status;
+    }
+
     qint64 duration() const
     {
         return m_position;
@@ -97,8 +103,10 @@ public slots:
     void record()
     {
         m_state = QMediaRecorder::RecordingState;
+        m_status = QMediaRecorder::RecordingStatus;
         m_position=1;
         emit stateChanged(m_state);
+        emit statusChanged(m_status);
         emit durationChanged(m_position);
 
         QUrl actualLocation = m_sink.isEmpty() ? QUrl::fromLocalFile("default_name.mp4") : m_sink;
@@ -108,14 +116,18 @@ public slots:
     void pause()
     {
         m_state = QMediaRecorder::PausedState;
+        m_status = QMediaRecorder::PausedStatus;
         emit stateChanged(m_state);
+        emit statusChanged(m_status);
     }
 
     void stop()
     {
         m_position=0;
         m_state = QMediaRecorder::StoppedState;
+        m_status = QMediaRecorder::LoadedStatus;
         emit stateChanged(m_state);
+        emit statusChanged(m_status);
     }
 
     void setMuted(bool muted)
@@ -127,6 +139,7 @@ public slots:
 public:
     QUrl       m_sink;
     QMediaRecorder::State m_state;
+    QMediaRecorder::Status m_status;
     qint64     m_position;
     bool m_muted;
     int m_settingAppliedCount;