Rename availabilityError to availability.

It's perhaps clearer in the usual case.

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

src/imports/multimedia/plugins.qmltypes

@@ -1434,9 +1434,9 @@ Module {
             Parameter { name: "available"; type: "bool" }
         }
         Signal {
-            name: "availabilityErrorChanged"
+            name: "availabilityChanged"
             type: "void"
-            Parameter { name: "error"; type: "QtMultimedia::AvailabilityError" }
+            Parameter { name: "error"; type: "QtMultimedia::AvailabilityStatus" }
         }
     }
     Component {

src/imports/multimedia/qdeclarativeaudio.cpp

@@ -99,7 +99,7 @@ void QDeclarativeAudio::_q_error(QMediaPlayer::Error errorCode)
     emit errorChanged();
 }
 
-void QDeclarativeAudio::_q_availabilityChanged(QtMultimedia::AvailabilityError)
+void QDeclarativeAudio::_q_availabilityChanged(QtMultimedia::AvailabilityStatus)
 {
     emit availabilityChanged(availability());
 }
@@ -153,7 +153,7 @@ QDeclarativeAudio::Availability QDeclarativeAudio::availability() const
 {
     if (!m_player)
         return Unavailable;
-    return Availability(m_player->availabilityError());
+    return Availability(m_player->availability());
 }
 
 QUrl QDeclarativeAudio::source() const
@@ -658,10 +658,10 @@ void QDeclarativeAudio::classBegin()
     connect(m_player, SIGNAL(videoAvailableChanged(bool)),
             this, SIGNAL(hasVideoChanged()));
 
-    m_error = m_player->availabilityError() == QtMultimedia::ServiceMissingError ? QMediaPlayer::ServiceMissingError : QMediaPlayer::NoError;
+    m_error = m_player->availability() == QtMultimedia::ServiceMissing ? QMediaPlayer::ServiceMissingError : QMediaPlayer::NoError;
 
-    connect(m_player, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)),
-                     this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
+    connect(m_player, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)),
+                     this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityStatus)));
 
     m_metaData.reset(new QDeclarativeMediaMetaData(m_player));
 

src/imports/multimedia/qdeclarativeaudio_p.h

@@ -138,9 +138,9 @@ public:
     };
 
     enum Availability {
-        Available = QtMultimedia::NoError,
-        Busy = QtMultimedia::BusyError,
-        Unavailable = QtMultimedia::ServiceMissingError,
+        Available = QtMultimedia::Available,
+        Busy = QtMultimedia::Busy,
+        Unavailable = QtMultimedia::ServiceMissing,
         ResourceMissing = QtMultimedia::ResourceError
     };
 
@@ -237,7 +237,7 @@ Q_SIGNALS:
 
 private Q_SLOTS:
     void _q_error(QMediaPlayer::Error);
-    void _q_availabilityChanged(QtMultimedia::AvailabilityError);
+    void _q_availabilityChanged(QtMultimedia::AvailabilityStatus);
     void _q_statusChanged();
 
 private:

src/imports/multimedia/qdeclarativecamera.cpp

@@ -68,9 +68,9 @@ void QDeclarativeCamera::_q_updateState(QCamera::State state)
     emit cameraStateChanged(QDeclarativeCamera::State(state));
 }
 
-void QDeclarativeCamera::_q_availabilityChanged(QtMultimedia::AvailabilityError error)
+void QDeclarativeCamera::_q_availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 {
-    emit availabilityChanged(Availability(error));
+    emit availabilityChanged(Availability(availability));
 }
 
 /*!
@@ -188,9 +188,7 @@ QDeclarativeCamera::QDeclarativeCamera(QObject *parent) :
     connect(m_camera, SIGNAL(stateChanged(QCamera::State)), this, SLOT(_q_updateState(QCamera::State)));
     connect(m_camera, SIGNAL(statusChanged(QCamera::Status)), this, SIGNAL(cameraStatusChanged()));
     connect(m_camera, SIGNAL(error(QCamera::Error)), this, SLOT(_q_error(QCamera::Error)));
-
-    // Note we map availabilityError->availability
-    connect(m_camera, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
+    connect(m_camera, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityStatus)));
 
     connect(m_camera->focus(), SIGNAL(opticalZoomChanged(qreal)), this, SIGNAL(opticalZoomChanged(qreal)));
     connect(m_camera->focus(), SIGNAL(digitalZoomChanged(qreal)), this, SIGNAL(digitalZoomChanged(qreal)));
@@ -260,7 +258,7 @@ QString QDeclarativeCamera::errorString() const
  */
 QDeclarativeCamera::Availability QDeclarativeCamera::availability() const
 {
-    return Availability(m_camera->availabilityError());
+    return Availability(m_camera->availability());
 }
 
 

