First step in cleaning up the plugin loading code

Stop assuming that there are multiple plugins providing
the same service. We'll have exactly one plugin for a
service in the future and not provide several.

The reason is that we will focus on having one good and
functional multimedia backend per platform, not the mix
of many semi-functional ones as we have today.

Change-Id: I809d4c99a56a48369d0ba283af78b1c41740d92a
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Doris Verria <doris.verria@qt.io>

24 files changed, 73 insertions, 551 deletions

diff --git a/src/multimedia/controls/qmediaplayercontrol.cpp b/src/multimedia/controls/qmediaplayercontrol.cpp
index 7602f80ce..4987c6d2f 100644
--- a/src/multimedia/controls/qmediaplayercontrol.cpp
+++ b/src/multimedia/controls/qmediaplayercontrol.cpp
@@ -327,7 +327,7 @@ QMediaPlayerControl::QMediaPlayerControl(QObject *parent):
     to that media.
 
     Qt resource files are never passed as is. If the service supports
-    QMediaServiceProviderHint::StreamPlayback, a \a stream is supplied, pointing to an opened
+    QMediaServiceFeaturesInterface::StreamPlayback, a \a stream is supplied, pointing to an opened
     QFile. Otherwise, the resource is copied into a temporary file and \a media contains the
     url to that file.
 */
diff --git a/src/multimedia/playback/qmediaplayer.cpp b/src/multimedia/playback/qmediaplayer.cpp
index 002f6ce74..b4e3887b0 100644
--- a/src/multimedia/playback/qmediaplayer.cpp
+++ b/src/multimedia/playback/qmediaplayer.cpp
@@ -552,24 +552,9 @@ void QMediaPlayerPrivate::_q_handlePlaylistLoadFailed()
         setMedia(QMediaContent(), nullptr);
 }
 
-static QMediaService *playerService(QMediaPlayer::Flags flags)
+static QMediaService *playerService()
 {
     QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
-    if (flags) {
-        QMediaServiceProviderHint::Features features;
-        if (flags & QMediaPlayer::LowLatency)
-            features |= QMediaServiceProviderHint::LowLatencyPlayback;
-
-        if (flags & QMediaPlayer::StreamPlayback)
-            features |= QMediaServiceProviderHint::StreamPlayback;
-
-        if (flags & QMediaPlayer::VideoSurface)
-            features |= QMediaServiceProviderHint::VideoSurface;
-
-        return provider->requestService(Q_MEDIASERVICE_MEDIAPLAYER,
-                                        QMediaServiceProviderHint(features));
-    }
-
     return provider->requestService(Q_MEDIASERVICE_MEDIAPLAYER);
 }
 
@@ -582,9 +567,10 @@ static QMediaService *playerService(QMediaPlayer::Flags flags)
 QMediaPlayer::QMediaPlayer(QObject *parent, QMediaPlayer::Flags flags):
     QMediaObject(*new QMediaPlayerPrivate,
                  parent,
-                 playerService(flags))
+                 playerService())
 {
     Q_D(QMediaPlayer);
+    Q_UNUSED(flags);
 
     d->provider = QMediaServiceProvider::defaultServiceProvider();
     if (d->service == nullptr) {
@@ -617,7 +603,7 @@ QMediaPlayer::QMediaPlayer(QObject *parent, QMediaPlayer::Flags flags):
             if (d->status == StalledMedia || d->status == BufferingMedia)
                 addPropertyWatch("bufferStatus");
 
-            d->hasStreamPlaybackFeature = d->provider->supportedFeatures(d->service).testFlag(QMediaServiceProviderHint::StreamPlayback);
+            d->hasStreamPlaybackFeature = d->provider->supportedFeatures(d->service).testFlag(QMediaServiceFeaturesInterface::StreamPlayback);
         }
     }
 }
diff --git a/src/multimedia/qmediaserviceprovider.cpp b/src/multimedia/qmediaserviceprovider.cpp
index 4d6ce266b..775814a77 100644
--- a/src/multimedia/qmediaserviceprovider.cpp
+++ b/src/multimedia/qmediaserviceprovider.cpp
@@ -53,227 +53,6 @@ QMediaServiceProviderFactoryInterface::~QMediaServiceProviderFactoryInterface()
 {
 }
 
