Merge lp:~phablet-team/qtubuntu-media/bg-playlist-fixes into lp:qtubuntu-media/stable

[Alfonso Sanchez-Beato]

Emit onPlaybackModeChanged (LP: #1510219).
Implements insertTrack() so that a client can move a track into a new position by first calling removeTrack().
Do proper clean-up when switching between playlist and playing a single
URI (LP: #1511029).

Emit onPlaybackModeChanged (LP: #1510219).
Implements insertTrack() so that a client can move a track into a new position by first calling removeTrack().
Do proper clean-up when switching between playlist and playing a single
URI (LP: #1511029).

[lp:~phablet-team/qtubuntu-media/bg-playlist-fixes]

92. By Alfonso Sanchez-Beato on 2015-11-02

Do proper clean-up when switching between playlist and playing a single
URI (LP: #1511029)

[Jim Hodapp (jhodapp)]

Looks good for the parts that you contributed Alfonso. We won't top approve this until we get all of the qtubuntu-media fixes into this branch and better tested together.

review: Approve (code)

[lp:~phablet-team/qtubuntu-media/bg-playlist-fixes]

93. By Alfonso Sanchez-Beato on 2015-11-04

Fix double connections to events and avoid some unnecessay DBus calls.

94. By Alfonso Sanchez-Beato on 2015-11-04

Revert change that caused forward button not to work

95. By Alfonso Sanchez-Beato on 2015-11-06

Add support for TrackListReset signal, which is now emitted instead of
one TrackRemoved per track when we call media-hub's Reset DBus call.

96. By Alfonso Sanchez-Beato on 2015-11-12

Update current track index after performing operations that alter the
track list.

[Jim Hodapp (jhodapp)]

A few comments inline below.

review: Needs Fixing (code)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Will address comments asap. Please see also comment below.

[lp:~phablet-team/qtubuntu-media/bg-playlist-fixes]

97. By Alfonso Sanchez-Beato on 2015-11-13

Address review comments

[Jim Hodapp (jhodapp)]

LGTM

review: Approve (code)

=== modified file 'src/aal/aalmediaplayercontrol.cpp'
--- src/aal/aalmediaplayercontrol.cpp	2015-08-18 15:48:31 +0000
+++ src/aal/aalmediaplayercontrol.cpp	2015-11-13 14:50:26 +0000
@@ -198,20 +198,27 @@
     qDebug() << __PRETTY_FUNCTION__ << endl;
 
     qDebug() << "setMedia() media: " << AalUtility::unescape(media);
+
+    if (m_mediaContent == media) {
+        qDebug() << "Same media as current";
+        return;
+    }
+
     m_mediaContent = media;
 
-    // Make sure we can actually load something valid
+    QMediaPlayer::MediaStatus priorStatus = mediaStatus();
+
     if (!media.isNull())
-    {
-        QMediaPlayer::MediaStatus priorStatus = mediaStatus();
         setMediaStatus(QMediaPlayer::LoadingMedia);
-        m_service->setMedia(AalUtility::unescape(media));
-        // This is important to do for QMediaPlaylist instances that
-        // are set to loop. Without this, such a playlist will only
-        // play once
-        if (priorStatus == QMediaPlayer::EndOfMedia)
-            stop();
-    }
+
+    // If there is no media this cleans up the play list
+    m_service->setMedia(AalUtility::unescape(media));
+
+    // This is important to do for QMediaPlaylist instances that
+    // are set to loop. Without this, such a playlist will only
+    // play once
+    if (priorStatus == QMediaPlayer::EndOfMedia)
+        stop();
 
     Q_EMIT mediaChanged(m_mediaContent);
 }
@@ -219,9 +226,11 @@
 void AalMediaPlayerControl::play()
 {
     qDebug() << __PRETTY_FUNCTION__ << endl;
+    m_service->play();
 
+    // FIXME: Why are these setState needed? State is changed also when signals
+    // from media-hub are received, which seems the right way to track it.
     setState(QMediaPlayer::PlayingState);
-    m_service->play();
 }
 
 void AalMediaPlayerControl::pause()

=== modified file 'src/aal/aalmediaplayerservice.cpp'
--- src/aal/aalmediaplayerservice.cpp	2015-10-23 14:46:14 +0000
+++ src/aal/aalmediaplayerservice.cpp	2015-11-13 14:50:26 +0000
@@ -278,11 +278,6 @@
         qWarning() << "Cannot open uri without a valid media-hub player session";
         return;
     }
-    if (url.isEmpty())
-    {
-        qWarning() << "Failed to set media source, url must be set." << endl;
-        return;
-    }
 
     // This is critical to allowing a different video source to be able to play correctly
     // if another video is already playing in the same AalMediaPlayerService instance
@@ -293,8 +288,12 @@
     }
 
     qDebug() << "Setting media to: " << url;
+
+    if (m_mediaPlaylistProvider && url.isEmpty())
+        m_mediaPlaylistProvider->clear();
+
     const media::Track::UriType uri(url.url().toStdString());
-    if (m_mediaPlaylistProvider == nullptr)
+    if (m_mediaPlaylistProvider == nullptr || m_mediaPlaylistProvider->mediaCount() == 0)
     {
         try {
             m_hubPlayerSession->open_uri(uri);

=== modified file 'src/aal/aalmediaplaylistcontrol.cpp'
--- src/aal/aalmediaplaylistcontrol.cpp	2015-08-11 15:45:59 +0000
+++ src/aal/aalmediaplaylistcontrol.cpp	2015-11-13 14:50:26 +0000
@@ -61,6 +61,7 @@
 bool AalMediaPlaylistControl::setPlaylistProvider(QMediaPlaylistProvider *playlist)
 {
     m_playlistProvider = playlist;
+    connect(playlist, SIGNAL(currentIndexChanged()), this, SLOT(onCurrentIndexChanged()));
     Q_EMIT playlistProviderChanged();
     return true;
 }
@@ -120,8 +121,8 @@
     //const int reducedSteps = steps - ((steps / tracklistSize) * tracklistSize);
     // Calculate how many of x are in tracklistSize to reduce the calculation
     // to only wrap around the list one time
+#ifdef VERBOSE_DEBUG
     const uint16_t m = (uint16_t)std::abs(x) / (uint16_t)tracklistSize; // 3
-#ifdef VERBOSE_DEBUG
     qDebug() << "m_currentIndex: " << m_currentIndex;
     qDebug() << "steps: " << steps;
     qDebug() << "tracklistSize: " << tracklistSize;
@@ -237,6 +238,8 @@
             qWarning() << "Unknown playback mode: " << mode;
             m_hubPlayerSession->shuffle() = false;
     }
+
+    Q_EMIT playbackModeChanged(mode);
 }
 
 void AalMediaPlaylistControl::setPlayerSession(const std::shared_ptr<core::ubuntu::media::Player>& playerSession)
@@ -259,6 +262,7 @@
     if (!id.empty())
     {
         m_currentIndex = aalMediaPlaylistProvider()->indexOfTrack(id);
+        m_currentId = id;
         qDebug() << "m_currentIndex updated to: " << m_currentIndex;
         const QMediaContent content = playlistProvider()->media(m_currentIndex);
         Q_EMIT currentMediaChanged(content);
@@ -266,8 +270,22 @@
     }
 }
 
+void AalMediaPlaylistControl::onCurrentIndexChanged()
+{
+    int index = aalMediaPlaylistProvider()->indexOfTrack(m_currentId);
+
+    if (index != m_currentIndex) {
+        qDebug() << "Index changed to " << index;
+        m_currentIndex = index;
+        Q_EMIT currentIndexChanged(m_currentIndex);
+    }
+}
+
 void AalMediaPlaylistControl::connect_signals()
 {
+    // Avoid duplicated subscriptions
+    disconnect_signals();
+
     if (!m_hubTrackList) {
         qWarning() << "Can't connect to track list signals as it doesn't exist";
         return;

=== modified file 'src/aal/aalmediaplaylistcontrol.h'
--- src/aal/aalmediaplaylistcontrol.h	2015-07-24 18:29:42 +0000
+++ src/aal/aalmediaplaylistcontrol.h	2015-11-13 14:50:26 +0000
@@ -62,6 +62,7 @@
 
 private Q_SLOTS:
     void onTrackChanged(const core::ubuntu::media::Track::Id& id);
+    void onCurrentIndexChanged();
 
 private:
     void connect_signals();
@@ -73,6 +74,7 @@
     QMediaPlaylistProvider *m_playlistProvider;
 
     int m_currentIndex;
+    core::ubuntu::media::Track::Id m_currentId;
 
     core::Connection m_trackChangedConnection;
 };

=== modified file 'src/aal/aalmediaplaylistprovider.cpp'
--- src/aal/aalmediaplaylistprovider.cpp	2015-10-23 15:08:10 +0000
+++ src/aal/aalmediaplaylistprovider.cpp	2015-11-13 14:50:26 +0000
@@ -36,7 +36,9 @@
     : QMediaPlaylistProvider(parent),
       m_trackAddedConnection(the_void.connect([](){})),
       m_tracksAddedConnection(the_void.connect([](){})),
-      m_trackRemovedConnection(the_void.connect([](){}))
+      m_trackRemovedConnection(the_void.connect([](){})),
+      m_trackListResetConnection(the_void.connect([](){})),
+      m_insertTrackIndex(-1)
 {
     qDebug() << Q_FUNC_INFO;
     qRegisterMetaType<core::ubuntu::media::Track::Id>();
@@ -50,7 +52,6 @@
 
 int AalMediaPlaylistProvider::mediaCount() const
 {
-    qDebug() << Q_FUNC_INFO;
     if (!m_hubTrackList) {
         qWarning() << "Tracklist doesn't exist";
         return 0;
@@ -99,6 +100,8 @@
 
 bool AalMediaPlaylistProvider::addMedia(const QMediaContent &content)
 {
+    qDebug() << Q_FUNC_INFO;
+
     if (!m_hubTrackList) {
         qWarning() << "Track list does not exist so can't add a new track";
         return false;
@@ -115,6 +118,7 @@
     const int newIndex = track_index_lut.size();
     Q_EMIT mediaAboutToBeInserted(newIndex, newIndex);
     try {
+        qDebug() << "Adding track " << urlStr.c_str();
         m_hubTrackList->add_track_with_uri_at(urlStr, after_empty_track, make_current);
     }
     catch (const media::TrackList::Errors::InsufficientPermissionsToAddTrack &e)
@@ -132,6 +136,8 @@
 
 bool AalMediaPlaylistProvider::addMedia(const QList<QMediaContent> &contentList)
 {
+    qDebug() << Q_FUNC_INFO << " num " << contentList.size();
+
     if (contentList.empty())
         return false;
 
@@ -141,8 +147,10 @@
     }
 
     media::TrackList::ContainerURI uris;
-    for (const auto mediaContent : contentList)
+    for (const auto mediaContent : contentList) {
+        qDebug() << "Adding track " << AalUtility::unescape(mediaContent).toString();
         uris.push_back(AalUtility::unescape_str(mediaContent));
+    }
 
     const media::Track::Id after_empty_track = media::TrackList::after_empty_track();
     const int newIndex = track_index_lut.size();
@@ -165,12 +173,52 @@
 
 bool AalMediaPlaylistProvider::insertMedia(int index, const QMediaContent &content)
 {
-    (void) index;
-    (void) content;
-
-    qWarning() << Q_FUNC_INFO << " - Not yet implemented";
-
-    return false;
+    if (!m_hubTrackList) {
+        qWarning() << "Track list does not exist so can't add a new track";
+        return false;
+    }
+
+    if (index < 0 or index >= static_cast<int>(track_index_lut.size())) {
+        qWarning() << Q_FUNC_INFO << "index is out of valid range";
+        return false;
+    }
+
+    const QUrl url = content.canonicalUrl();
+    std::string urlStr = AalUtility::unescape_str(content);
+    if (url.scheme().isEmpty() and url.scheme() != "file")
+        urlStr = "file://" + urlStr;
+
+    const media::Track::Id after_this_track = trackOfIndex(index);
+    if (after_this_track.empty()) {
+        qWarning() << Q_FUNC_INFO
+            << "failed to insertMedia due to failure to look up correct insertion position";
+        return false;
+    }
+
+    qDebug() << "after_this_track:" << after_this_track.c_str();
+
+    static const bool make_current = false;
+    const int newIndex = index + 1;
+    if (newIndex >= static_cast<int>(track_index_lut.size())) {
+        qWarning() << Q_FUNC_INFO << "newIndex is greater than track_index_lut.size()";
+        return false;
+    }
+    Q_EMIT mediaAboutToBeInserted(newIndex, newIndex);
+    m_insertTrackIndex = newIndex;
+    try {
+        m_hubTrackList->add_track_with_uri_at(urlStr, after_this_track, make_current);
+    }
+    catch (const media::TrackList::Errors::InsufficientPermissionsToAddTrack &e)
+    {
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString() << "' to playlist: " << e.what();
+        return false;
+    }
+    catch (const std::runtime_error &e) {
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString() << "' to playlist: " << e.what();
+        return false;
+    }
+
+    return true;
 }
 
 bool AalMediaPlaylistProvider::insertMedia(int index, const QList<QMediaContent> &content)
@@ -228,6 +276,19 @@
 
     try {
         m_hubTrackList->reset();
+
+        // We do not wait for the TrackListReset signal to empty the lut to
+        // avoid sync problems.
+        // TODO: Do the same in other calls if possible, as these calls are
+        // considered to be synchronous, and the job can be considered finished
+        // when the DBus call returns without error. If we need some information
+        // from the signal we should block until it arrives.
+        int num_tracks = track_index_lut.size();
+        if (num_tracks > 0) {
+            Q_EMIT mediaAboutToBeRemoved(0, num_tracks - 1);
+            track_index_lut.clear();
+            Q_EMIT mediaRemoved(0, num_tracks - 1);
+        }
     }
     catch (const std::runtime_error &e) {
         qWarning() << "Failed to clear the playlist: " << e.what();
@@ -248,6 +309,8 @@
         qWarning() << "FATAL: Failed to retrieve the current player session TrackList: " << e.what();
     }
 
+    /* Disconnect first to avoid duplicated calls */
+    disconnect_signals();
     connect_signals();
 }
 
@@ -258,21 +321,42 @@
         return;
     }
 
+    qDebug() << Q_FUNC_INFO;
+
     m_trackAddedConnection = m_hubTrackList->on_track_added().connect([this](const media::Track::Id& id)
     {
-        track_index_lut.push_back(id);
+        // If m_insertTrackIndex >= 0, then the user requested to insert a track and we don't want to push
+        // this track onto the back of the track_index_lut.
+        // Otherwise the user requested to add a track which automatically gets pushed onto the back.
+        if (m_insertTrackIndex >= 0)
+        {
+            const media::Track::Id after_track_id = trackOfIndex(m_insertTrackIndex);
+            qDebug() << "Inserting track into specific position after track id:" << after_track_id.c_str();
+            const auto trackPos = std::find(track_index_lut.begin(), track_index_lut.end(), after_track_id);
+            if (trackPos != track_index_lut.end())
+                track_index_lut.insert(trackPos - 1, id);
+            else
+                qWarning() << "Failed to find insertion point for non-existent track id: " << after_track_id.c_str();
+
+            // No longer doing an insert track, so reset flag
+            m_insertTrackIndex = -1;
+        }
+        else
+        {
+            track_index_lut.push_back(id);
+            qDebug() << "Added track id:" << id.c_str();
+        }
+
         // This must come after push_back(id) or indexOfTrack won't find id in the LUT
         const int index = indexOfTrack(id);
         Q_EMIT mediaAboutToBeInserted(index, index);
         qDebug() << "mediaInserted, index: " << index;
         Q_EMIT mediaInserted(index, index);
+        Q_EMIT currentIndexChanged();
     });
 
     m_tracksAddedConnection = m_hubTrackList->on_tracks_added().connect([this](const media::TrackList::ContainerURI& tracks)
     {
-        // TODO: Fill in on_tracks_added here
-        qDebug() << "on_tracks_added(), tracks.size()" << tracks.size();
-
         int i =0;
         for (const media::Track::Id& id : tracks)
         {
@@ -292,6 +376,7 @@
         Q_EMIT mediaAboutToBeInserted(first_index, last_index);
         qDebug() << "mediaInserted, first_index: " << first_index << " last_index: " << last_index;
         Q_EMIT mediaInserted(first_index, last_index);
+        Q_EMIT currentIndexChanged();
     });
 
     m_trackRemovedConnection = m_hubTrackList->on_track_removed().connect([this](const media::Track::Id& id)
@@ -305,6 +390,12 @@
 
         // Removed one track, so start and end are the same index values
         Q_EMIT mediaRemoved(index, index);
+        Q_EMIT currentIndexChanged();
+    });
+
+    m_trackListResetConnection = m_hubTrackList->on_track_list_reset().connect([this]()
+    {
+        qDebug() << "TrackListReset signal received";
     });
 }
 
@@ -312,6 +403,9 @@
 {
     qDebug() << Q_FUNC_INFO;
 
+    if (m_trackListResetConnection.is_connected())
+        m_trackListResetConnection.disconnect();
+
     if (m_trackRemovedConnection.is_connected())
         m_trackRemovedConnection.disconnect();
 

=== modified file 'src/aal/aalmediaplaylistprovider.h'
--- src/aal/aalmediaplaylistprovider.h	2015-10-21 19:42:13 +0000
+++ src/aal/aalmediaplaylistprovider.h	2015-11-13 14:50:26 +0000
@@ -25,6 +25,7 @@
 
 #include <core/connection.h>
 
+#include <atomic>
 #include <memory>
 #include <vector>
 
@@ -54,6 +55,9 @@
     bool removeMedia(int start, int end);
     bool clear();
 
+Q_SIGNALS:
+    void currentIndexChanged();
+
 private:
     void setPlayerSession(const std::shared_ptr<core::ubuntu::media::Player>& playerSession);
     void connect_signals();
@@ -69,11 +73,16 @@
     core::Connection m_trackAddedConnection;
     core::Connection m_tracksAddedConnection;
     core::Connection m_trackRemovedConnection;
+    core::Connection m_trackListResetConnection;
 
     // Simple table that holds a list (order is significant and explicit) of
     // Track::Id's for a lookup. track_index_lut.at[x] gives the corresponding
     // Track::Id for index x, and vice-versa.
     std::vector<core::ubuntu::media::Track::Id> track_index_lut;
+
+    // Did the client perform an insertTrack() (as opposed to an addTrack()) operation?
+    // If yes, the index will be zero or greater, if not index will be -1;
+    std::atomic<int> m_insertTrackIndex;
 };
 
 QT_END_NAMESPACE

=== modified file 'tests/integration/tst_mediaplaylist.cpp'
--- tests/integration/tst_mediaplaylist.cpp	2015-10-22 17:27:54 +0000
+++ tests/integration/tst_mediaplaylist.cpp	2015-11-13 14:50:26 +0000
@@ -69,6 +69,83 @@
     delete player;
 }
 
+void tst_MediaPlaylist::insertTracksAtPositionAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QElapsedTimer timer;
+    timer.start();
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    waitTrackInserted(playlist);
+    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
+
+    QCOMPARE(playlist->mediaCount(), 5);
+
+    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
+    playlist->insertMedia(2, insertedTrack);
+    waitTrackInserted(playlist);
+
+    qDebug() << "playlist->media(2):" << playlist->media(2).canonicalUrl();
+    qDebug() << "insertedTrack:" << insertedTrack.canonicalUrl();
+    QCOMPARE(playlist->media(2), insertedTrack);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::moveTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QElapsedTimer timer;
+    timer.start();
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    content.push_back(newLastTrack);
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->addMedia(content);
+    waitTrackInserted(playlist);
+    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
+
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    // Remove our track of interest
+    playlist->removeMedia(5);
+    waitTrackRemoved(playlist);
+    QCOMPARE(playlist->mediaCount(), 5);
+
+    // "Move" it by inserting it where we want it
+    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->insertMedia(2, insertedTrack);
+    waitTrackInserted(playlist);
+
+    qDebug() << "playlist->media(2):" << playlist->media(2).canonicalUrl();
+    qDebug() << "insertedTrack:" << insertedTrack.canonicalUrl();
+    QCOMPARE(playlist->media(2), insertedTrack);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    QCOMPARE(playlist->media(5), newLastTrack);
+
+    delete playlist;
+    delete player;
+}
+
 void tst_MediaPlaylist::addListOfTracksAndVerify()
 {
     QMediaPlayer *player = new QMediaPlayer;
@@ -420,7 +497,10 @@
     Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
     QCOMPARE(playlist->mediaCount(), 2);
 
-    playlist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop);
+    waitPlaybackModeChange(playlist, [playlist]()
+        {
+            playlist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop);
+        });
 
     player->play();
 
@@ -451,7 +531,10 @@
     Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
     QCOMPARE(playlist->mediaCount(), 2);
 
-    playlist->setPlaybackMode(QMediaPlaylist::Sequential);
+    waitPlaybackModeChange(playlist, [playlist]()
+        {
+            playlist->setPlaybackMode(QMediaPlaylist::Sequential);
+        });
 
     player->play();
 
@@ -550,6 +633,47 @@
     wait_for_signal(future);
 }
 