src/imports/multimedia/qdeclarativecamera_p.h

@@ -216,9 +216,9 @@ public:
     };
 
     enum Availability {
-        Available = QtMultimedia::NoError,
-        Busy = QtMultimedia::BusyError,
-        Unavailable = QtMultimedia::ServiceMissingError,
+        Available = QtMultimedia::Available,
+        Busy = QtMultimedia::Busy,
+        Unavailable = QtMultimedia::ServiceMissing,
         ResourceMissing = QtMultimedia::ResourceError
     };
 
@@ -287,7 +287,7 @@ Q_SIGNALS:
 private Q_SLOTS:
     void _q_updateState(QCamera::State);
     void _q_error(QCamera::Error);
-    void _q_availabilityChanged(QtMultimedia::AvailabilityError);
+    void _q_availabilityChanged(QtMultimedia::AvailabilityStatus);
 
 protected:
     void classBegin();

src/imports/multimedia/qdeclarativeradio.cpp

@@ -115,9 +115,7 @@ QDeclarativeRadio::QDeclarativeRadio(QObject *parent) :
     connect(m_radioTuner, SIGNAL(mutedChanged(bool)), this, SIGNAL(mutedChanged(bool)));
     connect(m_radioTuner, SIGNAL(stationFound(int, QString)), this, SIGNAL(stationFound(int, QString)));
     connect(m_radioTuner, SIGNAL(antennaConnectedChanged(bool)), this, SIGNAL(antennaConnectedChanged(bool)));
-
-    // Note we map availabilityError->availability
-    connect(m_radioTuner, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
+    connect(m_radioTuner, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityStatus)));
 
     connect(m_radioTuner, SIGNAL(error(QRadioTuner::Error)), this, SLOT(_q_error(QRadioTuner::Error)));
 }
@@ -339,7 +337,7 @@ bool QDeclarativeRadio::isAntennaConnected() const
  */
 QDeclarativeRadio::Availability QDeclarativeRadio::availability() const
 {
-    return Availability(m_radioTuner->availabilityError());
+    return Availability(m_radioTuner->availability());
 }
 
 void QDeclarativeRadio::setBand(QDeclarativeRadio::Band band)
@@ -528,9 +526,9 @@ void QDeclarativeRadio::_q_error(QRadioTuner::Error errorCode)
     emit errorChanged();
 }
 
-void QDeclarativeRadio::_q_availabilityChanged(QtMultimedia::AvailabilityError error)
+void QDeclarativeRadio::_q_availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 {
-    emit availabilityChanged(Availability(error));
+    emit availabilityChanged(Availability(availability));
 }
 
 /*!

src/imports/multimedia/qdeclarativeradio_p.h

@@ -120,9 +120,9 @@ public:
     };
 
     enum Availability {
-        Available = QtMultimedia::NoError,
-        Busy = QtMultimedia::BusyError,
-        Unavailable = QtMultimedia::ServiceMissingError,
+        Available = QtMultimedia::Available,
+        Busy = QtMultimedia::Busy,
+        Unavailable = QtMultimedia::ServiceMissing,
         ResourceMissing = QtMultimedia::ResourceError
     };
 
@@ -189,7 +189,7 @@ private Q_SLOTS:
     void _q_stateChanged(QRadioTuner::State state);
     void _q_bandChanged(QRadioTuner::Band band);
     void _q_error(QRadioTuner::Error errorCode);
-    void _q_availabilityChanged(QtMultimedia::AvailabilityError);
+    void _q_availabilityChanged(QtMultimedia::AvailabilityStatus);
 
 private:
     Q_DISABLE_COPY(QDeclarativeRadio)

src/imports/multimedia/qdeclarativeradiodata.cpp

@@ -141,7 +141,7 @@ QDeclarativeRadioData::~QDeclarativeRadioData()
  */
 QDeclarativeRadioData::Availability QDeclarativeRadioData::availability() const
 {
-    return Availability(m_radioData->availabilityError());
+    return Availability(m_radioData->availability());
 }
 
 
