Made QRadioData bind to QRadioTuner to avoid using multiple services

QRadioData has been updated to be a QMediaBindableInterface, and it
will bind to a QRadioTuner instance, i.e. a QMediaObject that provides
a service which implements the QRadioDataControl.
This change is reflected in the declarative implementations of radio
tuner and data. There is a new `radioData` property in the Radio element
which will give access to the declarative RadioData element for the
tuner.
If a RadioData element is created in QML, it will have an anonymous
tuner which communicates with the underlying media service (which is
pretty much the same how the QRadioTuner and QRadioData classes work
previously).
Updated radio tuner and data test cases to use availability control
and extended the mock media service to allow providing a number of
controls rather than just one (needed for testing availability of
all classes extending from or using QMediaObject).

Change-Id: Id41dde66eee529decd828fd2dcdfe4a54c0e81f4
Reviewed-by: Michael Goddard <michael.goddard@nokia.com>

doc/src/snippets/multimedia-snippets/media.cpp

@@ -49,6 +49,7 @@
 #include "qmediaplayercontrol.h"
 #include "qmediaplayer.h"
 #include "qradiotuner.h"
+#include "qradiodata.h"
 #include "qvideowidget.h"
 #include "qcameraimagecapture.h"
 #include "qcamera.h"
@@ -84,6 +85,7 @@ private:
     QCameraImageCapture *imageCapture;
     QString fileName;
     QRadioTuner *radio;
+    QRadioData *radioData;
     QAudioRecorder *audioRecorder;
     QAudioProbe *audioProbe;
     QVideoProbe *videoProbe;
@@ -248,6 +250,11 @@ void MediaExample::RadioTuna()
         radio->start();
     }
     //! [Radio tuner]
+
+    //! [Radio data setup]
+    radio = new QRadioTuner;
+    radioData = radio->radioData();
+    //! [Radio data setup]
 }
 
 void MediaExample::AudioProbe()

src/imports/multimedia/qdeclarativeradio.cpp

@@ -87,7 +87,9 @@ QT_BEGIN_NAMESPACE
     You can also use the Radio element to get information about tuning, for instance the
     frequency steps supported for tuning.
 
-    The corresponding \l RadioData element gives RDS information about the current radio station.
+    The corresponding \l RadioData element gives RDS information about the
+    current radio station. The best way to access the RadioData element for
+    the current Radio is to use the \c radioData property.
 
     \sa {Radio Overview}
 
@@ -95,10 +97,10 @@ QT_BEGIN_NAMESPACE
 
 
 QDeclarativeRadio::QDeclarativeRadio(QObject *parent) :
-    QObject(parent),
+    QObject(parent)
-    m_radioTuner(0)
 {
     m_radioTuner = new QRadioTuner(this);
+    m_radioData = new QDeclarativeRadioData(m_radioTuner, this);
 
     connect(m_radioTuner, SIGNAL(stateChanged(QRadioTuner::State)), this, SLOT(_q_stateChanged(QRadioTuner::State)));
     connect(m_radioTuner, SIGNAL(bandChanged(QRadioTuner::Band)), this, SLOT(_q_bandChanged(QRadioTuner::Band)));

src/imports/multimedia/qdeclarativeradio_p.h

@@ -55,6 +55,7 @@
 
 #include <QtDeclarative/qdeclarative.h>
 #include <qradiotuner.h>
+#include "qdeclarativeradiodata_p.h"
 
 QT_BEGIN_HEADER
 
@@ -77,6 +78,7 @@ class QDeclarativeRadio : public QObject
     Q_PROPERTY(int maximumFrequency READ maximumFrequency NOTIFY bandChanged)
     Q_PROPERTY(bool antennaConnected READ isAntennaConnected NOTIFY antennaConnectedChanged)
     Q_PROPERTY(Availability availability READ availability NOTIFY availabilityChanged)
+    Q_PROPERTY(QDeclarativeRadioData* radioData READ radioData CONSTANT)
     Q_ENUMS(State)
     Q_ENUMS(Band)
     Q_ENUMS(Error)
@@ -146,6 +148,8 @@ public:
     Q_INVOKABLE bool isAvailable() const {return availability() == Available;}
     Availability availability() const;
 
+    QDeclarativeRadioData *radioData() { return m_radioData; }
+
 public Q_SLOTS:
     void setBand(QDeclarativeRadio::Band band);
     void setFrequency(int frequency);
@@ -190,6 +194,7 @@ private:
     Q_DISABLE_COPY(QDeclarativeRadio)
 
     QRadioTuner *m_radioTuner;
+    QDeclarativeRadioData *m_radioData;
 };
 
 QT_END_NAMESPACE