+void tst_MediaPlaylist::waitTrackRemoved(QMediaPlaylist *playlist)
+{
+    int index = 0;
+    std::promise<int> promise;
+    std::future<int> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaRemoved,
+        [&](int start, int end)
+        {
+            qDebug() << "mediaRemoved start: " << start << ", end: " << end;
+            index = end;
+            promise.set_value(index);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    wait_for_signal(future);
+}
+
+void tst_MediaPlaylist::waitPlaybackModeChange(QMediaPlaylist *playlist,
+                                               const std::function<void()>& action)
+{
+    QMediaPlaylist::PlaybackMode current_mode;
+    std::promise<QMediaPlaylist::PlaybackMode> promise;
+    std::future<QMediaPlaylist::PlaybackMode> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::playbackModeChanged,
+        [&](QMediaPlaylist::PlaybackMode mode)
+        {
+            qDebug() << "playbackModeChanged to: " << mode;
+            current_mode = mode;
+            promise.set_value(current_mode);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    action();
+
+    wait_for_signal(future);
+}
+
 void tst_MediaPlaylist::connectSignal(QMediaPlaylist *playlist, Signals signal)
 {
     switch (signal)

=== modified file 'tests/integration/tst_mediaplaylist.h'
--- tests/integration/tst_mediaplaylist.h	2015-10-22 17:27:54 +0000
+++ tests/integration/tst_mediaplaylist.h	2015-11-13 14:50:26 +0000
@@ -56,6 +56,8 @@
     void constructDestroyRepeat();
 
     void addTwoTracksAndVerify();
+    void insertTracksAtPositionAndVerify();
+    void moveTrackAndVerify();
     void addListOfTracksAndVerify();
     void addLargeListOfTracksAndVerify();
     void addLargeListOfTracksAtOnceAndVerify();
@@ -88,6 +90,9 @@
 
     void waitTrackChange(QMediaPlaylist *playlist);
     void waitTrackInserted(QMediaPlaylist *playlist);
+    void waitTrackRemoved(QMediaPlaylist *playlist);
+    void waitPlaybackModeChange(QMediaPlaylist *playlist,
+                                const std::function<void()>& action);
 
     // A generic way of getting a signal registered into m_signalsDeque without blocking
     // which can be used to later check the order of signals that were emitted. Simply call