@@ -281,9 +281,9 @@ void QDeclarativeRadioData::_q_error(QRadioData::Error errorCode)
     emit errorChanged();
 }
 
-void QDeclarativeRadioData::_q_availabilityChanged(QtMultimedia::AvailabilityError error)
+void QDeclarativeRadioData::_q_availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 {
-    emit availabilityChanged(Availability(error));
+    emit availabilityChanged(Availability(availability));
 }
 
 void QDeclarativeRadioData::connectSignals()
@@ -297,10 +297,8 @@ void QDeclarativeRadioData::connectSignals()
     connect(m_radioData, SIGNAL(radioTextChanged(QString)), this, SIGNAL(radioTextChanged(QString)));
     connect(m_radioData, SIGNAL(alternativeFrequenciesEnabledChanged(bool)), this,
                          SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
-
-    // Note we map availabilityError->availability
     // Since the radio data type depends on the service for the tuner, the availability is also dictated from the tuner
-    connect(m_radioTuner, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
+    connect(m_radioTuner, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityStatus)));
 
     connect(m_radioData, SIGNAL(error(QRadioData::Error)), this, SLOT(_q_error(QRadioData::Error)));
 }

src/imports/multimedia/qdeclarativeradiodata_p.h

@@ -137,9 +137,9 @@ public:
     };
 
     enum Availability {
-        Available = QtMultimedia::NoError,
-        Busy = QtMultimedia::BusyError,
-        Unavailable = QtMultimedia::ServiceMissingError,
+        Available = QtMultimedia::Available,
+        Busy = QtMultimedia::Busy,
+        Unavailable = QtMultimedia::ServiceMissing,
         ResourceMissing = QtMultimedia::ResourceError
     };
 
@@ -176,7 +176,7 @@ Q_SIGNALS:
 private Q_SLOTS:
     void _q_programTypeChanged(QRadioData::ProgramType programType);
     void _q_error(QRadioData::Error errorCode);
-    void _q_availabilityChanged(QtMultimedia::AvailabilityError);
+    void _q_availabilityChanged(QtMultimedia::AvailabilityStatus);
 
 private:
     void connectSignals();

src/multimedia/camera/qcamera.cpp

@@ -412,11 +412,11 @@ QCamera::~QCamera()
 /*!
     Returns the availability state of the camera service.
 */
-QtMultimedia::AvailabilityError QCamera::availabilityError() const
+QtMultimedia::AvailabilityStatus QCamera::availability() const
 {
     Q_D(const QCamera);
     if (d->control == NULL)
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 
     if (d->deviceControl && d->deviceControl->deviceCount() == 0)
         return QtMultimedia::ResourceError;
@@ -424,7 +424,7 @@ QtMultimedia::AvailabilityError QCamera::availabilityError() const
     if (d->error != QCamera::NoError)
         return QtMultimedia::ResourceError;
 
-    return QMediaObject::availabilityError();
+    return QMediaObject::availability();
 }
 
 

src/multimedia/camera/qcamera.h

@@ -152,7 +152,7 @@ public:
     static QList<QByteArray> availableDevices();
     static QString deviceDescription(const QByteArray &device);
 
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
     State state() const;
     Status status() const;

src/multimedia/camera/qcameraimagecapture.cpp

@@ -312,14 +312,14 @@ bool QCameraImageCapture::isAvailable() const
 }
 
 /*!
-    Returns the availability error code.
+    Returns the availability of this functionality.
 */