src/imports/multimedia/qdeclarativeradiodata.cpp

@@ -70,52 +70,47 @@ QT_BEGIN_NAMESPACE
             band: Radio.FM
         }
 
-        RadioData {
-            id: radioData
-        }
-
         Column {
             Text {
-                text: radioData.stationName
+                text: radio.radioData.stationName
             }
 
             Text {
-                text: radioData.programTypeName
+                text: radio.radioData.programTypeName
             }
 
             Text {
-                text: radioData.radioText
+                text: radio.radioData.radioText
             }
         }
     }
 
     \endqml
 
-    You use \c RadioData together with the \l Radio element. The properties of the RadioData element will reflect the
+    You use \c RadioData together with the \l Radio element, either by
-    information broadcast by the radio station the Radio element is currently tuned to.
+    accessing the \c radioData property of the Radio element, or
+    creating a separate RadioData element. The properties of the
+    RadioData element will reflect the information broadcast by the
+    radio station the Radio element is currently tuned to.
 
     \sa {Radio Overview}
 */
 QDeclarativeRadioData::QDeclarativeRadioData(QObject *parent) :
-    QObject(parent),
+    QObject(parent)
-    m_radioData(0)
 {
-    m_radioData = new QRadioData(this);
+    m_radioTuner = new QRadioTuner(this);
+    m_radioData = m_radioTuner->radioData();
 
-    connect(m_radioData, SIGNAL(programTypeChanged(QRadioData::ProgramType)), this,
+    connectSignals();
-                                 SLOT(_q_programTypeChanged(QRadioData::ProgramType)));
+}
 
-    connect(m_radioData, SIGNAL(stationIdChanged(QString)), this, SIGNAL(stationIdChanged(QString)));
+QDeclarativeRadioData::QDeclarativeRadioData(QRadioTuner *tuner, QObject *parent) :
-    connect(m_radioData, SIGNAL(programTypeNameChanged(QString)), this, SIGNAL(programTypeNameChanged(QString)));
+    QObject(parent)
-    connect(m_radioData, SIGNAL(stationNameChanged(QString)), this, SIGNAL(stationNameChanged(QString)));
+{
-    connect(m_radioData, SIGNAL(radioTextChanged(QString)), this, SIGNAL(radioTextChanged(QString)));
+    m_radioTuner = tuner;
-    connect(m_radioData, SIGNAL(alternativeFrequenciesEnabledChanged(bool)), this,
+    m_radioData = m_radioTuner->radioData();
-                         SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
 
-    // Note we map availabilityError->availability
+    connectSignals();
-    connect(m_radioData, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)), this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
-
-    connect(m_radioData, SIGNAL(error(QRadioData::Error)), this, SLOT(_q_error(QRadioData::Error)));
 }
 
 QDeclarativeRadioData::~QDeclarativeRadioData()
@@ -290,4 +285,23 @@ void QDeclarativeRadioData::_q_availabilityChanged(QtMultimedia::AvailabilityErr
     emit availabilityChanged(Availability(error));
 }
 
+void QDeclarativeRadioData::connectSignals()
+{
+    connect(m_radioData, SIGNAL(programTypeChanged(QRadioData::ProgramType)), this,
+                                 SLOT(_q_programTypeChanged(QRadioData::ProgramType)));
+
+    connect(m_radioData, SIGNAL(stationIdChanged(QString)), this, SIGNAL(stationIdChanged(QString)));
+    connect(m_radioData, SIGNAL(programTypeNameChanged(QString)), this, SIGNAL(programTypeNameChanged(QString)));
+    connect(m_radioData, SIGNAL(stationNameChanged(QString)), this, SIGNAL(stationNameChanged(QString)));
+    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 element 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_radioData, SIGNAL(error(QRadioData::Error)), this, SLOT(_q_error(QRadioData::Error)));
+}
+
 QT_END_NAMESPACE

src/imports/multimedia/qdeclarativeradiodata_p.h

@@ -55,6 +55,7 @@
 
 #include <QtDeclarative/qdeclarative.h>
 #include <qradiodata.h>
+#include <qradiotuner.h>
 
 QT_BEGIN_HEADER
 