-class QMediaServiceProviderHintPrivate : public QSharedData
-{
-public:
-    QMediaServiceProviderHintPrivate(QMediaServiceProviderHint::Type type)
-        : type(type)
-    {
-    }
-
-    QMediaServiceProviderHintPrivate(const QMediaServiceProviderHintPrivate &other)
-        :QSharedData(other),
-        type(other.type),
-        device(other.device),
-        mimeType(other.mimeType),
-        codecs(other.codecs),
-        features(other.features)
-    {
-    }
-
-    ~QMediaServiceProviderHintPrivate()
-    {
-    }
-
-    QMediaServiceProviderHint::Type type;
-    QByteArray device;
-    QString mimeType;
-    QStringList codecs;
-    QMediaServiceProviderHint::Features features;
-};
-
-/*!
-    \class QMediaServiceProviderHint
-    \obsolete
-
-    \brief The QMediaServiceProviderHint class describes what is required of a QMediaService.
-
-    \inmodule QtMultimedia
-
-    \ingroup multimedia
-    \ingroup multimedia_control
-    \ingroup multimedia_core
-
-    \internal
-
-    The QMediaServiceProvider class uses hints to select an appropriate media service.
-*/
-
-/*!
-    \enum QMediaServiceProviderHint::Feature
-
-    Enumerates features a media service may provide.
-
-    \value LowLatencyPlayback
-            The service is expected to play simple audio formats,
-            but playback should start without significant delay.
-            Such playback service can be used for beeps, ringtones, etc.
-
-    \value RecordingSupport
-            The service provides audio or video recording functions.
-
-    \value StreamPlayback
-            The service is capable of playing QIODevice based streams.
-
-    \value VideoSurface
-            The service is capable of renderering to a QAbstractVideoSurface
-            output.
-*/
-
-/*!
-    \enum QMediaServiceProviderHint::Type
-
-    Enumerates the possible types of media service provider hint.
-
-    \value Null               En empty hint, use the default service.
-    \value ContentType        Select media service most suitable for certain content type.
-    \value Device             Select media service which supports certain device.
-    \value SupportedFeatures  Select media service supporting the set of optional features.
-    \value CameraPosition     Select media service having a camera at a specified position.
-*/
-
-
-/*!
-    Constructs an empty media service provider hint.
-*/
-QMediaServiceProviderHint::QMediaServiceProviderHint()
-    :d(new QMediaServiceProviderHintPrivate(Null))
-{
-}
-
-/*!
-    Constructs a ContentType media service provider hint.
-
-    This type of hint describes a service that is able to play content of a specific MIME \a type
-    encoded with one or more of the listed \a codecs.
-*/
-QMediaServiceProviderHint::QMediaServiceProviderHint(const QString &type, const QStringList& codecs)
-    :d(new QMediaServiceProviderHintPrivate(ContentType))
-{
-    d->mimeType = type;
-    d->codecs = codecs;
-}
-
-/*!
-  Constructs a Device media service provider hint.
-
-  This type of hint describes a media service that utilizes a specific \a device.
-*/
-QMediaServiceProviderHint::QMediaServiceProviderHint(const QByteArray &device)
-    :d(new QMediaServiceProviderHintPrivate(Device))
-{
-    d->device = device;
-}
-
-/*!
-    Constructs a SupportedFeatures media service provider hint.
-
-    This type of hint describes a service which supports a specific set of \a features.
-*/
-QMediaServiceProviderHint::QMediaServiceProviderHint(QMediaServiceProviderHint::Features features)
-    :d(new QMediaServiceProviderHintPrivate(SupportedFeatures))
-{
-    d->features = features;
-}
-
-/*!
-    Constructs a copy of the media service provider hint \a other.
-*/
-QMediaServiceProviderHint::QMediaServiceProviderHint(const QMediaServiceProviderHint &other)
-    :d(other.d)
-{
-}
-
-/*!
-    Destroys a media service provider hint.
-*/
-QMediaServiceProviderHint::~QMediaServiceProviderHint()
-{
-}
-
-/*!
-    Assigns the value \a other to a media service provider hint.
-*/
-QMediaServiceProviderHint& QMediaServiceProviderHint::operator=(const QMediaServiceProviderHint &other)
-{
-    d = other.d;
-    return *this;
-}
-
-/*!
-    Identifies if \a other is of equal value to a media service provider hint.
-
-    Returns true if the hints are equal, and false if they are not.
-*/
-bool QMediaServiceProviderHint::operator == (const QMediaServiceProviderHint &other) const
-{
-    return (d == other.d) ||
-           (d->type == other.d->type &&
-            d->device == other.d->device &&
-            d->mimeType == other.d->mimeType &&
-            d->codecs == other.d->codecs &&
-            d->features == other.d->features);
-}
-
-/*!
-    Identifies if \a other is not of equal value to a media service provider hint.
-
-    Returns true if the hints are not equal, and false if they are.
-*/
-bool QMediaServiceProviderHint::operator != (const QMediaServiceProviderHint &other) const
-{
-    return !(*this == other);
-}
-
-/*!
-    Returns true if a media service provider is null.
-*/
-bool QMediaServiceProviderHint::isNull() const
-{
-    return d->type == Null;
-}
-
-/*!
-    Returns the type of a media service provider hint.
-*/
-QMediaServiceProviderHint::Type QMediaServiceProviderHint::type() const
-{
-    return d->type;
-}
-
-/*!
-    Returns the mime type of the media a service is expected to be able play.
-*/
-QString QMediaServiceProviderHint::mimeType() const
-{
-    return d->mimeType;
-}
-
-/*!
-    Returns a list of codes a media service is expected to be able to decode.
-*/
-QStringList QMediaServiceProviderHint::codecs() const
-{
-    return d->codecs;
-}
-
-/*!
-    Returns the name of a device a media service is expected to utilize.
-*/
-QByteArray QMediaServiceProviderHint::device() const
-{
-    return d->device;
-}
-
-/*!
-    Returns a set of features a media service is expected to provide.
-*/
-QMediaServiceProviderHint::Features QMediaServiceProviderHint::features() const
-{
-    return d->features;
-}
-
-
 Q_GLOBAL_STATIC_WITH_ARGS(QMediaPluginLoader, loader,
         (QMediaServiceProviderFactoryInterface_iid, QLatin1String("mediaservice"), Qt::CaseInsensitive))
 
@@ -290,90 +69,20 @@ class QPluginServiceProvider : public QMediaServiceProvider
     QMap<const QMediaService*, MediaServiceData> mediaServiceData;
 
 public:
-    QMediaService* requestService(const QByteArray &type, const QMediaServiceProviderHint &hint) override
+    QMediaService* requestService(const QByteArray &type) override
     {
         QString key(QLatin1String(type.constData()));
 
         QList<QMediaServiceProviderPlugin *>plugins;
         const auto instances = loader()->instances(key);
         for (QObject *obj : instances) {
-            QMediaServiceProviderPlugin *plugin =
-                qobject_cast<QMediaServiceProviderPlugin*>(obj);
+            QMediaServiceProviderPlugin *plugin = qobject_cast<QMediaServiceProviderPlugin*>(obj);
             if (plugin)
                 plugins << plugin;
         }
 
         if (!plugins.isEmpty()) {
-            QMediaServiceProviderPlugin *plugin = nullptr;
-
-            switch (hint.type()) {
-            case QMediaServiceProviderHint::Null:
-                plugin = plugins[0];
-                //special case for media player, if low latency was not asked,
-                //prefer services not offering it, since they are likely to support
-                //more formats
-                if (type == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER)) {
-                    for (QMediaServiceProviderPlugin *currentPlugin : qAsConst(plugins)) {
-                        QMediaServiceFeaturesInterface *iface =
-                                qobject_cast<QMediaServiceFeaturesInterface*>(currentPlugin);
-
-                        if (!iface || !(iface->supportedFeatures(type) &
-                                        QMediaServiceProviderHint::LowLatencyPlayback)) {
-                            plugin = currentPlugin;
-                            break;
-                        }
-
-                    }
-                }
-                break;
-            case QMediaServiceProviderHint::SupportedFeatures:
-                plugin = plugins[0];
-                for (QMediaServiceProviderPlugin *currentPlugin : qAsConst(plugins)) {
-                    QMediaServiceFeaturesInterface *iface =
-                            qobject_cast<QMediaServiceFeaturesInterface*>(currentPlugin);
-
-                    if (iface) {
-                        if ((iface->supportedFeatures(type) & hint.features()) == hint.features()) {
-                            plugin = currentPlugin;
-                            break;
-                        }
-                    }
-                }
-                break;
-            case QMediaServiceProviderHint::Device: {
-                    plugin = plugins[0];
-                    for (QMediaServiceProviderPlugin *currentPlugin : qAsConst(plugins)) {
-                        QMediaServiceSupportedDevicesInterface *iface =
-                                qobject_cast<QMediaServiceSupportedDevicesInterface*>(currentPlugin);
-
-                        if (iface && iface->devices(type).contains(hint.device())) {
-                            plugin = currentPlugin;
-                            break;
-                        }
-                    }
-                }
-                break;
-            case QMediaServiceProviderHint::ContentType: {
-                    QMultimedia::SupportEstimate estimate = QMultimedia::NotSupported;
-                    for (QMediaServiceProviderPlugin *currentPlugin : qAsConst(plugins)) {
-                        QMultimedia::SupportEstimate currentEstimate = QMultimedia::MaybeSupported;
-                        QMediaServiceSupportedFormatsInterface *iface =
-                                qobject_cast<QMediaServiceSupportedFormatsInterface*>(currentPlugin);
-
-                        if (iface)
-                            currentEstimate = iface->hasSupport(hint.mimeType(), hint.codecs());
-
-                        if (currentEstimate > estimate) {
-                            estimate = currentEstimate;
-                            plugin = currentPlugin;
-
-                            if (currentEstimate == QMultimedia::PreferredService)
-                                break;
-                        }
-                    }
-                }
-                break;
-            }
+            QMediaServiceProviderPlugin *plugin = plugins[0];
 
             if (plugin != nullptr) {
                 QMediaService *service = plugin->create(key);
@@ -402,7 +111,7 @@ public:
         }
     }
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QMediaService *service) const override
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QMediaService *service) const override
     {
         if (service) {
             MediaServiceData d = mediaServiceData.value(service);
@@ -416,7 +125,7 @@ public:
             }
         }
 
-        return QMediaServiceProviderHint::Features();
+        return QMediaServiceFeaturesInterface::Features();
     }
 
     QMultimedia::SupportEstimate hasSupport(const QByteArray &serviceType,
@@ -442,17 +151,17 @@ public:
                         qobject_cast<QMediaServiceFeaturesInterface*>(obj);
 
                 if (iface) {
-                    QMediaServiceProviderHint::Features features = iface->supportedFeatures(serviceType);
+                    QMediaServiceFeaturesInterface::Features features = iface->supportedFeatures(serviceType);
 
                     //if low latency playback was asked, skip services known
                     //not to provide low latency playback
                     if ((flags & QMediaPlayer::LowLatency) &&
-                        !(features & QMediaServiceProviderHint::LowLatencyPlayback))
+                        !(features & QMediaServiceFeaturesInterface::LowLatencyPlayback))
                             continue;
 
                     //the same for QIODevice based streams support
                     if ((flags & QMediaPlayer::StreamPlayback) &&
-                        !(features & QMediaServiceProviderHint::StreamPlayback))
+                        !(features & QMediaServiceFeaturesInterface::StreamPlayback))
                             continue;
                 }
             }
@@ -490,22 +199,22 @@ public:
                         qobject_cast<QMediaServiceFeaturesInterface*>(obj);
 
                 if (iface) {
-                    QMediaServiceProviderHint::Features features = iface->supportedFeatures(serviceType);
+                    QMediaServiceFeaturesInterface::Features features = iface->supportedFeatures(serviceType);
 
                     // If low latency playback was asked for, skip MIME types from services known
                     // not to provide low latency playback
                     if ((flags & QMediaPlayer::LowLatency) &&
-                        !(features & QMediaServiceProviderHint::LowLatencyPlayback))
+                        !(features & QMediaServiceFeaturesInterface::LowLatencyPlayback))
                         continue;
 
                     //the same for QIODevice based streams support
                     if ((flags & QMediaPlayer::StreamPlayback) &&
-                        !(features & QMediaServiceProviderHint::StreamPlayback))
+                        !(features & QMediaServiceFeaturesInterface::StreamPlayback))
                             continue;
 
                     //the same for QAbstractVideoSurface support
                     if ((flags & QMediaPlayer::VideoSurface) &&
-                        !(features & QMediaServiceProviderHint::VideoSurface))
+                        !(features & QMediaServiceFeaturesInterface::VideoSurface))
                             continue;
                 }
             }