-QtMultimedia::AvailabilityError QCameraImageCapture::availabilityError() const
+QtMultimedia::AvailabilityStatus QCameraImageCapture::availability() const
 {
     if (d_func()->control != NULL)
-        return QtMultimedia::NoError;
+        return QtMultimedia::Available;
     else
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 }
 
 /*!

src/multimedia/camera/qcameraimagecapture.h

@@ -97,7 +97,7 @@ public:
     ~QCameraImageCapture();
 
     bool isAvailable() const;
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
     QMediaObject *mediaObject() const;
 

src/multimedia/controls/qmediaavailabilitycontrol.cpp

@@ -90,7 +90,7 @@ QMediaAvailabilityControl::~QMediaAvailabilityControl()
 
 
 /*!
-  \fn QtMultimedia::AvailabilityError QMediaAvailabilityControl::availability() const
+  \fn QtMultimedia::AvailabilityStatus QMediaAvailabilityControl::availability() const
 
   Returns the current availability of this instance of the media service.
   If the availability changes at run time (for example, some other media
@@ -100,7 +100,7 @@ QMediaAvailabilityControl::~QMediaAvailabilityControl()
 
 
 /*!
-    \fn void QMediaAvailabilityControl::availabilityChanged(QtMultimedia::AvailabilityError availability)
+    \fn void QMediaAvailabilityControl::availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 
     Signal emitted when the current \a availability value changed.
 */

src/multimedia/controls/qmediaavailabilitycontrol.h

@@ -62,10 +62,10 @@ class Q_MULTIMEDIA_EXPORT QMediaAvailabilityControl : public QMediaControl
 public:
     ~QMediaAvailabilityControl();
 
-    virtual QtMultimedia::AvailabilityError availability() const = 0;
+    virtual QtMultimedia::AvailabilityStatus availability() const = 0;
 
 signals:
-    void availabilityChanged(QtMultimedia::AvailabilityError availability);
+    void availabilityChanged(QtMultimedia::AvailabilityStatus availability);
 
 protected:
     QMediaAvailabilityControl(QObject* parent = 0);

src/multimedia/playback/qmediaplayer.cpp

@@ -84,7 +84,7 @@ QT_BEGIN_NAMESPACE
 
     \list
     \li Accessing the currently playing media's metadata (\l {QMediaObject::metaData()} and \l {QtMultimedia::MetaData}{predefined meta-data keys})
-    \li Checking to see if the media playback service is currently available (\l {QMediaObject::availabilityError()})
+    \li Checking to see if the media playback service is currently available (\l {QMediaObject::availability()})
     \endlist
 
     \sa QMediaObject, QMediaService, QVideoWidget, QMediaPlaylist
@@ -1013,14 +1013,14 @@ void QMediaPlayer::setVideoOutput(QAbstractVideoSurface *surface)
 }
 
 /*! \reimp */
-QtMultimedia::AvailabilityError QMediaPlayer::availabilityError() const
+QtMultimedia::AvailabilityStatus QMediaPlayer::availability() const
 {
     Q_D(const QMediaPlayer);
 
     if (!d->control)
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 
-    return QMediaObject::availabilityError();
+    return QMediaObject::availability();
 }
 
 

src/multimedia/playback/qmediaplayer.h

@@ -161,7 +161,7 @@ public:
 
     QNetworkConfiguration currentNetworkConfiguration() const;
 
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
 public Q_SLOTS:
     void play();

src/multimedia/qmediaobject.cpp

@@ -71,8 +71,8 @@ void QMediaObjectPrivate::_q_availabilityChanged()
     // Really this should not always emit, but
     // we can't really tell from here (isAvailable
     // may not have changed, or the mediaobject's overridden
-    // availabilityError() may not have changed).
-    q->availabilityErrorChanged(q->availabilityError());
+    // availability() may not have changed).
+    q->availabilityChanged(q->availability());
     q->availabilityChanged(q->isAvailable());
 }
 
@@ -113,18 +113,23 @@ QMediaObject::~QMediaObject()
 }
 
 /*!
-    Returns the service availability error state.
+    Returns the availability of the functionality offered by this object.
+
+    In some cases the functionality may not be available (for example, if
+    the current operating system or platform does not provide the required
+    functionality), or it may be temporarily unavailable (for example,
+    audio playback during a phone call or similar).
 */
 