@@ -143,6 +144,7 @@ public:
     };
 
     QDeclarativeRadioData(QObject *parent = 0);
+    QDeclarativeRadioData(QRadioTuner *tuner, QObject *parent = 0);
     ~QDeclarativeRadioData();
 
     QString stationId() const;
@@ -177,9 +179,12 @@ private Q_SLOTS:
     void _q_availabilityChanged(QtMultimedia::AvailabilityError);
 
 private:
+    void connectSignals();
+
     Q_DISABLE_COPY(QDeclarativeRadioData)
 
     QRadioData *m_radioData;
+    QRadioTuner *m_radioTuner;
 };
 
 QT_END_NAMESPACE

src/multimedia/radio/qradiodata.cpp

@@ -75,47 +75,64 @@ namespace
     The radio data object will emit signals for any changes in radio data. You can enable or disable
     alternative frequency with setAlternativeFrequenciesEnabled().
 
+    You can get a QRadioData instance fromt the \l{QRadioTuner::radioData()}{radioData}
+    property from a QRadioTuner instance.
+
+    \snippet doc/src/snippets/multimedia-snippets/media.cpp Radio data setup
+
+    Alternatively, you can pass an instance of QRadioTuner to the constructor to QRadioData.
+
     \sa {Radio Overview}
 
 */
 
 
-class QRadioDataPrivate : public QMediaObjectPrivate
+class QRadioDataPrivate
 {
+    Q_DECLARE_NON_CONST_PUBLIC(QRadioData)
 public:
-    QRadioDataPrivate():provider(0), control(0) {}
+    QRadioDataPrivate();
-    QMediaServiceProvider *provider;
+
+    QMediaObject *mediaObject;
     QRadioDataControl* control;
+
+    void _q_serviceDestroyed();
+
+    QRadioData *q_ptr;
 };
 
-/*!
+QRadioDataPrivate::QRadioDataPrivate()
-    Constructs a radio data based on a media service allocated by a media service \a provider.
+    : mediaObject(0)
+    , control(0)
+{}
 
-    The \a parent is passed to QMediaObject.
+void QRadioDataPrivate::_q_serviceDestroyed()
+{
+    mediaObject = 0;
+    control = 0;
+}
+
+/*!
+    Constructs a radio data based on a media object.
+
+    The \a mediaObject should be an instance of \l QRadioTuner. It is preferable to use the
+    \l{QRadioTuner::radioData()}{radioData} property on a QRadioTuner instance to get an instance
+    of QRadioData.
+
+    During construction, this class is bound to the \a mediaObject using the
+    \l{QMediaObject::bind()}{bind()} method.
 */
 