@@ -579,7 +288,7 @@ public:
 
     QCamera::Position cameraPosition(const QByteArray &device) const override
     {
-        QMediaService *service = const_cast<QPluginServiceProvider *>(this)->requestService(Q_MEDIASERVICE_CAMERA, QMediaServiceProviderHint());
+        QMediaService *service = const_cast<QPluginServiceProvider *>(this)->requestService(Q_MEDIASERVICE_CAMERA);
         auto *deviceControl = qobject_cast<QVideoDeviceSelectorControl *>(service->requestControl(QVideoDeviceSelectorControl_iid));
         auto pos = QCamera::UnspecifiedPosition;
         for (int i = 0; i < deviceControl->deviceCount(); i++) {
@@ -594,7 +303,7 @@ public:
 
     int cameraOrientation(const QByteArray &device) const override
     {
-        QMediaService *service = const_cast<QPluginServiceProvider *>(this)->requestService(Q_MEDIASERVICE_CAMERA, QMediaServiceProviderHint());
+        QMediaService *service = const_cast<QPluginServiceProvider *>(this)->requestService(Q_MEDIASERVICE_CAMERA);
         auto *deviceControl = qobject_cast<QVideoDeviceSelectorControl *>(service->requestControl(QVideoDeviceSelectorControl_iid));
         int orientation = 0;
         for (int i = 0; i < deviceControl->deviceCount(); i++) {
@@ -624,7 +333,7 @@ Q_GLOBAL_STATIC(QPluginServiceProvider, pluginProvider);
 
 /*!
     \internal
-    \fn QMediaServiceProvider::requestService(const QByteArray &type, const QMediaServiceProviderHint &hint)
+    \fn QMediaServiceProvider::requestService(const QByteArray &type)
 
     Requests an instance of a \a type service which best matches the given \a
     hint.
@@ -649,7 +358,7 @@ Q_GLOBAL_STATIC(QPluginServiceProvider, pluginProvider);
 
     Returns the features supported by a given \a service.
 */
-QMediaServiceProviderHint::Features QMediaServiceProvider::supportedFeatures(const QMediaService *service) const
+QMediaServiceFeaturesInterface::Features QMediaServiceProvider::supportedFeatures(const QMediaService *service) const
 {
     Q_UNUSED(service);
 
diff --git a/src/multimedia/qmediaserviceprovider_p.h b/src/multimedia/qmediaserviceprovider_p.h
index 4ca9c9e8f..a896bf4a2 100644
--- a/src/multimedia/qmediaserviceprovider_p.h
+++ b/src/multimedia/qmediaserviceprovider_p.h
@@ -67,10 +67,10 @@ class Q_MULTIMEDIA_EXPORT QMediaServiceProvider : public QObject
     Q_OBJECT
 
 public:
-    virtual QMediaService* requestService(const QByteArray &type, const QMediaServiceProviderHint &hint = QMediaServiceProviderHint()) = 0;
+    virtual QMediaService* requestService(const QByteArray &type) = 0;
     virtual void releaseService(QMediaService *service) = 0;
 
-    virtual QMediaServiceProviderHint::Features supportedFeatures(const QMediaService *service) const;
+    virtual QMediaServiceFeaturesInterface::Features supportedFeatures(const QMediaService *service) const;
 
     virtual QMultimedia::SupportEstimate hasSupport(const QByteArray &serviceType,
                                              const QString &mimeType,
diff --git a/src/multimedia/qmediaserviceproviderplugin.h b/src/multimedia/qmediaserviceproviderplugin.h
index ae278d6ba..3242ad7ad 100644
--- a/src/multimedia/qmediaserviceproviderplugin.h
+++ b/src/multimedia/qmediaserviceproviderplugin.h
@@ -57,51 +57,6 @@ class QString;
 
 class QMediaService;
 
-class QMediaServiceProviderHintPrivate;
-class Q_MULTIMEDIA_EXPORT QMediaServiceProviderHint
-{
-public:
-    enum Type { Null, ContentType, Device, SupportedFeatures };
-
-    enum Feature {
-        LowLatencyPlayback = 0x01,
-        RecordingSupport = 0x02,
-        StreamPlayback = 0x04,
-        VideoSurface = 0x08
-    };
-    Q_DECLARE_FLAGS(Features, Feature)
-
-    QMediaServiceProviderHint();
-    QMediaServiceProviderHint(const QString &mimeType, const QStringList& codecs);
-    QMediaServiceProviderHint(const QByteArray &device);
-    QMediaServiceProviderHint(Features features);
-    QMediaServiceProviderHint(const QMediaServiceProviderHint &other);
-    ~QMediaServiceProviderHint();
-
-    QMediaServiceProviderHint& operator=(const QMediaServiceProviderHint &other);
-
-    bool operator == (const QMediaServiceProviderHint &other) const;
-    bool operator != (const QMediaServiceProviderHint &other) const;
-
-    bool isNull() const;
-
-    Type type() const;
-
-    QString mimeType() const;
-    QStringList codecs() const;
-
-    QByteArray device() const;
-
-    Features features() const;
-
-    //to be extended, if necessary
-
-private:
-    QSharedDataPointer<QMediaServiceProviderHintPrivate> d;
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QMediaServiceProviderHint::Features)
-
 // Required for QDoc workaround
 class QString;
 
@@ -164,10 +119,19 @@ class QString;
 
 struct Q_MULTIMEDIA_EXPORT QMediaServiceFeaturesInterface
 {
+    enum Feature {
+        LowLatencyPlayback = 0x01,
+        RecordingSupport = 0x02,
+        StreamPlayback = 0x04,
+        VideoSurface = 0x08
+    };
+    Q_DECLARE_FLAGS(Features, Feature)
+
     virtual ~QMediaServiceFeaturesInterface() {}
-    virtual QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const = 0;
+    virtual QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const = 0;
 };
 
+Q_DECLARE_OPERATORS_FOR_FLAGS(QMediaServiceFeaturesInterface::Features)
 
 #define QMediaServiceFeaturesInterface_iid \
     "org.qt-project.qt.mediaservicefeatures/5.0"
diff --git a/src/plugins/android/src/qandroidmediaserviceplugin.cpp b/src/plugins/android/src/qandroidmediaserviceplugin.cpp
index c9b0d411f..e8bc20ec2 100644
--- a/src/plugins/android/src/qandroidmediaserviceplugin.cpp
+++ b/src/plugins/android/src/qandroidmediaserviceplugin.cpp
@@ -82,18 +82,18 @@ void QAndroidMediaServicePlugin::release(QMediaService *service)
     delete service;
 }
 
-QMediaServiceProviderHint::Features QAndroidMediaServicePlugin::supportedFeatures(const QByteArray &service) const
+QMediaServiceFeaturesInterface::Features QAndroidMediaServicePlugin::supportedFeatures(const QByteArray &service) const
 {
     if (service == Q_MEDIASERVICE_MEDIAPLAYER)
-        return QMediaServiceProviderHint::VideoSurface;
+        return QMediaServiceFeaturesInterface::VideoSurface;
 
     if (service == Q_MEDIASERVICE_CAMERA)
-        return QMediaServiceProviderHint::VideoSurface | QMediaServiceProviderHint::RecordingSupport;
+        return QMediaServiceFeaturesInterface::VideoSurface | QMediaServiceFeaturesInterface::RecordingSupport;
 
     if (service == Q_MEDIASERVICE_AUDIOSOURCE)
-        return QMediaServiceProviderHint::RecordingSupport;
+        return QMediaServiceFeaturesInterface::RecordingSupport;
 
-    return QMediaServiceProviderHint::Features();
+    return QMediaServiceFeaturesInterface::Features();
 }
 
 QByteArray QAndroidMediaServicePlugin::defaultDevice(const QByteArray &service) const
diff --git a/src/plugins/android/src/qandroidmediaserviceplugin.h b/src/plugins/android/src/qandroidmediaserviceplugin.h
index 74aa683ab..8fa4fb6af 100644
--- a/src/plugins/android/src/qandroidmediaserviceplugin.h
+++ b/src/plugins/android/src/qandroidmediaserviceplugin.h
@@ -64,7 +64,7 @@ public:
     QMediaService* create(QString const& key) override;
     void release(QMediaService *service) override;
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const override;
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const override;
 
     QByteArray defaultDevice(const QByteArray &service) const override;
     QList<QByteArray> devices(const QByteArray &service) const override;
diff --git a/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.h b/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.h
index e08f0f46e..5e4bd5376 100644
--- a/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.h
+++ b/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.h
@@ -62,7 +62,7 @@ public:
     QMediaService* create(QString const& key) override;
     void release(QMediaService *service) override;
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const override;
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const override;
     QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const override;
     QStringList supportedMimeTypes() const override;
 
diff --git a/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.mm b/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.mm
index 59b29a3d2..1216fc173 100644
--- a/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.mm
+++ b/src/plugins/avfoundation/mediaplayer/avfmediaplayerserviceplugin.mm
@@ -68,12 +68,12 @@ void AVFMediaPlayerServicePlugin::release(QMediaService *service)
     delete service;
 }
 
-QMediaServiceProviderHint::Features AVFMediaPlayerServicePlugin::supportedFeatures(const QByteArray &service) const
+QMediaServiceFeaturesInterface::Features AVFMediaPlayerServicePlugin::supportedFeatures(const QByteArray &service) const
 {
     if (service == Q_MEDIASERVICE_MEDIAPLAYER)
-        return QMediaServiceProviderHint::VideoSurface;
+        return QMediaServiceFeaturesInterface::VideoSurface;
     else
-        return QMediaServiceProviderHint::Features();
+        return QMediaServiceFeaturesInterface::Features();
 }
 
 QMultimedia::SupportEstimate AVFMediaPlayerServicePlugin::hasSupport(const QString &mimeType, const QStringList &codecs) const
diff --git a/src/plugins/gstreamer/camerabin/camerabinserviceplugin.cpp b/src/plugins/gstreamer/camerabin/camerabinserviceplugin.cpp
index 177e230b0..476cc2394 100644
--- a/src/plugins/gstreamer/camerabin/camerabinserviceplugin.cpp
+++ b/src/plugins/gstreamer/camerabin/camerabinserviceplugin.cpp
@@ -89,13 +89,13 @@ void CameraBinServicePlugin::release(QMediaService *service)
     delete service;
 }
 
-QMediaServiceProviderHint::Features CameraBinServicePlugin::supportedFeatures(
+QMediaServiceFeaturesInterface::Features CameraBinServicePlugin::supportedFeatures(
         const QByteArray &service) const
 {
     if (service == Q_MEDIASERVICE_CAMERA)
-        return QMediaServiceProviderHint::VideoSurface;
+        return QMediaServiceFeaturesInterface::VideoSurface;
 
-    return QMediaServiceProviderHint::Features();
+    return QMediaServiceFeaturesInterface::Features();
 }
 
 QByteArray CameraBinServicePlugin::defaultDevice(const QByteArray &service) const
diff --git a/src/plugins/gstreamer/camerabin/camerabinserviceplugin.h b/src/plugins/gstreamer/camerabin/camerabinserviceplugin.h
index e16a0d9cc..50eb52d45 100644
--- a/src/plugins/gstreamer/camerabin/camerabinserviceplugin.h
+++ b/src/plugins/gstreamer/camerabin/camerabinserviceplugin.h
@@ -66,7 +66,7 @@ public:
     QMediaService* create(const QString &key) override;
     void release(QMediaService *service) override;
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const override;
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const override;
 
     QByteArray defaultDevice(const QByteArray &service) const override;
     QList<QByteArray> devices(const QByteArray &service) const override;
diff --git a/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.cpp b/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.cpp
index 59302f1d2..03a599761 100644
--- a/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.cpp
+++ b/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.cpp
@@ -66,17 +66,17 @@ void QGstreamerPlayerServicePlugin::release(QMediaService *service)
     delete service;
 }
 
-QMediaServiceProviderHint::Features QGstreamerPlayerServicePlugin::supportedFeatures(
+QMediaServiceFeaturesInterface::Features QGstreamerPlayerServicePlugin::supportedFeatures(
         const QByteArray &service) const
 {
     if (service == Q_MEDIASERVICE_MEDIAPLAYER)
         return
 #if QT_CONFIG(gstreamer_app)
-                QMediaServiceProviderHint::StreamPlayback |
+                QMediaServiceFeaturesInterface::StreamPlayback |
 #endif
-                QMediaServiceProviderHint::VideoSurface;
+                QMediaServiceFeaturesInterface::VideoSurface;
     else
-        return QMediaServiceProviderHint::Features();
+        return QMediaServiceFeaturesInterface::Features();
 }
 
 QMultimedia::SupportEstimate QGstreamerPlayerServicePlugin::hasSupport(const QString &mimeType,
diff --git a/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.h b/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.h
index 71eece23e..6cc7a7007 100644
--- a/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.h
+++ b/src/plugins/gstreamer/mediaplayer/qgstreamerplayerserviceplugin.h
@@ -61,7 +61,7 @@ public:
     QMediaService* create(const QString &key) override;
     void release(QMediaService *service) override;
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const override;
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const override;
 
     QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList &codecs) const override;
     QStringList supportedMimeTypes() const override;
diff --git a/src/plugins/qnx/neutrinoserviceplugin.cpp b/src/plugins/qnx/neutrinoserviceplugin.cpp
index 842796c83..99d3fcc3d 100644
--- a/src/plugins/qnx/neutrinoserviceplugin.cpp
+++ b/src/plugins/qnx/neutrinoserviceplugin.cpp
@@ -59,10 +59,10 @@ void NeutrinoServicePlugin::release(QMediaService *service)
     delete service;
 }
 
-QMediaServiceProviderHint::Features NeutrinoServicePlugin::supportedFeatures(const QByteArray &service) const
+QMediaServiceFeaturesInterface::Features NeutrinoServicePlugin::supportedFeatures(const QByteArray &service) const
 {
     Q_UNUSED(service);
-    return QMediaServiceProviderHint::Features();
+    return QMediaServiceFeaturesInterface::Features();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/qnx/neutrinoserviceplugin.h b/src/plugins/qnx/neutrinoserviceplugin.h
index 62ed7f0bd..0a239f75c 100644
--- a/src/plugins/qnx/neutrinoserviceplugin.h
+++ b/src/plugins/qnx/neutrinoserviceplugin.h
@@ -55,7 +55,7 @@ public:
 
     QMediaService *create(const QString &key) override;
     void release(QMediaService *service) override;
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const override;
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const override;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/wmf/wmfserviceplugin.cpp b/src/plugins/wmf/wmfserviceplugin.cpp
index 740067600..3e48cab2f 100644
--- a/src/plugins/wmf/wmfserviceplugin.cpp
+++ b/src/plugins/wmf/wmfserviceplugin.cpp
@@ -91,13 +91,13 @@ void WMFServicePlugin::release(QMediaService *service)
     releaseRefCount();
 }
 
-QMediaServiceProviderHint::Features WMFServicePlugin::supportedFeatures(
+QMediaServiceFeaturesInterface::Features WMFServicePlugin::supportedFeatures(
         const QByteArray &service) const
 {
     if (service == Q_MEDIASERVICE_MEDIAPLAYER)
-        return QMediaServiceProviderHint::StreamPlayback;
+        return QMediaServiceFeaturesInterface::StreamPlayback;
     else
-        return QMediaServiceProviderHint::Features();
+        return QMediaServiceFeaturesInterface::Features();
 }
 
 QByteArray WMFServicePlugin::defaultDevice(const QByteArray &) const
diff --git a/src/plugins/wmf/wmfserviceplugin.h b/src/plugins/wmf/wmfserviceplugin.h
index 493a0b08c..28afbf942 100644
--- a/src/plugins/wmf/wmfserviceplugin.h
+++ b/src/plugins/wmf/wmfserviceplugin.h
@@ -61,7 +61,7 @@ public:
     QMediaService* create(QString const& key);
     void release(QMediaService *service);
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const;
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const;
 
     QByteArray defaultDevice(const QByteArray &service) const;
     QList<QByteArray> devices(const QByteArray &service) const;
diff --git a/tests/auto/unit/qdeclarativeaudio/tst_qdeclarativeaudio.cpp b/tests/auto/unit/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
index b6c2cf1b0..ea1b37d4d 100644
--- a/tests/auto/unit/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
+++ b/tests/auto/unit/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
@@ -276,9 +276,7 @@ public:
         setDefaultServiceProvider(0);
     }
 
-    QMediaService *requestService(
-            const QByteArray &type,
-            const QMediaServiceProviderHint & = QMediaServiceProviderHint())
+    QMediaService *requestService(const QByteArray &type)
     {
         requestedService = type;
 
diff --git a/tests/auto/unit/qdeclarativevideo/tst_qdeclarativevideo.cpp b/tests/auto/unit/qdeclarativevideo/tst_qdeclarativevideo.cpp
index e90f58388..547768e3b 100644
--- a/tests/auto/unit/qdeclarativevideo/tst_qdeclarativevideo.cpp
+++ b/tests/auto/unit/qdeclarativevideo/tst_qdeclarativevideo.cpp
@@ -309,9 +309,7 @@ public:
         setDefaultServiceProvider(0);
     }
 
-    QMediaService *requestService(
-            const QByteArray &type,
-            const QMediaServiceProviderHint & = QMediaServiceProviderHint())
+    QMediaService *requestService(const QByteArray &type)
     {
         requestedService = type;
 
diff --git a/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp b/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
index 0dcdcd1cc..57a010528 100644
--- a/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
+++ b/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
@@ -121,7 +121,6 @@ private slots:
     void testSetVideoOutputDestruction();
     void testPositionPropertyWatch();
     void debugEnums();
-    void testPlayerFlags();
     void testDestructor();
     void testSupportedMimeTypes();
     void testQrc_data();
@@ -994,54 +993,6 @@ void tst_QMediaPlayer::testPlaylist()
     delete playlist2;
 }
 
-void tst_QMediaPlayer::testPlayerFlags()
-{
-    MockMediaServiceProvider provider(0, true);
-    QMediaPlayer::Flag flags = QMediaPlayer::LowLatency;
-
-    QMediaServiceProviderHint::Feature feature;
-
-    if (flags & QMediaPlayer::LowLatency)
-    {
-        /* if the flag is low latency set the low latency play back for the service provider */
-        feature = QMediaServiceProviderHint::LowLatencyPlayback;
-        const QByteArray service(Q_MEDIASERVICE_MEDIAPLAYER);
-        const QMediaServiceProviderHint providerHint(feature);
-        /* request service for the service provider */
-        provider.requestService(service,providerHint);
-
-        /* Constructs a SupportedFeatures  media service provider hint. */
-        QMediaServiceProviderHint servicepro(feature);
-
-        /* compare the flag value */
-        QVERIFY(servicepro.features() == QMediaServiceProviderHint::LowLatencyPlayback);
-    }
-
-    /* The player is expected to play QIODevice based streams.
-        If passed to QMediaPlayer  constructor,
-        the service supporting streams playback will be chosen. */
-    flags = QMediaPlayer::StreamPlayback;
-    /* Construct a QMediaPlayer  that uses the playback service from provider,
-        parented to parent  and with flags.*/
-
-    if (flags & QMediaPlayer::StreamPlayback)
-    {
-        /* if the flag is stream play back set the stream play back for the service provider */
-        feature = QMediaServiceProviderHint::StreamPlayback;
-        const QByteArray service(Q_MEDIASERVICE_MEDIAPLAYER);
-        const QMediaServiceProviderHint providerHint(feature);
-
-        /* request service for the service provider */
-        provider.requestService(service,providerHint);
-
-        /* Constructs a SupportedFeatures media service provider hint. */
-        QMediaServiceProviderHint servicepro(feature);
-
-        /* compare the flag value */
-        QVERIFY(servicepro.features() == QMediaServiceProviderHint::StreamPlayback);
-    }
-}
-
 void tst_QMediaPlayer::testDestructor()
 {
     //don't use the same service as tst_QMediaPlayer::player
@@ -1231,7 +1182,7 @@ void tst_QMediaPlayer::testQrc()
     QFETCH(bool, backendHasStream);
 
     if (hasStreamFeature)
-        mockProvider->setSupportedFeatures(QMediaServiceProviderHint::StreamPlayback);
+        mockProvider->setSupportedFeatures(QMediaServiceFeaturesInterface::StreamPlayback);
 
     QMediaPlayer player;
 
diff --git a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
index b44c704f4..f0567e82d 100644
--- a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
@@ -72,11 +72,11 @@ public:
         return QStringList("audio/wav");
     }
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const
     {
-        QMediaServiceProviderHint::Features result;
+        QMediaServiceFeaturesInterface::Features result;
         if (service == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER))
-            result |= QMediaServiceProviderHint::LowLatencyPlayback;
+            result |= QMediaServiceFeaturesInterface::LowLatencyPlayback;
         return result;
     }
 };
diff --git a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
index 6a7725fee..f7d3c526e 100644
--- a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
@@ -73,11 +73,11 @@ public:
         return QStringList() << "video/mp4" << "video/quicktime";
     }
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QByteArray &service) const
     {
-        QMediaServiceProviderHint::Features result;
+        QMediaServiceFeaturesInterface::Features result;
         if (service == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER))