-QtMultimedia::AvailabilityError QMediaObject::availabilityError() const
+QtMultimedia::AvailabilityStatus QMediaObject::availability() const
 {
     if (d_func()->service == 0)
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 
     if (d_func()->availabilityControl)
         return d_func()->availabilityControl->availability();
 
-    return QtMultimedia::NoError;
+    return QtMultimedia::Available;
 }
 
 /*!
@@ -133,7 +138,7 @@ QtMultimedia::AvailabilityError QMediaObject::availabilityError() const
 
 bool QMediaObject::isAvailable() const
 {
-    return availabilityError() == QtMultimedia::NoError;
+    return availability() == QtMultimedia::Available;
 }
 
 /*!
@@ -403,7 +408,7 @@ void QMediaObject::setupControls()
         d->availabilityControl = d->service->requestControl<QMediaAvailabilityControl*>();
         if (d->availabilityControl) {
             connect(d->availabilityControl,
-                    SIGNAL(availabilityChanged(QtMultimedia::AvailabilityError)),
+                    SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)),
                     SLOT(_q_availabilityChanged()));
         }
     }
@@ -412,13 +417,13 @@ void QMediaObject::setupControls()
 /*!
     \fn QMediaObject::availabilityChanged(bool available)
 
-    Signal emitted when the availability state has changed to \a available
+    Signal emitted when the availability state has changed to \a available.
 */
 
 /*!
-    \fn QMediaObject::availabilityErrorChanged(QtMultimedia::AvailabilityError error)
+    \fn QMediaObject::availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 
-    Signal emitted when the availability error has changed to \a error
+    Signal emitted when the availability of the service has changed to \a availabilty
 */
 
 

src/multimedia/qmediaobject.h

@@ -67,7 +67,7 @@ public:
     ~QMediaObject();
 
     virtual bool isAvailable() const;
-    virtual QtMultimedia::AvailabilityError availabilityError() const;
+    virtual QtMultimedia::AvailabilityStatus availability() const;
 
     virtual QMediaService* service() const;
 
@@ -90,7 +90,7 @@ Q_SIGNALS:
     void metaDataChanged(const QString &key, const QVariant &value);
 
     void availabilityChanged(bool available);
-    void availabilityErrorChanged(QtMultimedia::AvailabilityError error);
+    void availabilityChanged(QtMultimedia::AvailabilityStatus availability);
 
 protected:
     QMediaObject(QObject *parent, QMediaService *service);

src/multimedia/qtmedianamespace.cpp