-QRadioData::QRadioData(QObject *parent):
+QRadioData::QRadioData(QMediaObject *mediaObject, QObject *parent)
-    QMediaObject(*new QRadioDataPrivate,
+    : QObject(parent)
-                 parent,
+    , d_ptr(new QRadioDataPrivate)
-                 QMediaServiceProvider::defaultServiceProvider()->requestService(Q_MEDIASERVICE_RADIO))
 {
     Q_D(QRadioData);
 
-    d->provider = QMediaServiceProvider::defaultServiceProvider();
+    d->q_ptr = this;
 
-    if (d->service != 0) {
+    if (mediaObject)
-        d->control = qobject_cast<QRadioDataControl*>(d->service->requestControl(QRadioDataControl_iid));
+        mediaObject->bind(this);
-        if (d->control != 0) {
-            connect(d->control, SIGNAL(stationIdChanged(QString)), SIGNAL(stationIdChanged(QString)));
-            connect(d->control, SIGNAL(programTypeChanged(QRadioData::ProgramType)),
-                                SIGNAL(programTypeChanged(QRadioData::ProgramType)));
-            connect(d->control, SIGNAL(programTypeNameChanged(QString)), SIGNAL(programTypeNameChanged(QString)));
-            connect(d->control, SIGNAL(stationNameChanged(QString)), SIGNAL(stationNameChanged(QString)));
-            connect(d->control, SIGNAL(radioTextChanged(QString)), SIGNAL(radioTextChanged(QString)));
-            connect(d->control, SIGNAL(alternativeFrequenciesEnabledChanged(bool)), SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
-            connect(d->control, SIGNAL(error(QRadioData::Error)), SIGNAL(error(QRadioData::Error)));
-        }
-    }
 }
 
 /*!
@@ -126,14 +143,93 @@ QRadioData::~QRadioData()
 {
     Q_D(QRadioData);
 
-    if (d->service && d->control)
+    if (d->mediaObject)
-        d->service->releaseControl(d->control);
+        d->mediaObject->unbind(this);
 
-    d->provider->releaseService(d->service);
+    delete d_ptr;
+}
+
+/*!
+  \reimp
+*/
+QMediaObject *QRadioData::mediaObject() const
+{
+    return d_func()->mediaObject;
+}
+
+/*!
+  \reimp
+*/
+bool QRadioData::setMediaObject(QMediaObject *mediaObject)
+{
+    Q_D(QRadioData);
+
+    if (d->mediaObject) {
+        if (d->control) {
+            disconnect(d->control, SIGNAL(stationIdChanged(QString)),
+                       this, SIGNAL(stationIdChanged(QString)));
+            disconnect(d->control, SIGNAL(programTypeChanged(QRadioData::ProgramType)),
+                       this, SIGNAL(programTypeChanged(QRadioData::ProgramType)));
+            disconnect(d->control, SIGNAL(programTypeNameChanged(QString)),
+                       this, SIGNAL(programTypeNameChanged(QString)));
+            disconnect(d->control, SIGNAL(stationNameChanged(QString)),
+                       this, SIGNAL(stationNameChanged(QString)));
+            disconnect(d->control, SIGNAL(radioTextChanged(QString)),
+                       this, SIGNAL(radioTextChanged(QString)));
+            disconnect(d->control, SIGNAL(alternativeFrequenciesEnabledChanged(bool)),
+                       this, SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
+            disconnect(d->control, SIGNAL(error(QRadioData::Error)),
+                       this, SIGNAL(error(QRadioData::Error)));
+
+            QMediaService *service = d->mediaObject->service();
+            service->releaseControl(d->control);
+            disconnect(service, SIGNAL(destroyed()), this, SLOT(_q_serviceDestroyed()));
+        }
+    }
+
+    d->mediaObject = mediaObject;
+
+    if (d->mediaObject) {
+        QMediaService *service = mediaObject->service();
+        if (service) {
+            d->control = qobject_cast<QRadioDataControl*>(service->requestControl(QRadioDataControl_iid));
+
+            if (d->control) {
+                connect(d->control, SIGNAL(stationIdChanged(QString)),
+                        this, SIGNAL(stationIdChanged(QString)));
+                connect(d->control, SIGNAL(programTypeChanged(QRadioData::ProgramType)),
+                        this, SIGNAL(programTypeChanged(QRadioData::ProgramType)));
+                connect(d->control, SIGNAL(programTypeNameChanged(QString)),
+                        this, SIGNAL(programTypeNameChanged(QString)));
+                connect(d->control, SIGNAL(stationNameChanged(QString)),
+                        this, SIGNAL(stationNameChanged(QString)));
+                connect(d->control, SIGNAL(radioTextChanged(QString)),
+                        this, SIGNAL(radioTextChanged(QString)));
+                connect(d->control, SIGNAL(alternativeFrequenciesEnabledChanged(bool)),
+                        this, SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
+                connect(d->control, SIGNAL(error(QRadioData::Error)),
+                        this, SIGNAL(error(QRadioData::Error)));
+
+                connect(service, SIGNAL(destroyed()), this, SLOT(_q_serviceDestroyed()));
+
+                return true;
+            }
+        }
+    }
+
+    // without QRadioDataControl discard the media object
+    d->mediaObject = 0;
+    d->control = 0;
+
+    return false;
 }
 
 /*!
     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}.
 */
 QtMultimedia::AvailabilityError QRadioData::availabilityError() const
 {
@@ -142,7 +238,7 @@ QtMultimedia::AvailabilityError QRadioData::availabilityError() const
     if (d->control == 0)
         return QtMultimedia::ServiceMissingError;
 
-    return QMediaObject::availabilityError();
+    return d->mediaObject->availabilityError();
 }
 
 /*!

src/multimedia/radio/qradiodata.h

@@ -44,11 +44,10 @@
 
 #include <QtCore/qobject.h>
 
-#include "qmediaobject.h"
+#include <qmediaobject.h>
+#include <qmediabindableinterface.h>
 #include <qmediaenumdebug.h>
 
-#include <QPair>
-
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
@@ -57,7 +56,7 @@ QT_MODULE(Multimedia)
 
 
 class QRadioDataPrivate;
-class Q_MULTIMEDIA_EXPORT QRadioData : public QMediaObject
+class Q_MULTIMEDIA_EXPORT QRadioData : public QObject, public QMediaBindableInterface
 {
     Q_OBJECT
     Q_PROPERTY(QString stationId READ stationId NOTIFY stationIdChanged)
@@ -70,6 +69,8 @@ class Q_MULTIMEDIA_EXPORT QRadioData : public QMediaObject
     Q_ENUMS(Error)
     Q_ENUMS(ProgramType)
 
+    Q_INTERFACES(QMediaBindableInterface)
+
 public:
     enum Error { NoError, ResourceError, OpenError, OutOfRangeError };
 
@@ -87,11 +88,13 @@ public:
         College
     };
 
-    QRadioData(QObject *parent = 0);
+    QRadioData(QMediaObject *mediaObject, QObject *parent = 0);
     ~QRadioData();
 
     QtMultimedia::AvailabilityError availabilityError() const;
 
+    QMediaObject *mediaObject() const;
+
     QString stationId() const;
     ProgramType programType() const;
     QString programTypeName() const;
@@ -115,10 +118,15 @@ Q_SIGNALS:
 
     void error(QRadioData::Error error);
 
+protected:
+    bool setMediaObject(QMediaObject *);
+
+    QRadioDataPrivate *d_ptr;
 private:
 
     Q_DISABLE_COPY(QRadioData)
     Q_DECLARE_PRIVATE(QRadioData)
+    Q_PRIVATE_SLOT(d_func(), void _q_serviceDestroyed())
 };
 
 QT_END_NAMESPACE

src/multimedia/radio/qradiotuner.cpp

@@ -43,6 +43,7 @@
 #include "qmediaservice.h"
 #include "qmediaobject_p.h"
 #include "qradiotunercontrol.h"
+#include "qradiodata.h"
 #include "qmediaserviceprovider_p.h"
 
 #include <QPair>
@@ -94,9 +95,10 @@ namespace
 class QRadioTunerPrivate : public QMediaObjectPrivate
 {
 public:
-    QRadioTunerPrivate():provider(0), control(0) {}
+    QRadioTunerPrivate():provider(0), control(0), radioData(0) {}
     QMediaServiceProvider *provider;
     QRadioTunerControl* control;
+    QRadioData *radioData;
 };
 
 
@@ -131,6 +133,8 @@ QRadioTuner::QRadioTuner(QObject *parent):
             connect(d->control, SIGNAL(antennaConnectedChanged(bool)), SIGNAL(antennaConnectedChanged(bool)));
             connect(d->control, SIGNAL(error(QRadioTuner::Error)), SIGNAL(error(QRadioTuner::Error)));
         }
+
+        d->radioData = new QRadioData(this, this);
     }
 }
 
@@ -142,6 +146,9 @@ QRadioTuner::~QRadioTuner()
 {
     Q_D(QRadioTuner);
 
+    if (d->radioData)
+        delete d->radioData;
+
     if (d->service && d->control)
         d->service->releaseControl(d->control);
 
@@ -539,6 +546,18 @@ QString QRadioTuner::errorString() const
     return QString();
 }
 
+/*!
+    \property QRadioTuner::radioData
+    \brief holds an instance of \l QRadioData
+
+    The instance of QRadioData is already bound to this instance of QRadioTuner.
+*/
+QRadioData *QRadioTuner::radioData() const
+{
+    return d_func()->radioData;
+}
+
+
 /*!
     \fn void QRadioTuner::bandChanged(QRadioTuner::Band band)
 

src/multimedia/radio/qradiotuner.h

@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Multimedia)
 
-
+class QRadioData;
 class QRadioTunerPrivate;
 class Q_MULTIMEDIA_EXPORT QRadioTuner : public QMediaObject
 {
@@ -70,6 +70,7 @@ class Q_MULTIMEDIA_EXPORT QRadioTuner : public QMediaObject
     Q_PROPERTY(bool muted READ isMuted WRITE setMuted NOTIFY mutedChanged)
     Q_PROPERTY(bool searching READ isSearching NOTIFY searchingChanged)
     Q_PROPERTY(bool antennaConnected READ isAntennaConnected NOTIFY antennaConnectedChanged)
+    Q_PROPERTY(QRadioData *radioData READ radioData CONSTANT)
     Q_ENUMS(State)
     Q_ENUMS(Band)
     Q_ENUMS(Error)
@@ -114,6 +115,8 @@ public:
     Error error() const;
     QString errorString() const;
 
+    QRadioData *radioData() const;
+
 public Q_SLOTS:
     void searchForward();
     void searchBackward();

tests/auto/unit/qmultimedia_common/mockmediaservice.h

@@ -43,6 +43,9 @@
 #define MOCKMEDIASERVICE_H
 
 #include "qmediaservice.h"
+#include <QtCore/QMap>
+
+Q_DECLARE_METATYPE(QMediaControl *)
 
 class MockMediaService : public QMediaService
 {
@@ -52,14 +55,23 @@ public:
         QMediaService(parent),
         mockControl(control) {}
 
-    QMediaControl* requestControl(const char *)
+    MockMediaService(QObject *parent, QMap<QString, QMediaControl *> controls):
+        QMediaService(parent),
+        mockControl(0),
+        mockControls(controls) {}
+
+    QMediaControl* requestControl(const char *key)
     {
-        return mockControl;
+        if (mockControl)
+            return mockControl;
+        else
+            return mockControls.value(key);
     }
 
     void releaseControl(QMediaControl*) {}
 
-    QMediaControl   *mockControl;
+    QMediaControl *mockControl;
+    QMap<QString, QMediaControl *>   mockControls;
 };
 
 

tests/auto/unit/qradiodata/tst_qradiodata.cpp

@@ -44,15 +44,19 @@
 #include <QtTest/QtTest>
 #include <QDebug>
 #include <QTimer>
+#include <QtCore/QMap>
 
 #include <qmediaobject.h>
 #include <qmediacontrol.h>
 #include <qmediaservice.h>
 #include <qradiodatacontrol.h>
 #include <qradiodata.h>
+#include <qradiotuner.h>
 
 #include "mockmediaserviceprovider.h"
 #include "mockmediaservice.h"
+#include "mockavailabilitycontrol.h"
+#include "mockradiotunercontrol.h"
 #include "mockradiodatacontrol.h"
 
 QT_USE_NAMESPACE
@@ -72,34 +76,47 @@ private slots:
     void testRadioDataUpdates();
 
 private:
-    MockRadioDataControl     *mock;
+    MockAvailabilityControl  *mockAvailability;
+    MockRadioTunerControl    *mockTuner;
+    MockRadioDataControl     *mockData;
     MockMediaService     *service;
     MockMediaServiceProvider    *provider;
-    QRadioData    *radio;
+    QRadioTuner   * radio;
+    QRadioData    *radioData;
 };
 
 void tst_QRadioData::initTestCase()
 {
     qRegisterMetaType<QRadioData::ProgramType>("QRadioData::ProgramType");
 
-    mock = new MockRadioDataControl(this);
+    mockAvailability = new MockAvailabilityControl(QtMultimedia::NoError);
-    service = new MockMediaService(this, mock);
+    mockTuner = new MockRadioTunerControl(this);
+    mockData = new MockRadioDataControl(this);
+
+    QMap<QString, QMediaControl *> map;
+    map.insert(QRadioTunerControl_iid, mockTuner);
+    map.insert(QRadioDataControl_iid, mockData);
+    map.insert(QMediaAvailabilityControl_iid, mockAvailability);
+
+    service = new MockMediaService(this, map);
     provider = new MockMediaServiceProvider(service);
     QMediaServiceProvider::setDefaultServiceProvider(provider);
-    radio = new QRadioData;
+
-    QVERIFY(radio->service() != 0);
+    radio = new QRadioTuner;
-    QVERIFY(radio->isAvailable());
+    radioData = radio->radioData();
-    QVERIFY(radio->availabilityError() == QtMultimedia::NoError);
+
+    QVERIFY(radioData->availabilityError() == QtMultimedia::NoError);
 }
 
 void tst_QRadioData::cleanupTestCase()
 {
-    QVERIFY(radio->error() == QRadioData::NoError);
+    QVERIFY(radioData->error() == QRadioData::NoError);
-    QVERIFY(radio->errorString().isEmpty());
+    QVERIFY(radioData->errorString().isEmpty());
 
     delete radio;
     delete service;
     delete provider;
+    delete mockAvailability;
 }
 
 void tst_QRadioData::testNullService()
@@ -108,17 +125,21 @@ void tst_QRadioData::testNullService()
 
     MockMediaServiceProvider nullProvider(0);
     QMediaServiceProvider::setDefaultServiceProvider(&nullProvider);
-    QRadioData radio;
+    QRadioTuner radio;
+    QRadioData *nullRadioData = radio.radioData();
 
-    QVERIFY(!radio.isAvailable());
+    QVERIFY(nullRadioData == 0);
-    QCOMPARE(radio.error(), QRadioData::ResourceError);
+
-    QCOMPARE(radio.errorString(), QString());
+    QRadioData radioData(&radio);
-    QCOMPARE(radio.stationId(), QString());
+
-    QCOMPARE(radio.programType(), QRadioData::Undefined);
+    QCOMPARE(radioData.error(), QRadioData::ResourceError);
-    QCOMPARE(radio.programTypeName(), QString());
+    QCOMPARE(radioData.errorString(), QString());
-    QCOMPARE(radio.stationName(), QString());
+    QCOMPARE(radioData.stationId(), QString());
-    QCOMPARE(radio.radioText(), QString());
+    QCOMPARE(radioData.programType(), QRadioData::Undefined);
-    QCOMPARE(radio.isAlternativeFrequenciesEnabled(), false);
+    QCOMPARE(radioData.programTypeName(), QString());
+    QCOMPARE(radioData.stationName(), QString());
+    QCOMPARE(radioData.radioText(), QString());
+    QCOMPARE(radioData.isAlternativeFrequenciesEnabled(), false);
 
 }
 
@@ -129,59 +150,58 @@ void tst_QRadioData::testNullControl()
     MockMediaService service(0, 0);
     MockMediaServiceProvider provider(&service);
     QMediaServiceProvider::setDefaultServiceProvider(&provider);
-    QRadioData radio;
+    QRadioTuner radio;
-    QVERIFY(!radio.isAvailable());
+    QRadioData *radioData = radio.radioData();
-    QCOMPARE(radio.error(), QRadioData::ResourceError);
+    QCOMPARE(radioData->error(), QRadioData::ResourceError);
-    QCOMPARE(radio.errorString(), QString());
+    QCOMPARE(radioData->errorString(), QString());
 
-    QCOMPARE(radio.stationId(), QString());
+    QCOMPARE(radioData->stationId(), QString());
-    QCOMPARE(radio.programType(), QRadioData::Undefined);
+    QCOMPARE(radioData->programType(), QRadioData::Undefined);
-    QCOMPARE(radio.programTypeName(), QString());
+    QCOMPARE(radioData->programTypeName(), QString());
-    QCOMPARE(radio.stationName(), QString());
+    QCOMPARE(radioData->stationName(), QString());
-    QCOMPARE(radio.radioText(), QString());
+    QCOMPARE(radioData->radioText(), QString());
-    QCOMPARE(radio.isAlternativeFrequenciesEnabled(), false);
+    QCOMPARE(radioData->isAlternativeFrequenciesEnabled(), false);
     {
-        QSignalSpy spy(&radio, SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
+        QSignalSpy spy(radioData, SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
 
-        radio.setAlternativeFrequenciesEnabled(true);
+        radioData->setAlternativeFrequenciesEnabled(true);
-        QCOMPARE(radio.isAlternativeFrequenciesEnabled(), false);
+        QCOMPARE(radioData->isAlternativeFrequenciesEnabled(), false);
         QCOMPARE(spy.count(), 0);
     }
 }
 
 void tst_QRadioData::testAlternativeFrequencies()
 {
-    QSignalSpy readSignal(radio, SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
+    QSignalSpy readSignal(radioData, SIGNAL(alternativeFrequenciesEnabledChanged(bool)));
-    radio->setAlternativeFrequenciesEnabled(true);
+    radioData->setAlternativeFrequenciesEnabled(true);
     QTestEventLoop::instance().enterLoop(1);
-    QVERIFY(radio->isAlternativeFrequenciesEnabled() == true);
+    QVERIFY(radioData->isAlternativeFrequenciesEnabled() == true);
     QVERIFY(readSignal.count() == 1);
 }
 
 void tst_QRadioData::testRadioDataUpdates()
 {
-    QSignalSpy rtSpy(radio, SIGNAL(radioTextChanged(QString)));
+    QSignalSpy rtSpy(radioData, SIGNAL(radioTextChanged(QString)));
-    QSignalSpy ptyPTYSpy(radio, SIGNAL(programTypeChanged(QRadioData::ProgramType)));
+    QSignalSpy ptyPTYSpy(radioData, SIGNAL(programTypeChanged(QRadioData::ProgramType)));
-    QSignalSpy ptynSpy(radio, SIGNAL(programTypeNameChanged(QString)));
+    QSignalSpy ptynSpy(radioData, SIGNAL(programTypeNameChanged(QString)));
-    QSignalSpy piSpy(radio, SIGNAL(stationIdChanged(QString)));
+    QSignalSpy piSpy(radioData, SIGNAL(stationIdChanged(QString)));
-    QSignalSpy psSpy(radio, SIGNAL(stationNameChanged(QString)));
+    QSignalSpy psSpy(radioData, SIGNAL(stationNameChanged(QString)));
-    mock->forceRT("Mock Radio Text");
+    mockData->forceRT("Mock Radio Text");
-    mock->forceProgramType(static_cast<int>(QRadioData::Sport));
+    mockData->forceProgramType(static_cast<int>(QRadioData::Sport));
-    mock->forcePTYN("Mock Programme Type Name");
+    mockData->forcePTYN("Mock Programme Type Name");
-    mock->forcePI("Mock Programme Identification");
+    mockData->forcePI("Mock Programme Identification");
-    mock->forcePS("Mock Programme Service");
+    mockData->forcePS("Mock Programme Service");
     QTestEventLoop::instance().enterLoop(1);
     QVERIFY(rtSpy.count() == 1);
     QVERIFY(ptyPTYSpy.count() == 1);
     QVERIFY(ptynSpy.count() == 1);
     QVERIFY(piSpy.count() == 1);
     QVERIFY(psSpy.count() == 1);
-    qDebug()<<radio->radioText();
+    QCOMPARE(radioData->radioText(), QString("Mock Radio Text"));
-    QCOMPARE(radio->radioText(), QString("Mock Radio Text"));
+    QCOMPARE(radioData->programType(), QRadioData::Sport);
-    QCOMPARE(radio->programType(), QRadioData::Sport);
+    QCOMPARE(radioData->programTypeName(), QString("Mock Programme Type Name"));
-    QCOMPARE(radio->programTypeName(), QString("Mock Programme Type Name"));
+    QCOMPARE(radioData->stationId(), QString("Mock Programme Identification"));
-    QCOMPARE(radio->stationId(), QString("Mock Programme Identification"));
+    QCOMPARE(radioData->stationName(), QString("Mock Programme Service"));
-    QCOMPARE(radio->stationName(), QString("Mock Programme Service"));
 }
 
 QTEST_GUILESS_MAIN(tst_QRadioData)

tests/auto/unit/qradiotuner/tst_qradiotuner.cpp

@@ -44,6 +44,7 @@
 #include <QtTest/QtTest>
 #include <QDebug>
 #include <QTimer>
+#include <QtCore/QMap>
 
 #include <qmediaobject.h>
 #include <qmediacontrol.h>
@@ -54,6 +55,7 @@
 #include "mockmediaserviceprovider.h"
 #include "mockmediaservice.h"
 #include "mockradiotunercontrol.h"
+#include "mockavailabilitycontrol.h"
 
 QT_USE_NAMESPACE
 
@@ -81,6 +83,7 @@ private slots:
 
 private:
     MockRadioTunerControl     *mock;
+    MockAvailabilityControl   *mockAvailability;
     MockMediaService     *service;
     MockMediaServiceProvider    *provider;
     QRadioTuner    *radio;
@@ -92,7 +95,13 @@ void tst_QRadioTuner::initTestCase()
     qRegisterMetaType<QRadioTuner::Band>("QRadioTuner::Band");
 
     mock = new MockRadioTunerControl(this);
-    service = new MockMediaService(this, mock);
+    mockAvailability = new MockAvailabilityControl(QtMultimedia::NoError);
+
+    QMap<QString, QMediaControl *> map;
+    map.insert(QRadioTunerControl_iid, mock);
+    map.insert(QMediaAvailabilityControl_iid, mockAvailability);
+
+    service = new MockMediaService(this, map);
     provider = new MockMediaServiceProvider(service);
     QMediaServiceProvider::setDefaultServiceProvider(provider);
 
@@ -129,6 +138,7 @@ void tst_QRadioTuner::cleanupTestCase()
     delete radio;
     delete service;
     delete provider;
+    delete mockAvailability;
 }
 
 void tst_QRadioTuner::init()