Android: Rename the wrapper classes

Change-Id: I2ce15c8475da3186f128ba59b7c58f9b5b0a67e1
Reviewed-by: Yoann Lopes <yoann.lopes@digia.com>

4 files changed, 101 insertions, 101 deletions

diff --git a/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.cpp b/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.cpp
index 68fb5e473..2d49e78b1 100644
--- a/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.cpp
+++ b/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.cpp
@@ -40,14 +40,14 @@
 ****************************************************************************/
 
 #include "qandroidmediaplayercontrol.h"
-#include "jmediaplayer.h"
+#include "androidmediaplayer.h"
 #include "qandroidvideooutput.h"
 
 QT_BEGIN_NAMESPACE
 
 QAndroidMediaPlayerControl::QAndroidMediaPlayerControl(QObject *parent)
     : QMediaPlayerControl(parent),
-      mMediaPlayer(new JMediaPlayer),
+      mMediaPlayer(new AndroidMediaPlayer),
       mCurrentState(QMediaPlayer::StoppedState),
       mCurrentMediaStatus(QMediaPlayer::NoMedia),
       mMediaStream(0),
@@ -58,7 +58,7 @@ QAndroidMediaPlayerControl::QAndroidMediaPlayerControl(QObject *parent)
       mAudioAvailable(false),
       mVideoAvailable(false),
       mBuffering(false),
-      mState(JMediaPlayer::Uninitialized),
+      mState(AndroidMediaPlayer::Uninitialized),
       mPendingState(-1),
       mPendingPosition(-1),
       mPendingSetMedia(false),