@@ -49,7 +49,7 @@ namespace
     public:
         QMultimediaNamespacePrivateRegisterMetaTypes()
         {
-            qRegisterMetaType<QtMultimedia::AvailabilityError>();
+            qRegisterMetaType<QtMultimedia::AvailabilityStatus>();
             qRegisterMetaType<QtMultimedia::SupportEstimate>();
             qRegisterMetaType<QtMultimedia::EncodingMode>();
             qRegisterMetaType<QtMultimedia::EncodingQuality>();
@@ -400,7 +400,7 @@ Q_DEFINE_METADATA(ThumbnailImage);
 */
 
 /*!
-    \enum QtMultimedia::AvailabilityError
+    \enum QtMultimedia::AvailabilityStatus
 
     Enumerates Service status errors.
 

src/multimedia/qtmedianamespace.h

@@ -314,11 +314,11 @@ namespace QtMultimedia
         TwoPassEncoding
     };
 
-    enum AvailabilityError
+    enum AvailabilityStatus
     {
-        NoError,
-        ServiceMissingError,
-        BusyError,
+        Available,
+        ServiceMissing,
+        Busy,
         ResourceError
     };
 
@@ -328,7 +328,7 @@ namespace QtMultimedia
 
 QT_END_NAMESPACE
 
-Q_DECLARE_METATYPE(QtMultimedia::AvailabilityError)
+Q_DECLARE_METATYPE(QtMultimedia::AvailabilityStatus)
 Q_DECLARE_METATYPE(QtMultimedia::SupportEstimate)
 Q_DECLARE_METATYPE(QtMultimedia::EncodingMode)
 Q_DECLARE_METATYPE(QtMultimedia::EncodingQuality)

src/multimedia/radio/qradiodata.cpp

@@ -227,18 +227,18 @@ bool QRadioData::setMediaObject(QMediaObject *mediaObject)
 /*!
     Returns the availability of the radio data service.
 
-    A long as there is a media service which provides control, then the
-    \l{QtMultimedia::AvailabilityError}{availability error} will be that
-    of the \l{QRadioTuner::availabilityError()}{radio tuner}.
+    A long as there is a media service which provides radio functionality, then the
+    \l{QtMultimedia::AvailabilityStatus}{availability} will be that
+    of the \l{QRadioTuner::availability()}{radio tuner}.
 */
-QtMultimedia::AvailabilityError QRadioData::availabilityError() const
+QtMultimedia::AvailabilityStatus QRadioData::availability() const
 {
     Q_D(const QRadioData);
 
     if (d->control == 0)
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 
-    return d->mediaObject->availabilityError();
+    return d->mediaObject->availability();
 }
 
 /*!

src/multimedia/radio/qradiodata.h

@@ -91,7 +91,7 @@ public:
     QRadioData(QMediaObject *mediaObject, QObject *parent = 0);
     ~QRadioData();
 
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
     QMediaObject *mediaObject() const;
 

src/multimedia/radio/qradiotuner.cpp

@@ -159,15 +159,15 @@ QRadioTuner::~QRadioTuner()
 /*!
     Returns the availability of the radio tuner.
 */
-QtMultimedia::AvailabilityError QRadioTuner::availabilityError() const
+QtMultimedia::AvailabilityStatus QRadioTuner::availability() const
 {
     if (d_func()->control == 0)
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 
     if (!d_func()->control->isAntennaConnected())
         return QtMultimedia::ResourceError;
 
-    return QMediaObject::availabilityError();
+    return QMediaObject::availability();
 }
 
 /*!

src/multimedia/radio/qradiotuner.h

@@ -87,7 +87,7 @@ public:
     QRadioTuner(QObject *parent = 0);
     ~QRadioTuner();
 
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
     State state() const;
 

src/multimedia/recording/qmediarecorder.cpp

@@ -185,7 +185,7 @@ void QMediaRecorderPrivate::_q_applySettings()
     }
 }
 
-void QMediaRecorderPrivate::_q_availabilityChanged(QtMultimedia::AvailabilityError error)
+void QMediaRecorderPrivate::_q_availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 {
     Q_Q(QMediaRecorder);
     Q_UNUSED(error);
@@ -193,8 +193,8 @@ void QMediaRecorderPrivate::_q_availabilityChanged(QtMultimedia::AvailabilityErr
     // Really this should not always emit, but
     // we can't really tell from here (isAvailable
     // may not have changed, or the mediaobject's overridden
-    // availabilityError() may not have changed).
-    q->availabilityErrorChanged(q->availabilityError());
+    // availability() may not have changed).
+    q->availabilityChanged(q->availability());
     q->availabilityChanged(q->isAvailable());
 }
 
@@ -323,8 +323,8 @@ bool QMediaRecorder::setMediaObject(QMediaObject *object)
                 service->releaseControl(d->metaDataControl);
             }
             if (d->availabilityControl) {
-                disconnect(d->availabilityControl, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityError)),
-                           this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
+                disconnect(d->availabilityControl, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)),
+                           this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityStatus)));
                 service->releaseControl(d->availabilityControl);
             }
         }
@@ -375,8 +375,8 @@ bool QMediaRecorder::setMediaObject(QMediaObject *object)
 
                 d->availabilityControl = service->requestControl<QMediaAvailabilityControl*>();
                 if (d->availabilityControl) {
-                    connect(d->availabilityControl, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityError)),
-                            this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
+                    connect(d->availabilityControl, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)),
+                            this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityStatus)));
                 }
 
                 connect(d->control, SIGNAL(stateChanged(QMediaRecorder::State)),
@@ -442,23 +442,23 @@ bool QMediaRecorder::setMediaObject(QMediaObject *object)
 */
 bool QMediaRecorder::isAvailable() const
 {
-    return availabilityError() == QtMultimedia::NoError;
+    return availability() == QtMultimedia::Available;
 }
 
 /*!
-    Returns the availability error code.
+    Returns the availability of this functionality.
 
-    \sa availabilityErrorChanged()
+    \sa availabilityChanged()
 */
-QtMultimedia::AvailabilityError QMediaRecorder::availabilityError() const
+QtMultimedia::AvailabilityStatus QMediaRecorder::availability() const
 {
     if (d_func()->control == NULL)
-        return QtMultimedia::ServiceMissingError;
+        return QtMultimedia::ServiceMissing;
 
     if (d_func()->availabilityControl)
         return d_func()->availabilityControl->availability();
 
-    return QtMultimedia::NoError;
+    return QtMultimedia::Available;
 }
 
 QUrl QMediaRecorder::outputLocation() const
@@ -960,7 +960,7 @@ void QMediaRecorder::stop()
 */
 
 /*!
-    \fn QMediaRecorder::availabilityErrorChanged(QtMultimedia::AvailabilityError availability)
+    \fn QMediaRecorder::availabilityChanged(QtMultimedia::AvailabilityStatus availability)
 
     Signals that the service availability has changed to \a availability.
 */

src/multimedia/recording/qmediarecorder.h

@@ -117,7 +117,7 @@ public:
     QMediaObject *mediaObject() const;
 
     bool isAvailable() const;
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
     QUrl outputLocation() const;
     bool setOutputLocation(const QUrl &location);
@@ -192,7 +192,7 @@ Q_SIGNALS:
     void metaDataChanged(const QString &key, const QVariant &value);
 
     void availabilityChanged(bool available);
-    void availabilityErrorChanged(QtMultimedia::AvailabilityError error);
+    void availabilityChanged(QtMultimedia::AvailabilityStatus availability);
 
 protected:
     QMediaRecorder(QMediaRecorderPrivate &dd, QMediaObject *mediaObject, QObject *parent = 0);
@@ -209,7 +209,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_updateActualLocation(const QUrl &))
     Q_PRIVATE_SLOT(d_func(), void _q_updateNotifyInterval(int))
     Q_PRIVATE_SLOT(d_func(), void _q_applySettings())