-            result |= QMediaServiceProviderHint::StreamPlayback;
+            result |= QMediaServiceFeaturesInterface::StreamPlayback;
         return result;
     }
 };
diff --git a/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp b/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
index f461e710b..aa53488be 100644
--- a/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
@@ -46,7 +46,7 @@ QT_USE_NAMESPACE
 
 class MockMediaServiceProvider : public QMediaServiceProvider
 {
-    QMediaService* requestService(const QByteArray &type, const QMediaServiceProviderHint &)
+    QMediaService* requestService(const QByteArray &type)
     {
         Q_UNUSED(type);
         return 0;
@@ -71,7 +71,6 @@ private slots:
     void testObtainService();
     void testHasSupport();
     void testSupportedMimeTypes();
-    void testProviderHints();
     void testDefaultDevice();
     void testAvailableDevices();
     void testCameraInfo();
@@ -182,89 +181,6 @@ void tst_QMediaServiceProvider::testSupportedMimeTypes()
     QVERIFY(!provider->supportedMimeTypes(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER)).contains("audio/mp3"));
 }
 
-void tst_QMediaServiceProvider::testProviderHints()
-{
-    {
-        QMediaServiceProviderHint hint;
-        QVERIFY(hint.isNull());
-        QCOMPARE(hint.type(), QMediaServiceProviderHint::Null);
-        QVERIFY(hint.device().isEmpty());
-        QVERIFY(hint.mimeType().isEmpty());
-        QVERIFY(hint.codecs().isEmpty());
-        QCOMPARE(hint.features(), 0);
-    }
-
-    {
-        QByteArray deviceName(QByteArray("testDevice"));
-        QMediaServiceProviderHint hint(deviceName);
-        QVERIFY(!hint.isNull());
-        QCOMPARE(hint.type(), QMediaServiceProviderHint::Device);
-        QCOMPARE(hint.device(), deviceName);
-        QVERIFY(hint.mimeType().isEmpty());
-        QVERIFY(hint.codecs().isEmpty());
-        QCOMPARE(hint.features(), 0);
-    }
-
-    {
-        QMediaServiceProviderHint hint(QMediaServiceProviderHint::LowLatencyPlayback);
-        QVERIFY(!hint.isNull());
-        QCOMPARE(hint.type(), QMediaServiceProviderHint::SupportedFeatures);
-        QVERIFY(hint.device().isEmpty());
-        QVERIFY(hint.mimeType().isEmpty());
-        QVERIFY(hint.codecs().isEmpty());
-        QCOMPARE(hint.features(), QMediaServiceProviderHint::LowLatencyPlayback);
-    }
-
-    {
-        QMediaServiceProviderHint hint(QMediaServiceProviderHint::RecordingSupport);
-        QVERIFY(!hint.isNull());
-        QCOMPARE(hint.type(), QMediaServiceProviderHint::SupportedFeatures);
-        QVERIFY(hint.device().isEmpty());
-        QVERIFY(hint.mimeType().isEmpty());
-        QVERIFY(hint.codecs().isEmpty());
-        QCOMPARE(hint.features(), QMediaServiceProviderHint::RecordingSupport);
-    }
-
-    {
-        QString mimeType(QLatin1String("video/ogg"));
-        QStringList codecs;
-        codecs << "theora" << "vorbis";
-
-        QMediaServiceProviderHint hint(mimeType,codecs);
-        QVERIFY(!hint.isNull());
-        QCOMPARE(hint.type(), QMediaServiceProviderHint::ContentType);
-        QVERIFY(hint.device().isEmpty());
-        QCOMPARE(hint.mimeType(), mimeType);
-        QCOMPARE(hint.codecs(), codecs);
-
-        QMediaServiceProviderHint hint2(hint);
-
-        QVERIFY(!hint2.isNull());
-        QCOMPARE(hint2.type(), QMediaServiceProviderHint::ContentType);
-        QVERIFY(hint2.device().isEmpty());
-        QCOMPARE(hint2.mimeType(), mimeType);
-        QCOMPARE(hint2.codecs(), codecs);
-
-        QMediaServiceProviderHint hint3;
-        QVERIFY(hint3.isNull());
-        hint3 = hint;
-        QVERIFY(!hint3.isNull());
-        QCOMPARE(hint3.type(), QMediaServiceProviderHint::ContentType);
-        QVERIFY(hint3.device().isEmpty());
-        QCOMPARE(hint3.mimeType(), mimeType);
-        QCOMPARE(hint3.codecs(), codecs);
-
-        QCOMPARE(hint, hint2);
-        QCOMPARE(hint3, hint2);
-
-        QMediaServiceProviderHint hint4(mimeType,codecs);
-        QCOMPARE(hint, hint4);
-
-        QMediaServiceProviderHint hint5(mimeType,QStringList());
-        QVERIFY(hint != hint5);
-    }
-}
-
 void tst_QMediaServiceProvider::testDefaultDevice()
 {
     QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
diff --git a/tests/auto/unit/qmultimedia_common/mockmediaserviceprovider.h b/tests/auto/unit/qmultimedia_common/mockmediaserviceprovider.h
index f533e03f6..7be88a9fa 100644
--- a/tests/auto/unit/qmultimedia_common/mockmediaserviceprovider.h
+++ b/tests/auto/unit/qmultimedia_common/mockmediaserviceprovider.h
@@ -42,7 +42,7 @@ public:
     {
     }
 
-    QMediaService *requestService(const QByteArray &, const QMediaServiceProviderHint &)
+    QMediaService *requestService(const QByteArray &)
     {
         return service;
     }
@@ -55,12 +55,12 @@ public:
         }
     }
 
-    QMediaServiceProviderHint::Features supportedFeatures(const QMediaService *) const
+    QMediaServiceFeaturesInterface::Features supportedFeatures(const QMediaService *) const
     {
         return features;
     }
 
-    void setSupportedFeatures(QMediaServiceProviderHint::Features f)
+    void setSupportedFeatures(QMediaServiceFeaturesInterface::Features f)
     {
         features = f;
     }
@@ -91,7 +91,7 @@ public:
 
     QMediaService *service;
     bool deleteServiceOnRelease;
-    QMediaServiceProviderHint::Features features;
+    QMediaServiceFeaturesInterface::Features features;
 };
 
 #endif // MOCKMEDIASERVICEPROVIDER_H