@@ -99,11 +99,11 @@ QMediaPlayer::MediaStatus QAndroidMediaPlayerControl::mediaStatus() const
 
 qint64 QAndroidMediaPlayerControl::duration() const
 {
-    if ((mState & (JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::Stopped
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::Stopped
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
         return 0;
     }
 
@@ -115,13 +115,13 @@ qint64 QAndroidMediaPlayerControl::position() const
     if (mCurrentMediaStatus == QMediaPlayer::EndOfMedia)
         return duration();
 
-    if ((mState & (JMediaPlayer::Idle
-                   | JMediaPlayer::Initialized
-                   | JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::Stopped
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Idle
+                   | AndroidMediaPlayer::Initialized
+                   | AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::Stopped
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
          return (mPendingPosition == -1) ? 0 : mPendingPosition;
     }
 
@@ -135,10 +135,10 @@ void QAndroidMediaPlayerControl::setPosition(qint64 position)
 
     const int seekPosition = (position > INT_MAX) ? INT_MAX : position;
 
-    if ((mState & (JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
         if (mPendingPosition != seekPosition) {
             mPendingPosition = seekPosition;
             Q_EMIT positionChanged(seekPosition);
@@ -165,13 +165,13 @@ int QAndroidMediaPlayerControl::volume() const
 
 void QAndroidMediaPlayerControl::setVolume(int volume)
 {
-    if ((mState & (JMediaPlayer::Idle
-                   | JMediaPlayer::Initialized
-                   | JMediaPlayer::Stopped
-                   | JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Idle
+                   | AndroidMediaPlayer::Initialized
+                   | AndroidMediaPlayer::Stopped
+                   | AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
         if (mPendingVolume != volume) {
             mPendingVolume = volume;
             Q_EMIT volumeChanged(volume);
@@ -196,13 +196,13 @@ bool QAndroidMediaPlayerControl::isMuted() const
 
 void QAndroidMediaPlayerControl::setMuted(bool muted)
 {
-    if ((mState & (JMediaPlayer::Idle
-                   | JMediaPlayer::Initialized
-                   | JMediaPlayer::Stopped
-                   | JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Idle
+                   | AndroidMediaPlayer::Initialized
+                   | AndroidMediaPlayer::Stopped
+                   | AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
         if (mPendingMute != muted) {
             mPendingMute = muted;
             Q_EMIT mutedChanged(muted);
@@ -291,7 +291,7 @@ void QAndroidMediaPlayerControl::setMedia(const QMediaContent &mediaContent,
     }
 
     // Release the mediaplayer if it's not in in Idle or Uninitialized state
-    if ((mState & (JMediaPlayer::Idle | JMediaPlayer::Uninitialized)) == 0)
+    if ((mState & (AndroidMediaPlayer::Idle | AndroidMediaPlayer::Uninitialized)) == 0)
         mMediaPlayer->release();
 
     if (mediaContent.isNull()) {
@@ -353,16 +353,16 @@ void QAndroidMediaPlayerControl::setVideoOutput(QObject *videoOutput)
 void QAndroidMediaPlayerControl::play()
 {
     // We need to prepare the mediaplayer again.
-    if ((mState & JMediaPlayer::Stopped) && !mMediaContent.isNull()) {
+    if ((mState & AndroidMediaPlayer::Stopped) && !mMediaContent.isNull()) {
         setMedia(mMediaContent, mMediaStream);
     }
 
     setState(QMediaPlayer::PlayingState);
 
-    if ((mState & (JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
         mPendingState = QMediaPlayer::PlayingState;
         return;
     }
@@ -374,9 +374,9 @@ void QAndroidMediaPlayerControl::pause()
 {
     setState(QMediaPlayer::PausedState);
 
-    if ((mState & (JMediaPlayer::Started
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
+    if ((mState & (AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
         mPendingState = QMediaPlayer::PausedState;
         return;
     }
@@ -388,12 +388,12 @@ void QAndroidMediaPlayerControl::stop()
 {
     setState(QMediaPlayer::StoppedState);
 
-    if ((mState & (JMediaPlayer::Prepared
-                   | JMediaPlayer::Started
-                   | JMediaPlayer::Stopped
-                   | JMediaPlayer::Paused
-                   | JMediaPlayer::PlaybackCompleted)) == 0) {
-        if ((mState & (JMediaPlayer::Idle | JMediaPlayer::Uninitialized | JMediaPlayer::Error)) == 0)
+    if ((mState & (AndroidMediaPlayer::Prepared
+                   | AndroidMediaPlayer::Started
+                   | AndroidMediaPlayer::Stopped
+                   | AndroidMediaPlayer::Paused
+                   | AndroidMediaPlayer::PlaybackCompleted)) == 0) {
+        if ((mState & (AndroidMediaPlayer::Idle | AndroidMediaPlayer::Uninitialized | AndroidMediaPlayer::Error)) == 0)
             mPendingState = QMediaPlayer::StoppedState;
         return;
     }
@@ -405,28 +405,28 @@ void QAndroidMediaPlayerControl::onInfo(qint32 what, qint32 extra)
 {
     Q_UNUSED(extra);
     switch (what) {
-    case JMediaPlayer::MEDIA_INFO_UNKNOWN:
+    case AndroidMediaPlayer::MEDIA_INFO_UNKNOWN:
         break;
-    case JMediaPlayer::MEDIA_INFO_VIDEO_TRACK_LAGGING:
+    case AndroidMediaPlayer::MEDIA_INFO_VIDEO_TRACK_LAGGING:
         // IGNORE
         break;
-    case JMediaPlayer::MEDIA_INFO_VIDEO_RENDERING_START:
+    case AndroidMediaPlayer::MEDIA_INFO_VIDEO_RENDERING_START:
         break;
-    case JMediaPlayer::MEDIA_INFO_BUFFERING_START:
+    case AndroidMediaPlayer::MEDIA_INFO_BUFFERING_START:
         mPendingState = mCurrentState;
         setState(QMediaPlayer::PausedState);
         setMediaStatus(QMediaPlayer::StalledMedia);
         break;
-    case JMediaPlayer::MEDIA_INFO_BUFFERING_END:
+    case AndroidMediaPlayer::MEDIA_INFO_BUFFERING_END:
         if (mCurrentState != QMediaPlayer::StoppedState)
             flushPendingStates();
         break;
-    case JMediaPlayer::MEDIA_INFO_BAD_INTERLEAVING:
+    case AndroidMediaPlayer::MEDIA_INFO_BAD_INTERLEAVING:
         break;
-    case JMediaPlayer::MEDIA_INFO_NOT_SEEKABLE:
+    case AndroidMediaPlayer::MEDIA_INFO_NOT_SEEKABLE:
         setSeekable(false);
         break;
-    case JMediaPlayer::MEDIA_INFO_METADATA_UPDATE:
+    case AndroidMediaPlayer::MEDIA_INFO_METADATA_UPDATE:
         Q_EMIT metaDataUpdated();
         break;
     }
@@ -438,44 +438,44 @@ void QAndroidMediaPlayerControl::onError(qint32 what, qint32 extra)
     QMediaPlayer::Error error = QMediaPlayer::ResourceError;
 
     switch (what) {
-    case JMediaPlayer::MEDIA_ERROR_UNKNOWN:
+    case AndroidMediaPlayer::MEDIA_ERROR_UNKNOWN:
         errorString = QLatin1String("Error:");
         break;
-    case JMediaPlayer::MEDIA_ERROR_SERVER_DIED:
+    case AndroidMediaPlayer::MEDIA_ERROR_SERVER_DIED:
         errorString = QLatin1String("Error: Server died");
         error = QMediaPlayer::ServiceMissingError;
         break;
-    case JMediaPlayer::MEDIA_ERROR_INVALID_STATE:
+    case AndroidMediaPlayer::MEDIA_ERROR_INVALID_STATE:
         errorString = QLatin1String("Error: Invalid state");
         error = QMediaPlayer::ServiceMissingError;
         break;
     }
 
     switch (extra) {
-    case JMediaPlayer::MEDIA_ERROR_IO: // Network OR file error
+    case AndroidMediaPlayer::MEDIA_ERROR_IO: // Network OR file error
         errorString += QLatin1String(" (I/O operation failed)");
         error = QMediaPlayer::NetworkError;
         setMediaStatus(QMediaPlayer::InvalidMedia);
         break;
-    case JMediaPlayer::MEDIA_ERROR_MALFORMED:
+    case AndroidMediaPlayer::MEDIA_ERROR_MALFORMED:
         errorString += QLatin1String(" (Malformed bitstream)");
         error = QMediaPlayer::FormatError;
         setMediaStatus(QMediaPlayer::InvalidMedia);
         break;
-    case JMediaPlayer::MEDIA_ERROR_UNSUPPORTED:
+    case AndroidMediaPlayer::MEDIA_ERROR_UNSUPPORTED:
         errorString += QLatin1String(" (Unsupported media)");
         error = QMediaPlayer::FormatError;
         setMediaStatus(QMediaPlayer::InvalidMedia);
         break;
-    case JMediaPlayer::MEDIA_ERROR_TIMED_OUT:
+    case AndroidMediaPlayer::MEDIA_ERROR_TIMED_OUT:
         errorString += QLatin1String(" (Timed out)");
         break;
-    case JMediaPlayer::MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
+    case AndroidMediaPlayer::MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
         errorString += QLatin1String(" (Unable to start progressive playback')");
         error = QMediaPlayer::FormatError;
         setMediaStatus(QMediaPlayer::InvalidMedia);
         break;
-    case JMediaPlayer::MEDIA_ERROR_BAD_THINGS_ARE_GOING_TO_HAPPEN:
+    case AndroidMediaPlayer::MEDIA_ERROR_BAD_THINGS_ARE_GOING_TO_HAPPEN:
         errorString += QLatin1String(" (Unknown error/Insufficient resources)");
         error = QMediaPlayer::ServiceMissingError;
         break;
@@ -512,21 +512,21 @@ void QAndroidMediaPlayerControl::onVideoSizeChanged(qint32 width, qint32 height)
 void QAndroidMediaPlayerControl::onStateChanged(qint32 state)
 {
     // If reloading, don't report state changes unless the new state is Prepared or Error.
-    if ((mState & JMediaPlayer::Stopped)
-        && (state & (JMediaPlayer::Prepared | JMediaPlayer::Error | JMediaPlayer::Uninitialized)) == 0) {
+    if ((mState & AndroidMediaPlayer::Stopped)
+        && (state & (AndroidMediaPlayer::Prepared | AndroidMediaPlayer::Error | AndroidMediaPlayer::Uninitialized)) == 0) {
         return;
     }
 
     mState = state;
     switch (mState) {
-    case JMediaPlayer::Idle:
+    case AndroidMediaPlayer::Idle:
         break;
-    case JMediaPlayer::Initialized:
+    case AndroidMediaPlayer::Initialized:
         break;
-    case JMediaPlayer::Preparing:
+    case AndroidMediaPlayer::Preparing:
         setMediaStatus(QMediaPlayer::LoadingMedia);
         break;
-    case JMediaPlayer::Prepared:
+    case AndroidMediaPlayer::Prepared:
         setMediaStatus(QMediaPlayer::LoadedMedia);
         if (mBuffering) {
             setMediaStatus(mBufferPercent == 100 ? QMediaPlayer::BufferedMedia
@@ -537,7 +537,7 @@ void QAndroidMediaPlayerControl::onStateChanged(qint32 state)
         setAudioAvailable(true);
         flushPendingStates();
         break;
-    case JMediaPlayer::Started:
+    case AndroidMediaPlayer::Started:
         setState(QMediaPlayer::PlayingState);
         if (mBuffering) {
             setMediaStatus(mBufferPercent == 100 ? QMediaPlayer::BufferedMedia
@@ -546,25 +546,25 @@ void QAndroidMediaPlayerControl::onStateChanged(qint32 state)
             setMediaStatus(QMediaPlayer::BufferedMedia);
         }
         break;
-    case JMediaPlayer::Paused:
+    case AndroidMediaPlayer::Paused:
         setState(QMediaPlayer::PausedState);
         break;
-    case JMediaPlayer::Error:
+    case AndroidMediaPlayer::Error:
         setState(QMediaPlayer::StoppedState);
         setMediaStatus(QMediaPlayer::UnknownMediaStatus);
         mMediaPlayer->release();
         break;
-    case JMediaPlayer::Stopped:
+    case AndroidMediaPlayer::Stopped:
         setState(QMediaPlayer::StoppedState);
         setMediaStatus(QMediaPlayer::LoadedMedia);
         setPosition(0);
         break;
-    case JMediaPlayer::PlaybackCompleted:
+    case AndroidMediaPlayer::PlaybackCompleted:
         setState(QMediaPlayer::StoppedState);
         setPosition(0);
         setMediaStatus(QMediaPlayer::EndOfMedia);
         break;
-    case JMediaPlayer::Uninitialized:
+    case AndroidMediaPlayer::Uninitialized:
         // reset some properties
         resetBufferingProgress();
         mPendingPosition = -1;
@@ -579,7 +579,7 @@ void QAndroidMediaPlayerControl::onStateChanged(qint32 state)
         break;
     }
 
-    if ((mState & (JMediaPlayer::Stopped | JMediaPlayer::Uninitialized)) != 0) {
+    if ((mState & (AndroidMediaPlayer::Stopped | AndroidMediaPlayer::Uninitialized)) != 0) {
         mMediaPlayer->setDisplay(0);
         if (mVideoOutput) {
             mVideoOutput->stop();
diff --git a/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.h b/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.h
index 27e6afc12..5744c11b8 100644
--- a/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.h
+++ b/src/plugins/android/src/mediaplayer/qandroidmediaplayercontrol.h
@@ -49,7 +49,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class JMediaPlayer;
+class AndroidMediaPlayer;
 class QAndroidVideoOutput;
 
 class QAndroidMediaPlayerControl : public QMediaPlayerControl
@@ -98,7 +98,7 @@ private Q_SLOTS:
     void onStateChanged(qint32 state);
 
 private:
-    JMediaPlayer *mMediaPlayer;
+    AndroidMediaPlayer *mMediaPlayer;
     QMediaPlayer::State mCurrentState;
     QMediaPlayer::MediaStatus mCurrentMediaStatus;
     QMediaContent mMediaContent;
diff --git a/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.cpp b/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.cpp
index dcc3dfbe0..82bd74997 100644
--- a/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.cpp
+++ b/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.cpp
@@ -41,7 +41,7 @@
 
 #include "qandroidmetadatareadercontrol.h"
 
-#include "jmediametadataretriever.h"
+#include "androidmediametadataretriever.h"
 #include <QtMultimedia/qmediametadata.h>
 #include <qsize.h>
 #include <QDate>
@@ -74,7 +74,7 @@ static const char* qt_ID3GenreNames[] =
 QAndroidMetaDataReaderControl::QAndroidMetaDataReaderControl(QObject *parent)
     : QMetaDataReaderControl(parent)
     , m_available(false)
-    , m_retriever(new JMediaMetadataRetriever)
+    , m_retriever(new AndroidMediaMetadataRetriever)
 {
 }
 
@@ -124,56 +124,56 @@ void QAndroidMetaDataReaderControl::updateData()
 
     if (!m_mediaContent.isNull()) {
         if (m_retriever->setDataSource(m_mediaContent.canonicalUrl())) {
-            QString mimeType = m_retriever->extractMetadata(JMediaMetadataRetriever::MimeType);
+            QString mimeType = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::MimeType);
             if (!mimeType.isNull())
                 m_metadata.insert(QMediaMetaData::MediaType, mimeType);
 
-            bool isVideo = !m_retriever->extractMetadata(JMediaMetadataRetriever::HasVideo).isNull()
+            bool isVideo = !m_retriever->extractMetadata(AndroidMediaMetadataRetriever::HasVideo).isNull()
                            || mimeType.startsWith(QStringLiteral("video"));
 
-            QString string = m_retriever->extractMetadata(JMediaMetadataRetriever::Album);
+            QString string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Album);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::AlbumTitle, string);
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::AlbumArtist);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::AlbumArtist);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::AlbumArtist, string);
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Artist);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Artist);
             if (!string.isNull()) {
                 m_metadata.insert(isVideo ? QMediaMetaData::LeadPerformer
                                           : QMediaMetaData::ContributingArtist,
                                   string.split('/', QString::SkipEmptyParts));
             }
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Author);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Author);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Author, string.split('/', QString::SkipEmptyParts));
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Bitrate);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Bitrate);
             if (!string.isNull()) {
                 m_metadata.insert(isVideo ? QMediaMetaData::VideoBitRate
                                           : QMediaMetaData::AudioBitRate,
                                   string.toInt());
             }
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::CDTrackNumber);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::CDTrackNumber);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::TrackNumber, string.toInt());
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Composer);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Composer);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Composer, string.split('/', QString::SkipEmptyParts));
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Date);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Date);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Date, QDateTime::fromString(string, QStringLiteral("yyyyMMddTHHmmss.zzzZ")).date());
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Duration);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Duration);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Duration, string.toLongLong());
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Genre);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Genre);
             if (!string.isNull()) {
                 // The genre can be returned as an ID3v2 id, get the name for it in that case
                 if (string.startsWith('(') && string.endsWith(')')) {
@@ -185,22 +185,22 @@ void QAndroidMetaDataReaderControl::updateData()
                 m_metadata.insert(QMediaMetaData::Genre, string);
             }
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Title);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Title);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Title, string);
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::VideoHeight);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::VideoHeight);
             if (!string.isNull()) {
                 int height = string.toInt();
-                int width = m_retriever->extractMetadata(JMediaMetadataRetriever::VideoWidth).toInt();
+                int width = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::VideoWidth).toInt();
                 m_metadata.insert(QMediaMetaData::Resolution, QSize(width, height));
             }
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Writer);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Writer);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Writer, string.split('/', QString::SkipEmptyParts));
 
-            string = m_retriever->extractMetadata(JMediaMetadataRetriever::Year);
+            string = m_retriever->extractMetadata(AndroidMediaMetadataRetriever::Year);
             if (!string.isNull())
                 m_metadata.insert(QMediaMetaData::Year, string.toInt());
         }
diff --git a/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.h b/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.h
index 7ea736ffd..67b92f1eb 100644
--- a/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.h
+++ b/src/plugins/android/src/mediaplayer/qandroidmetadatareadercontrol.h
@@ -47,7 +47,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class JMediaMetadataRetriever;
+class AndroidMediaMetadataRetriever;
 
 class QAndroidMetaDataReaderControl : public QMetaDataReaderControl
 {
@@ -72,7 +72,7 @@ private:
     bool m_available;
     QVariantMap m_metadata;
 
-    JMediaMetadataRetriever *m_retriever;
+    AndroidMediaMetadataRetriever *m_retriever;
 };
 
 QT_END_NAMESPACE