-    Q_PRIVATE_SLOT(d_func(), void _q_availabilityChanged(QtMultimedia::AvailabilityError))
+    Q_PRIVATE_SLOT(d_func(), void _q_availabilityChanged(QtMultimedia::AvailabilityStatus))
 };
 
 QT_END_NAMESPACE

src/multimedia/recording/qmediarecorder_p.h

@@ -92,7 +92,7 @@ public:
     void _q_notify();
     void _q_updateNotifyInterval(int ms);
     void _q_applySettings();
-    void _q_availabilityChanged(QtMultimedia::AvailabilityError error);
+    void _q_availabilityChanged(QtMultimedia::AvailabilityStatus availability);
 
     QMediaRecorder *q_ptr;
 };

src/plugins/gstreamer/mediaplayer/qgstreameravailabilitycontrol.cpp

@@ -58,9 +58,9 @@ void QGStreamerAvailabilityControl::handleAvailabilityChanged()
     emit availabilityChanged(this->availability());
 }
 
-QtMultimedia::AvailabilityError QGStreamerAvailabilityControl::availability() const
+QtMultimedia::AvailabilityStatus QGStreamerAvailabilityControl::availability() const
 {
-    return m_resources->isAvailable() ? QtMultimedia::NoError : QtMultimedia::BusyError;
+    return m_resources->isAvailable() ? QtMultimedia::Available : QtMultimedia::Busy;
 }
 
 QT_END_NAMESPACE

src/plugins/gstreamer/mediaplayer/qgstreameravailabilitycontrol.h

@@ -53,7 +53,7 @@ class QGStreamerAvailabilityControl : public QMediaAvailabilityControl
     Q_OBJECT
 public:
     QGStreamerAvailabilityControl(QMediaPlayerResourceSetInterface *resources, QObject *parent = 0);
-    QtMultimedia::AvailabilityError availability() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
 private Q_SLOTS:
     void handleAvailabilityChanged();

src/plugins/v4l/radio/v4lradiocontrol.cpp

@@ -88,10 +88,10 @@ bool V4LRadioControl::isAvailable() const
     return available;
 }
 
-QtMultimedia::AvailabilityError V4LRadioControl::availabilityError() const
+QtMultimedia::AvailabilityStatus V4LRadioControl::availability() const
 {
     if (fd > 0)
-        return QtMultimedia::NoError;
+        return QtMultimedia::Available;
     else
         return QtMultimedia::ResourceError;
 }

src/plugins/v4l/radio/v4lradiocontrol.h

@@ -65,7 +65,7 @@ public:
     ~V4LRadioControl();
 
     bool isAvailable() const;
-    QtMultimedia::AvailabilityError availabilityError() const;
+    QtMultimedia::AvailabilityStatus availability() const;
 
     QRadioTuner::State state() const;