Merge lp:~phablet-team/media-hub/sync-trunk into lp:media-hub

[Alfonso Sanchez-Beato]

Sync with stable branch

Sync with stable branch

[Jim Hodapp (jhodapp)]

LGTM

review: Approve (code)

[lp:~phablet-team/media-hub/sync-trunk]

161. By Thomas Voß on 2015-12-23

Fix bug #1479036 which prevents the out_of_range exception from
causing media-hub-server from crashing when a player key is not
found (LP: #1479036)

=== modified file 'README'
--- README	2015-09-09 14:08:12 +0000
+++ README	2015-12-23 14:19:01 +0000
@@ -6,6 +6,10 @@
 
 https://google-styleguide.googlecode.com/svn/trunk/cppguide.html
 
+Deviations from the Google Style Guide above:
+
+1. We will agree to maximum of 100 characters in a single line instead of 80.
+
 
 To Build:
 ---------

=== modified file 'debian/changelog'
--- debian/changelog	2015-12-21 18:55:55 +0000
+++ debian/changelog	2015-12-23 14:19:01 +0000
@@ -57,12 +57,57 @@
 
  -- CI Train Bot <[e-mail]>  Tue, 01 Sep 2015 08:46:00 +0000
 
+media-hub (4.0.0+15.04.20151209-0ubuntu1) vivid; urgency=medium
+
+  * Set gstreamer context directly instead of using gobject to
+    communicate with the video sink
+
+ -- Alfonso Sanchez-Beato <[e-mail]>  Wed, 09 Dec 2015 06:49:28 +0000
+
+media-hub (4.0.0+15.04.20151202-0ubuntu1) vivid; urgency=medium
+
+  [ CI Train Bot ]
+  * No-change rebuild.
+
+ -- Thomas Voß <[e-mail]>  Wed, 02 Dec 2015 07:40:41 +0000
+
+media-hub (4.0.0+15.04.20151118.1-0ubuntu1) vivid; urgency=medium
+
+  [ Jim Hodapp ]
+  * Added move_track and various fixes for TrackList. 
+  * Major bump for new TrackList API changes.
+
+  [ Alfonso Sanchez-Beato ]
+  * Make sure our iterator for the current track points to the right
+    place when (un)shuffling (LP #1510219). Fix crash when client tries
+    to set the player for a non-existing key. Do not add empty URIs to
+    the list (LP: #1511029). (LP: #1511073, #1511385, #1510219,
+    #1510227, #1511029)
+
+ -- Jim Hodapp <[e-mail]>  Wed, 18 Nov 2015 18:36:18 +0000
+
 media-hub (4.0.0-0ubuntu1) wily; urgency=medium
 
   * Bump major revision to account for toolchain update. Fixes LP:#1452331
 
  -- Thomas Voß <[e-mail]>  Thu, 23 Jul 2015 08:47:21 +0200
 
+media-hub (3.3.0+15.04.20151023.3-0ubuntu2) UNRELEASED; urgency=medium
+
+  * Force rebuild against dbus-cpp. 
+
+ -- Thomas Voß <[e-mail]>  Tue, 17 Nov 2015 09:37:46 +0100
+
+media-hub (3.3.0+15.04.20151023.3-0ubuntu1) vivid; urgency=medium
+
+  [ Jim Hodapp ]
+  * Add batch adding of tracks to the TrackList.
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+ -- Jim Hodapp <[e-mail]>  Fri, 23 Oct 2015 19:07:52 +0000
+
 media-hub (3.1.0+15.10.20150724-0ubuntu1) wily; urgency=medium
 
   [ Alfonso Sanchez-Beato (email Canonical) ]

=== modified file 'include/core/media/track_list.h'
--- include/core/media/track_list.h	2015-07-20 20:39:42 +0000
+++ include/core/media/track_list.h	2015-12-23 14:19:01 +0000
@@ -41,10 +41,42 @@
 {
   public:
     typedef std::vector<Track::Id> Container;
+    typedef std::vector<Track::UriType> ContainerURI;
     typedef std::tuple<std::vector<Track::Id>, Track::Id> ContainerTrackIdTuple;
+    typedef std::tuple<Track::Id, Track::Id> TrackIdTuple;
     typedef Container::iterator Iterator;
     typedef Container::const_iterator ConstIterator;
 
+    struct Errors
+    {
+        Errors() = delete;
+
+        struct InsufficientPermissionsToAddTrack : public std::runtime_error
+        {
+            InsufficientPermissionsToAddTrack();
+        };
+
+        struct FailedToMoveTrack : public std::runtime_error
+        {
+            FailedToMoveTrack();
+        };
+
+        struct FailedToFindMoveTrackSource : public std::runtime_error
+        {
+            FailedToFindMoveTrackSource(const std::string& err);
+        };
+
+        struct FailedToFindMoveTrackDest : public std::runtime_error
+        {
+            FailedToFindMoveTrackDest(const std::string& err);
+        };
+
+        struct TrackNotFound : public std::runtime_error
+        {
+            TrackNotFound();
+        };
+    };
+
     static const Track::Id& after_empty_track();
 
     TrackList(const TrackList&) = delete;
@@ -65,14 +97,20 @@
     /** Gets the URI for a given Track. */
     virtual Track::UriType query_uri_for_track(const Track::Id& id) = 0;
 
-    /** Adds a URI in the TrackList. */
+    /** Adds a URI into the TrackList. */
     virtual void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current) = 0;
 
+    /** Adds a list of URIs into the TrackList. */
+    virtual void add_tracks_with_uri_at(const ContainerURI& uris, const Track::Id& position) = 0;
+
+    /** Moves track 'id' from its old position in the TrackList to new position. */
+    virtual bool move_track(const Track::Id& id, const Track::Id& to) = 0;
+
     /** Removes a Track from the TrackList. */
     virtual void remove_track(const Track::Id& id) = 0;
 
-    /** Skip to the specified TrackId. Calls stop() and play() on the player if toggle_player_state is true. */
-    virtual void go_to(const Track::Id& track, bool toggle_player_state) = 0;
+    /** Skip to the specified TrackId. */
+    virtual void go_to(const Track::Id& track) = 0;
 
     /** Returns true if there is a next track in the TrackList after the current one playing */
     bool has_next() const;
@@ -86,31 +124,34 @@
     /** Skip to the previous Track in the TrackList if there is one. */
     virtual Track::Id previous() = 0;
 
-
-    /** Reorders the tracks such that they are in a random order. */
-    virtual void shuffle_tracks() = 0;
-
-    /** Restores the original order of tracks before shuffle mode was turned on. */
-    virtual void unshuffle_tracks() = 0;
-
     /** Clears and resets the TrackList to the same as a newly constructed instance. */
     virtual void reset() = 0;
 
-
     /** Indicates that the entire tracklist has been replaced. */
     virtual const core::Signal<ContainerTrackIdTuple>& on_track_list_replaced() const = 0;
 
     /** Indicates that a track has been added to the track list. */
     virtual const core::Signal<Track::Id>& on_track_added() const = 0;
 
+    /** Indicates that one or more tracks have been added to the track list. */
+    virtual const core::Signal<ContainerURI>& on_tracks_added() const = 0;
+
+    /** Indicates that a track has been moved within the track list. First template param
+     *  holds the id of the track being moved. Second param holds the id of the track of the
+     *  position to move the track to in the TrackList. */
+    virtual const core::Signal<TrackIdTuple>& on_track_moved() const = 0;
+
     /** Indicates that a track has been removed from the track list. */
     virtual const core::Signal<Track::Id>& on_track_removed() const = 0;
 
+    /** Indicates that the track list has been reset and there are no tracks now */
+    virtual const core::Signal<void>& on_track_list_reset() const = 0;
+
     /** Indicates that the track list advanced from one track to another. */
     virtual const core::Signal<Track::Id>& on_track_changed() const = 0;
 
     /** Used to notify the Player of when the client requested that the Player should immediately play a new track. */
-    virtual const core::Signal<std::pair<Track::Id, bool>>& on_go_to_track() const = 0;
+    virtual const core::Signal<Track::Id>& on_go_to_track() const = 0;
 
     /** Used to notify the Player of when the end of the tracklist has been reached. */
     virtual const core::Signal<void>& on_end_of_tracklist() const = 0;

=== modified file 'src/core/media/gstreamer/playbin.cpp'
--- src/core/media/gstreamer/playbin.cpp	2015-10-16 08:32:58 +0000
+++ src/core/media/gstreamer/playbin.cpp	2015-12-23 14:19:01 +0000
@@ -455,7 +455,13 @@
     const core::ubuntu::media::Player::HeadersType& headers = core::ubuntu::media::Player::HeadersType(),
     bool do_pipeline_reset)
 {
-    if (do_pipeline_reset)
+    gchar *current_uri = nullptr;
+    g_object_get(pipeline, "current-uri", &current_uri, NULL);
+
+    // Checking for a current_uri being set and not resetting the pipeline
+    // if there isn't a current_uri causes the first play to start playback
+    // sooner since reset_pipeline won't be called
+    if (current_uri and do_pipeline_reset)
         reset_pipeline();
 
     g_object_set(pipeline, "uri", uri.c_str(), NULL);
@@ -465,6 +471,8 @@
         file_type = MEDIA_FILE_TYPE_AUDIO;
 
     request_headers = headers;
+
+    g_free(current_uri);
 }
 
 void gstreamer::Playbin::setup_source(GstElement *source)

=== modified file 'src/core/media/mpris/track_list.h'
--- src/core/media/mpris/track_list.h	2015-07-27 22:15:33 +0000
+++ src/core/media/mpris/track_list.h	2015-12-23 14:19:01 +0000
@@ -48,9 +48,54 @@
         return s;
     }
 
+    struct Error
+    {
+        struct InsufficientPermissionsToAddTrack
+        {
+            static constexpr const char* name
+            {
+                "mpris.TrackList.Error.InsufficientPermissionsToAddTrack"
+            };
+        };
+
+        struct FailedToMoveTrack
+        {
+            static constexpr const char* name
+            {
+                "mpris.TrackList.Error.FailedToMoveTrack"
+            };
+        };
+
+        struct FailedToFindMoveTrackSource
+        {
+            static constexpr const char* name
+            {
+                "mpris.TrackList.Error.FailedToFindMoveTrackSource"
+            };
+        };
+
+        struct FailedToFindMoveTrackDest
+        {
+            static constexpr const char* name
+            {
+                "mpris.TrackList.Error.FailedToFindMoveTrackDest"
+            };
+        };
+
+        struct TrackNotFound
+        {
+            static constexpr const char* name
+            {
+                "mpris.TrackList.Error.TrackNotFound"
+            };
+        };
+    };
+
     DBUS_CPP_METHOD_DEF(GetTracksMetadata, TrackList)
     DBUS_CPP_METHOD_DEF(GetTracksUri, TrackList)
     DBUS_CPP_METHOD_DEF(AddTrack, TrackList)
+    DBUS_CPP_METHOD_DEF(AddTracks, TrackList)
+    DBUS_CPP_METHOD_DEF(MoveTrack, TrackList)
     DBUS_CPP_METHOD_DEF(RemoveTrack, TrackList)
     DBUS_CPP_METHOD_DEF(GoTo, TrackList)
     DBUS_CPP_METHOD_DEF(Reset, TrackList)
@@ -75,6 +120,20 @@
 
         DBUS_CPP_SIGNAL_DEF
         (
+            TracksAdded,
+            TrackList,
+            core::ubuntu::media::TrackList::ContainerURI
+        )
+
+        DBUS_CPP_SIGNAL_DEF
+        (
+            TrackMoved,
+            TrackList,
+            BOOST_IDENTITY_TYPE((std::tuple<core::ubuntu::media::Track::Id, core::ubuntu::media::Track::Id>))
+        )
+
+        DBUS_CPP_SIGNAL_DEF
+        (
             TrackRemoved,
             TrackList,
             core::ubuntu::media::Track::Id
@@ -89,6 +148,13 @@
 
         DBUS_CPP_SIGNAL_DEF
         (
+            TrackListReset,
+            TrackList,
+            void
+        )
+
+        DBUS_CPP_SIGNAL_DEF
+        (
             TrackMetadataChanged,
             TrackList,
             BOOST_IDENTITY_TYPE((std::tuple<std::map<std::string, dbus::types::Variant>, dbus::types::ObjectPath>))
@@ -134,8 +200,11 @@
               {
                   configuration.object->template get_signal<Signals::TrackListReplaced>(),
                   configuration.object->template get_signal<Signals::TrackAdded>(),
+                  configuration.object->template get_signal<Signals::TracksAdded>(),
+                  configuration.object->template get_signal<Signals::TrackMoved>(),
                   configuration.object->template get_signal<Signals::TrackRemoved>(),
                   configuration.object->template get_signal<Signals::TrackChanged>(),
+                  configuration.object->template get_signal<Signals::TrackListReset>(),
                   configuration.object->template get_signal<Signals::TrackMetadataChanged>(),
                   configuration.object->template get_signal<core::dbus::interfaces::Properties::Signals::PropertiesChanged>()
               }
@@ -178,8 +247,11 @@
         {
             core::dbus::Signal<Signals::TrackListReplaced, Signals::TrackListReplaced::ArgumentType>::Ptr tracklist_replaced;
             core::dbus::Signal<Signals::TrackAdded, Signals::TrackAdded::ArgumentType>::Ptr track_added;
+            core::dbus::Signal<Signals::TracksAdded, Signals::TracksAdded::ArgumentType>::Ptr tracks_added;
+            core::dbus::Signal<Signals::TrackMoved, Signals::TrackMoved::ArgumentType>::Ptr track_moved;
             core::dbus::Signal<Signals::TrackRemoved, Signals::TrackRemoved::ArgumentType>::Ptr track_removed;
             core::dbus::Signal<Signals::TrackChanged, Signals::TrackChanged::ArgumentType>::Ptr track_changed;
+            core::dbus::Signal<Signals::TrackListReset, Signals::TrackListReset::ArgumentType>::Ptr track_list_reset;
             core::dbus::Signal<Signals::TrackMetadataChanged, Signals::TrackMetadataChanged::ArgumentType>::Ptr track_metadata_changed;
 
             dbus::Signal <core::dbus::interfaces::Properties::Signals::PropertiesChanged,

=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2015-09-29 11:07:54 +0000
+++ src/core/media/player_implementation.cpp	2015-12-23 14:19:01 +0000
@@ -294,7 +294,8 @@
         {
             // Using a TrackList for playback, added tracks via add_track(), but open_uri hasn't been called yet
             // to load a media resource
-            std::cout << "Calling d->engine->open_resource_for_uri() for first track added only: " << uri << std::endl;
+            std::cout << "Calling d->engine->open_resource_for_uri() for first track added only: "
+                      << uri << std::endl;
             std::cout << "\twith a Track::Id: " << id << std::endl;
             static const bool do_pipeline_reset = false;
             engine->open_resource_for_uri(uri, do_pipeline_reset);
@@ -375,6 +376,11 @@
     };
     Parent::position().install(position_getter);
 
+    d->engine->position().changed().connect([this](uint64_t position)
+    {
+        d->track_list->on_position_changed(position);
+    });
+
     // Make sure that the Duration property gets updated from the Engine
     // every time the client requests duration
     std::function<uint64_t()> duration_getter = [this]()
@@ -507,8 +513,7 @@
         }
     });
 
-
-    d->track_list->on_go_to_track().connect([this](std::pair<const media::Track::Id, bool> p)
+    d->track_list->on_go_to_track().connect([this](const media::Track::Id& id)
     {
         // This lambda needs to be mutually exclusive with the about_to_finish lambda above
         const bool locked = d->doing_go_to_track.try_lock();
@@ -517,11 +522,8 @@
         if (!locked)
             return;
 
-        const media::Track::Id id = p.first;
-        const bool toggle_player_state = p.second;
-
-        if (toggle_player_state)
-            d->engine->stop();
+        // Store whether we should restore the current playing state after loading the new uri
+        const bool auto_play = Parent::playback_status().get() == media::Player::playing;
 
         const Track::UriType uri = d->track_list->query_uri_for_track(id);
         if (!uri.empty())
@@ -532,8 +534,11 @@
             d->engine->open_resource_for_uri(uri, do_pipeline_reset);
         }
 
-        if (toggle_player_state)
+        if (auto_play)
+        {
+            std::cout << "Restoring playing state in on_go_to_track()" << std::endl;
             d->engine->play();
+        }
 
         d->doing_go_to_track.unlock();
     });
@@ -547,11 +552,28 @@
         d->update_mpris_properties();
     });
 
+    d->track_list->on_tracks_added().connect([this](const media::TrackList::ContainerURI& tracks)
+    {
+        std::cout << "** Track was added, handling in PlayerImplementation" << std::endl;
+        // If the two sizes are the same, that means the TrackList was previously empty and we need
+        // to open the first track in the TrackList so that is_audio_source() and is_video_source()
+        // will function correctly.
+        if (tracks.size() >= 1 and d->track_list->tracks()->size() == tracks.size())
+            d->open_first_track_from_tracklist(tracks.front());
+
+        d->update_mpris_properties();
+    });
+
     d->track_list->on_track_removed().connect([this](const media::Track::Id&)
     {
         d->update_mpris_properties();
     });
 
+    d->track_list->on_track_list_reset().connect([this](void)
+    {
+        d->update_mpris_properties();
+    });
+
     d->track_list->on_track_changed().connect([this](const media::Track::Id&)
     {
         d->update_mpris_properties();
@@ -664,7 +686,15 @@
 bool media::PlayerImplementation<Parent>::open_uri(const Track::UriType& uri)
 {
     d->track_list->reset();
-    const bool ret = d->engine->open_resource_for_uri(uri, false);
+
+    // If empty uri, give the same meaning as QMediaPlayer::setMedia("")
+    if (uri.empty()) {
+        cout << __PRETTY_FUNCTION__ << ": resetting current media" << endl;
+        return true;
+    }
+
+    static const bool do_pipeline_reset = false;
+    const bool ret = d->engine->open_resource_for_uri(uri, do_pipeline_reset);
     // Don't set new track as the current track to play since we're calling open_resource_for_uri above
     static const bool make_current = false;
     d->track_list->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), make_current);

=== modified file 'src/core/media/service_skeleton.cpp'
--- src/core/media/service_skeleton.cpp	2015-12-18 16:24:01 +0000
+++ src/core/media/service_skeleton.cpp	2015-12-23 14:19:01 +0000
@@ -46,6 +46,8 @@
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
 
+using namespace std;
+
 namespace
 {
 core::Signal<void> the_empty_signal;
@@ -132,7 +134,9 @@
             impl->access_service()->add_object_for_path(op)
         };
 
-        std::cout << "Session created by request of: " << msg->sender() << ", uuid: " << uuid << ", path:" << op << std::endl;
+        cout << "Session created by request of: " << msg->sender()
+             << ", key: " << key << ", uuid: " << uuid
+             << ", path:" << op << std::endl;
 
         try
         {
@@ -205,9 +209,11 @@
             std::string uuid;
             msg->reader() >> uuid;
 
-            if (uuid_player_map.count(uuid) != 0) {
+            if (uuid_player_map.count(uuid) != 0)
+            {
                 auto key = uuid_player_map.at(uuid);
-                if (not configuration.player_store->has_player_for_key(key)) {
+                if (not configuration.player_store->has_player_for_key(key))
+                {
                     auto reply = dbus::Message::make_error(
                                 msg,
                                 mpris::Service::Errors::ReattachingSession::name(),

=== modified file 'src/core/media/track_list.cpp'
--- src/core/media/track_list.cpp	2015-07-20 20:39:42 +0000
+++ src/core/media/track_list.cpp	2015-12-23 14:19:01 +0000
@@ -20,6 +20,33 @@
 
 namespace media = core::ubuntu::media;
 
+media::TrackList::Errors::InsufficientPermissionsToAddTrack::InsufficientPermissionsToAddTrack()
+    : std::runtime_error{"Insufficient client permissions for adding track to TrackList"}
+{
+}
+
+media::TrackList::Errors::FailedToMoveTrack::FailedToMoveTrack()
+    : std::runtime_error{"Failed to move track within TrackList"}
+{
+}
+
+media::TrackList::Errors::FailedToFindMoveTrackSource::FailedToFindMoveTrackSource
+        (const std::string &e)
+    : std::runtime_error{e}
+{
+}
+
+media::TrackList::Errors::FailedToFindMoveTrackDest::FailedToFindMoveTrackDest
+        (const std::string &e)
+    : std::runtime_error{e}
+{
+}
+
+media::TrackList::Errors::TrackNotFound::TrackNotFound()
+    : std::runtime_error{"Track not found in TrackList"}
+{
+}
+
 const media::Track::Id& media::TrackList::after_empty_track()
 {
     static const media::Track::Id id{"/org/mpris/MediaPlayer2/TrackList/NoTrack"};

=== modified file 'src/core/media/track_list_implementation.cpp'
--- src/core/media/track_list_implementation.cpp	2015-09-28 13:20:01 +0000
+++ src/core/media/track_list_implementation.cpp	2015-12-23 14:19:01 +0000
@@ -17,9 +17,13 @@
  */
 
 #include <algorithm>
+#include <random>
 #include <stdio.h>
 #include <stdlib.h>
 #include <tuple>
+#include <unistd.h>
+
+#include <dbus/dbus.h>
 
 #include "track_list_implementation.h"
 
@@ -38,7 +42,45 @@
     std::shared_ptr<media::Engine::MetaDataExtractor> extractor;
     // Used for caching the original tracklist order to be used to restore the order
     // to the live TrackList after shuffle is turned off
-    media::TrackList::Container original_tracklist;
+    media::TrackList::Container shuffled_tracks;
+    bool shuffle;
+
+    void updateCachedTrackMetadata(const media::Track::Id& id, const media::Track::UriType& uri)
+    {
+        if (meta_data_cache.count(id) == 0)
+        {
+            // FIXME: This code seems to conflict badly when called multiple times in a row: causes segfaults
+#if 0
+            try {
+                meta_data_cache[id] = std::make_tuple(
+                            uri,
+                            extractor->meta_data_for_track_with_uri(uri));
+            } catch (const std::runtime_error &e) {
+                std::cerr << "Failed to retrieve metadata for track '" << uri << "' (" << e.what() << ")" << std::endl;
+            }
+#else
+            meta_data_cache[id] = std::make_tuple(
+                    uri,
+                    core::ubuntu::media::Track::MetaData{});
+#endif
+        } else
+        {
+            std::get<0>(meta_data_cache[id]) = uri;
+        }
+    }
+
+    media::TrackList::Container::iterator get_shuffled_insert_it()
+    {
+        media::TrackList::Container::iterator random_it = shuffled_tracks.begin();
+        if (random_it == shuffled_tracks.end())
+            return random_it;
+
+        // This is slightly biased, but not much, as RAND_MAX >= 32767, which is
+        // much more than the average number of tracks.
+        // Note that for N tracks we have N + 1 possible insertion positions.
+        std::advance(random_it, rand() % (shuffled_tracks.size() + 1));
+        return random_it;
+    }
 };
 
 media::TrackListImplementation::TrackListImplementation(
@@ -48,7 +90,8 @@
         const media::apparmor::ubuntu::RequestContextResolver::Ptr& request_context_resolver,
         const media::apparmor::ubuntu::RequestAuthenticator::Ptr& request_authenticator)
     : media::TrackListSkeleton(bus, object, request_context_resolver, request_authenticator),
-      d(new Private{object, 0, Private::MetaDataCache{}, extractor, media::TrackList::Container{}})
+      d(new Private{object, 0, Private::MetaDataCache{},
+                    extractor, media::TrackList::Container{}, false})
 {
     can_edit_tracks().set(true);
 }
@@ -84,12 +127,15 @@
 {
     std::cout << __PRETTY_FUNCTION__ << std::endl;
 
-    std::stringstream ss; ss << d->object->path().as_string() << "/" << d->track_counter++;
+    std::stringstream ss;
+    ss << d->object->path().as_string() << "/" << d->track_counter++;
     Track::Id id{ss.str()};
 
     std::cout << "Adding Track::Id: " << id << std::endl;
     std::cout << "\tURI: " << uri << std::endl;
 
+    const auto current = get_current_track();
+
     auto result = tracks().update([this, id, position, make_current](TrackList::Container& container)
     {
         auto it = std::find(container.begin(), container.end(), position);
@@ -101,50 +147,180 @@
 
     if (result)
     {
-        if (d->meta_data_cache.count(id) == 0)
-        {
-            // FIXME: This code seems to conflict badly when called multiple times in a row: causes segfaults
-#if 0
-            try {
-                d->meta_data_cache[id] = std::make_tuple(
-                            uri,
-                            d->extractor->meta_data_for_track_with_uri(uri));
-            } catch (const std::runtime_error &e) {
-                std::cerr << "Failed to retrieve metadata for track '" << uri << "' (" << e.what() << ")" << std::endl;
-            }
-#else
-            d->meta_data_cache[id] = std::make_tuple(
-                    uri,
-                    core::ubuntu::media::Track::MetaData{});
-#endif
-        } else
-        {
-            std::get<0>(d->meta_data_cache[id]) = uri;
-        }
+        d->updateCachedTrackMetadata(id, uri);
+
+        if (d->shuffle)
+            d->shuffled_tracks.insert(d->get_shuffled_insert_it(), id);
 
         if (make_current)
         {
-            // Don't automatically call stop() and play() in player_implementation.cpp on_go_to_track()
-            // since this breaks video playback when using open_uri() (stop() and play() are unwanted in
-            // this scenario since the qtubuntu-media will handle this automatically)
-            const bool toggle_player_state = false;
-            go_to(id, toggle_player_state);
+            set_current_track(id);
+            go_to(id);
+        } else {
+            set_current_track(current);
         }
 
-        // Signal to the client that the current track has changed for the first track added to the TrackList
-        if (tracks().get().size() == 1)
-            on_track_changed()(id);
-
         std::cout << "Signaling that we just added track id: " << id << std::endl;
         // Signal to the client that a track was added to the TrackList
         on_track_added()(id);
-        std::cout << "Signaled that we just added track id: " << id << std::endl;
-    }
+
+        // Signal to the client that the current track has changed for the first
+        // track added to the TrackList
+        if (tracks().get().size() == 1)
+            on_track_changed()(id);
+    }
+}
+
+void media::TrackListImplementation::add_tracks_with_uri_at(const ContainerURI& uris, const Track::Id& position)
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+    const auto current = get_current_track();
+
+    Track::Id current_id;
+    ContainerURI tmp;
+    for (const auto uri : uris)
+    {
+        // TODO: Refactor this code to use a smaller common function shared with add_track_with_uri_at()
+        std::stringstream ss;
+        ss << d->object->path().as_string() << "/" << d->track_counter++;
+        Track::Id id{ss.str()};
+        std::cout << "Adding Track::Id: " << id << std::endl;
+        std::cout << "\tURI: " << uri << std::endl;
+
+        tmp.push_back(id);
+
+        Track::Id insert_position = position;
+
+        auto it = std::find(tracks().get().begin(), tracks().get().end(), insert_position);
+        const auto result = tracks().update([this, id, position, it, &insert_position](TrackList::Container& container)
+        {
+            container.insert(it, id);
+            // Make sure the next insert position is after the current insert position
+            // Update the Track::Id after which to insert the next one from uris
+            insert_position = id;
+
+            return true;
+        });
+
+        if (result)
+        {
+            d->updateCachedTrackMetadata(id, uri);
+
+            if (d->shuffle)
+                d->shuffled_tracks.insert(d->get_shuffled_insert_it(), id);
+
+            // Signal to the client that the current track has changed for the first track added to the TrackList
+            if (tracks().get().size() == 1)
+                current_id = id;
+        }
+    }
+
+    set_current_track(current);
+
+    std::cout << "Signaling that we just added " << tmp.size() << " tracks to the TrackList" << std::endl;
+    on_tracks_added()(tmp);
+
+    if (!current_id.empty())
+        on_track_changed()(current_id);
+}
+
+bool media::TrackListImplementation::move_track(const media::Track::Id& id,
+                                                const media::Track::Id& to)
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+    std::cout << "-----------------------------------------------------" << std::endl;
+    if (id.empty() or to.empty())
+    {
+        std::cerr << "Can't move track since 'id' or 'to' are empty" << std::endl;
+        return false;
+    }
+
+    if (id == to)
+    {
+        std::cerr << "Can't move track to it's same position" << std::endl;
+        return false;
+    }
+
+    if (tracks().get().size() == 1)
+    {
+        std::cerr << "Can't move track since TrackList contains only one track" << std::endl;
+        return false;
+    }
+
+    bool ret = false;
+    const media::Track::Id current_id = *current_iterator();
+    std::cout << "current_track id: " << current_id << std::endl;
+    // Get an iterator that points to the track that is the insertion point
+    auto insert_point_it = std::find(tracks().get().begin(), tracks().get().end(), to);
+    if (insert_point_it != tracks().get().end())
+    {
+        const auto result = tracks().update([this, id, to, current_id, &insert_point_it]
+                (TrackList::Container& container)
+        {
+            // Get an iterator that points to the track to move within the TrackList
+            auto to_move_it = std::find(tracks().get().begin(), tracks().get().end(), id);
+            std::cout << "Erasing old track position: " << *to_move_it << std::endl;
+            if (to_move_it != tracks().get().end())
+            {
+                container.erase(to_move_it);
+            }
+            else
+            {
+                throw media::TrackList::Errors::FailedToFindMoveTrackDest
+                        ("Failed to find destination track " + to);
+            }
+
+            // Insert id at the location just before insert_point_it
+            container.insert(insert_point_it, id);
+
+            const auto new_current_track_it = std::find(tracks().get().begin(), tracks().get().end(), current_id);
+            if (new_current_track_it != tracks().get().end())
+            {
+                const bool r = update_current_iterator(new_current_track_it);
+                if (!r)
+                {
+                    throw media::TrackList::Errors::FailedToMoveTrack();
+                }
+                std::cout << "*** Updated current_iterator, id: " << *current_iterator() << std::endl;
+            }
+            else
+            {
+                std::cerr << "Can't update current_iterator - failed to find track after move" << std::endl;
+                throw media::TrackList::Errors::FailedToMoveTrack();
+            }
+
+            return true;
+        });
+
+        if (result)
+        {
+            std::cout << "TrackList after move" << std::endl;
+            for(auto track : tracks().get())
+            {
+                std::cout << track << std::endl;
+            }
+            const media::TrackList::TrackIdTuple ids = std::make_tuple(id, to);
+            // Signal to the client that track 'id' was moved within the TrackList
+            on_track_moved()(ids);
+            ret = true;
+        }
+    }
+    else
+    {
+        throw media::TrackList::Errors::FailedToFindMoveTrackSource
+                ("Failed to find source track " + id);
+    }
+
+    std::cout << "-----------------------------------------------------" << std::endl;
+
+    return ret;
 }
 
 void media::TrackListImplementation::remove_track(const media::Track::Id& id)
 {
-    auto result = tracks().update([id](TrackList::Container& container)
+    const auto result = tracks().update([id](TrackList::Container& container)
     {
         container.erase(std::find(container.begin(), container.end(), id));
         return true;
@@ -156,85 +332,63 @@
     {
         d->meta_data_cache.erase(id);
 
+        if (d->shuffle)
+            d->shuffled_tracks.erase(find(d->shuffled_tracks.begin(),
+                                          d->shuffled_tracks.end(), id));
+
         on_track_removed()(id);
+
+        // Make sure playback stops if all tracks were removed
+        if (tracks().get().empty())
+            on_end_of_tracklist()();
     }
-
 }
 
-void media::TrackListImplementation::go_to(const media::Track::Id& track, bool toggle_player_state)
+void media::TrackListImplementation::go_to(const media::Track::Id& track)
 {
     std::cout << __PRETTY_FUNCTION__ << std::endl;
-    std::pair<const media::Track::Id, bool> p = std::make_pair(track, toggle_player_state);
     // Signal the Player instance to go to a specific track for playback
-    on_go_to_track()(p);
+    on_go_to_track()(track);
     on_track_changed()(track);
 }
 
-void media::TrackListImplementation::shuffle_tracks()
-{
-    std::cout << __PRETTY_FUNCTION__ << std::endl;
-
-    if (tracks().get().empty())
-        return;
-
-    auto result = tracks().update([this](TrackList::Container& container)
-    {
-        // Save off the original TrackList ordering
-        d->original_tracklist.assign(container.begin(), container.end());
-        std::random_shuffle(container.begin(), container.end());
-        return true;
-    });
-
-    if (result)
-    {
-        media::TrackList::ContainerTrackIdTuple t{std::make_tuple(tracks().get(), current())};
-        on_track_list_replaced()(t);
-    }
-}
-
-void media::TrackListImplementation::unshuffle_tracks()
-{
-    std::cout << __PRETTY_FUNCTION__ << std::endl;
-
-    if (tracks().get().empty() or d->original_tracklist.empty())
-        return;
-
-    auto result = tracks().update([this](TrackList::Container& container)
-    {
-        // Restore the original TrackList ordering
-        container.assign(d->original_tracklist.begin(), d->original_tracklist.end());
-        return true;
-    });
-
-    if (result)
-    {
-        media::TrackList::ContainerTrackIdTuple t{std::make_tuple(tracks().get(), current())};
-        on_track_list_replaced()(t);
-    }
+void media::TrackListImplementation::set_shuffle(bool shuffle)
+{
+    d->shuffle = shuffle;
+
+    if (shuffle) {
+        d->shuffled_tracks = tracks().get();
+        random_shuffle(d->shuffled_tracks.begin(), d->shuffled_tracks.end());
+    }
+}
+
+bool media::TrackListImplementation::shuffle()
+{
+    return d->shuffle;
+}
+
+const media::TrackList::Container& media::TrackListImplementation::shuffled_tracks()
+{
+    return d->shuffled_tracks;
 }
 
 void media::TrackListImplementation::reset()
 {
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+
     // Make sure playback stops
     on_end_of_tracklist()();
     // And make sure there is no "current" track
     media::TrackListSkeleton::reset();
 
-    auto result = tracks().update([this](TrackList::Container& container)
+    tracks().update([this](TrackList::Container& container)
     {
-        TrackList::Container ids = container;
-
-        for (auto it = container.begin(); it != container.end(); ) {
-            auto id = *it;
-            it = container.erase(it);
-            on_track_removed()(id);
-        }
-
-        container.resize(0);
+        container.clear();
+        on_track_list_reset()();
+
         d->track_counter = 0;
+        d->shuffled_tracks.clear();
 
         return true;
     });
-
-    (void) result;
 }

=== modified file 'src/core/media/track_list_implementation.h'
--- src/core/media/track_list_implementation.h	2015-05-22 21:19:28 +0000
+++ src/core/media/track_list_implementation.h	2015-12-23 14:19:01 +0000
@@ -43,11 +43,14 @@
     Track::MetaData query_meta_data_for_track(const Track::Id& id);
 
     void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current);
+    void add_tracks_with_uri_at(const ContainerURI& uris, const Track::Id& position);
+    bool move_track(const Track::Id& id, const Track::Id& to);
     void remove_track(const Track::Id& id);
 
-    void go_to(const Track::Id& track, bool toggle_player_state);
-    void shuffle_tracks();
-    void unshuffle_tracks();
+    void go_to(const Track::Id& track);
+    void set_shuffle(bool shuffle);
+    bool shuffle();
+    const media::TrackList::Container& shuffled_tracks();
     void reset();
 
 private:

=== modified file 'src/core/media/track_list_skeleton.cpp'
--- src/core/media/track_list_skeleton.cpp	2015-09-28 15:31:46 +0000
+++ src/core/media/track_list_skeleton.cpp	2015-12-23 14:19:01 +0000
@@ -38,10 +38,14 @@
 
 #include <iostream>
 #include <limits>
+#include <sstream>
+#include <cstdint>
 
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
 
+using namespace std;
+
 struct media::TrackListSkeleton::Private
 {
     Private(media::TrackListSkeleton* impl, const dbus::Bus::Ptr& bus, const dbus::Object::Ptr& object,
@@ -56,11 +60,16 @@
           current_track(skeleton.properties.tracks->get().begin()),
           empty_iterator(skeleton.properties.tracks->get().begin()),
           loop_status(media::Player::LoopStatus::none),
+          current_position(0),
+          id_after_remove(),
           signals
           {
               skeleton.signals.track_added,
+              skeleton.signals.tracks_added,
+              skeleton.signals.track_moved,
               skeleton.signals.track_removed,
               skeleton.signals.track_changed,
+              skeleton.signals.track_list_reset,
               skeleton.signals.tracklist_replaced
           }
     {
@@ -93,9 +102,12 @@
     void handle_add_track_with_uri_at(const core::dbus::Message::Ptr& msg)
     {
         std::cout << "*** " << __PRETTY_FUNCTION__ << std::endl;
-        request_context_resolver->resolve_context_for_dbus_name_async(msg->sender(), [this, msg](const media::apparmor::ubuntu::Context& context)
+        request_context_resolver->resolve_context_for_dbus_name_async
+            (msg->sender(), [this, msg](const media::apparmor::ubuntu::Context& context)
         {
-            Track::UriType uri; media::Track::Id after; bool make_current;
+            Track::UriType uri;
+            media::Track::Id after;
+            bool make_current;
             msg->reader() >> uri >> after >> make_current;
 
             // Make sure the client has adequate apparmor permissions to open the URI
@@ -104,13 +116,109 @@
             auto reply = dbus::Message::make_method_return(msg);
             // Only add the track to the TrackList if it passes the apparmor permissions check
             if (std::get<0>(result))
+            {
                 impl->add_track_with_uri_at(uri, after, make_current);
-            else
-                std::cerr << "Warning: Not adding track " << uri <<
-                    " to TrackList because of inadequate client apparmor permissions." << std::endl;
-
-            bus->send(reply);
-        });
+            }
+            else
+            {
+                const std::string err_str = {"Warning: Not adding track " + uri +
+                    " to TrackList because of inadequate client apparmor permissions."};
+                std::cerr << err_str << std::endl;
+                reply = dbus::Message::make_error(
+                            msg,
+                            mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name,
+                            err_str);
+            }
+
+            bus->send(reply);
+        });
+    }
+
+    void handle_add_tracks_with_uri_at(const core::dbus::Message::Ptr& msg)
+    {
+        std::cout << "*** " << __PRETTY_FUNCTION__ << std::endl;
+        request_context_resolver->resolve_context_for_dbus_name_async
+            (msg->sender(), [this, msg](const media::apparmor::ubuntu::Context& context)
+        {
+            ContainerURI uris;
+            media::Track::Id after;
+            msg->reader() >> uris >> after;
+
+            media::apparmor::ubuntu::RequestAuthenticator::Result result;
+            std::string err_str;
+            for (const auto uri : uris)
+            {
+                // Make sure the client has adequate apparmor permissions to open the URI
+                result = request_authenticator->authenticate_open_uri_request(context, uri);
+                if (not std::get<0>(result))
+                {
+                    err_str = {"Warning: Not adding track " + uri +
+                        " to TrackList because of inadequate client apparmor permissions."};
+                    break;
+                }
+            }
+
+            core::dbus::Message::Ptr reply;
+            // Only add the track to the TrackList if it passes the apparmor permissions check
+            if (std::get<0>(result))
+            {
+                reply = dbus::Message::make_method_return(msg);
+                impl->add_tracks_with_uri_at(uris, after);
+            }
+            else
+            {
+                std::cerr << err_str << std::endl;
+                reply = dbus::Message::make_error(
+                            msg,
+                            mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name,
+                            err_str);
+            }
+
+            bus->send(reply);
+        });
+    }
+
+    void handle_move_track(const core::dbus::Message::Ptr& msg)
+    {
+        media::Track::Id id;
+        media::Track::Id to;
+        msg->reader() >> id >> to;
+
+        core::dbus::Message::Ptr reply;
+        try {
+            const bool ret = impl->move_track(id, to);
+            if (!ret)
+            {
+                const std::string err_str = {"Error: Not moving track " + id +
+                    " to destination " + to};
+                std::cerr << err_str << std::endl;
+                reply = dbus::Message::make_error(
+                        msg,
+                        mpris::TrackList::Error::FailedToMoveTrack::name,
+                        err_str);
+            }
+            else
+            {
+                reply = dbus::Message::make_method_return(msg);
+            }
+        } catch(media::TrackList::Errors::FailedToMoveTrack& e) {
+            reply = dbus::Message::make_error(
+                    msg,
+                    mpris::TrackList::Error::FailedToFindMoveTrackSource::name,
+                    e.what());
+        } catch(media::TrackList::Errors::FailedToFindMoveTrackSource& e) {
+            reply = dbus::Message::make_error(
+                    msg,
+                    mpris::TrackList::Error::FailedToFindMoveTrackSource::name,
+                    e.what());
+        } catch(media::TrackList::Errors::FailedToFindMoveTrackDest& e) {
+            reply = dbus::Message::make_error(
+                    msg,
+                    mpris::TrackList::Error::FailedToFindMoveTrackDest::name,
+                    e.what());
+        }
+
+        bus->send(reply);
     }
 
     void handle_remove_track(const core::dbus::Message::Ptr& msg)
@@ -118,8 +226,63 @@
         media::Track::Id track;
         msg->reader() >> track;
 
+        auto id_it = find(impl->tracks().get().begin(), impl->tracks().get().end(), track);
+        if (id_it == impl->tracks().get().end()) {
+            ostringstream err_str;
+            err_str << "Track " << track << " not found in track list";
+            cout << __PRETTY_FUNCTION__ << " WARNING " << err_str.str() << endl;
+            auto reply = dbus::Message::make_error(
+                            msg,
+                            mpris::TrackList::Error::TrackNotFound::name,
+                            err_str.str());
+            bus->send(reply);
+            return;
+        }
+
+        media::Track::Id next;
+        bool deleting_current = false;
+
+        if (id_it == impl->current_iterator())
+        {
+            cout << "Removing current track" << endl;
+            deleting_current = true;
+
+            if (current_track != empty_iterator)
+            {
+                ++current_track;
+
+                if (current_track == impl->tracks().get().end()
+                            && loop_status == media::Player::LoopStatus::playlist)
+                {
+                    // Removed the last track, current is the first track and make sure that
+                    // the player starts playing it
+                    current_track = impl->tracks().get().begin();
+                }
+
+                if (current_track == impl->tracks().get().end())
+                {
+                    current_track = empty_iterator;
+                    // Nothing else to play, stop playback
+                    impl->emit_on_end_of_tracklist();
+                }
+                else
+                {
+                    next = *current_track;
+                }
+            }
+        }
+        else if (current_track != empty_iterator)
+        {
+            next = *current_track;
+        }
+        id_after_remove = next;
+
+        // Calls reset_current_iterator_if_needed(), which updates the iterator
         impl->remove_track(track);
 
+        if ((not next.empty()) and deleting_current)
+            impl->go_to(next);
+
         auto reply = dbus::Message::make_method_return(msg);
         bus->send(reply);
     }
@@ -130,8 +293,7 @@
         msg->reader() >> track;
 
         current_track = std::find(skeleton.properties.tracks->get().begin(), skeleton.properties.tracks->get().end(), track);
-        const bool toggle_player_state = true;
-        impl->go_to(track, toggle_player_state);
+        impl->go_to(track);
 
         auto reply = dbus::Message::make_method_return(msg);
         bus->send(reply);
@@ -155,17 +317,28 @@
     TrackList::ConstIterator current_track;
     TrackList::ConstIterator empty_iterator;
     media::Player::LoopStatus loop_status;
+    uint64_t current_position;
+    media::Track::Id id_after_remove;
 
     struct Signals
     {
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackAdded, mpris::TrackList::Signals::TrackAdded::ArgumentType> DBusTrackAddedSignal;
+        typedef core::dbus::Signal<mpris::TrackList::Signals::TracksAdded, mpris::TrackList::Signals::TracksAdded::ArgumentType> DBusTracksAddedSignal;
+        typedef core::dbus::Signal<mpris::TrackList::Signals::TrackMoved, mpris::TrackList::Signals::TrackMoved::ArgumentType> DBusTrackMovedSignal;
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackRemoved, mpris::TrackList::Signals::TrackRemoved::ArgumentType> DBusTrackRemovedSignal;
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackChanged, mpris::TrackList::Signals::TrackChanged::ArgumentType> DBusTrackChangedSignal;
+        typedef core::dbus::Signal<
+            mpris::TrackList::Signals::TrackListReset,
+            mpris::TrackList::Signals::TrackListReset::ArgumentType>
+                DBusTrackListResetSignal;
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackListReplaced, mpris::TrackList::Signals::TrackListReplaced::ArgumentType> DBusTrackListReplacedSignal;
 
         Signals(const std::shared_ptr<DBusTrackAddedSignal>& remote_track_added,
+                const std::shared_ptr<DBusTracksAddedSignal>& remote_tracks_added,
+                const std::shared_ptr<DBusTrackMovedSignal>& remote_track_moved,
                 const std::shared_ptr<DBusTrackRemovedSignal>& remote_track_removed,
                 const std::shared_ptr<DBusTrackChangedSignal>& remote_track_changed,
+                const std::shared_ptr<DBusTrackListResetSignal>& remote_track_list_reset,
                 const std::shared_ptr<DBusTrackListReplacedSignal>& remote_track_list_replaced)
         {
             // Connect all of the MPRIS interface signals to be emitted over dbus
@@ -174,11 +347,26 @@
                 remote_track_added->emit(id);
             });
 
+            on_tracks_added.connect([remote_tracks_added](const media::TrackList::ContainerURI &tracks)
+            {
+                remote_tracks_added->emit(tracks);
+            });
+
+            on_track_moved.connect([remote_track_moved](const media::TrackList::TrackIdTuple &ids)
+            {
+                remote_track_moved->emit(ids);
+            });
+
             on_track_removed.connect([remote_track_removed](const media::Track::Id &id)
             {
                 remote_track_removed->emit(id);
             });
 
+            on_track_list_reset.connect([remote_track_list_reset]()
+            {
+                remote_track_list_reset->emit();
+            });
+
             on_track_changed.connect([remote_track_changed](const media::Track::Id &id)
             {
                 remote_track_changed->emit(id);
@@ -191,10 +379,13 @@
         }
 
         core::Signal<Track::Id> on_track_added;
+        core::Signal<TrackList::ContainerURI> on_tracks_added;
+        core::Signal<TrackList::TrackIdTuple> on_track_moved;
         core::Signal<Track::Id> on_track_removed;
+        core::Signal<void> on_track_list_reset;
         core::Signal<Track::Id> on_track_changed;
         core::Signal<TrackList::ContainerTrackIdTuple> on_track_list_replaced;
-        core::Signal<std::pair<Track::Id, bool>> on_go_to_track;
+        core::Signal<Track::Id> on_go_to_track;
         core::Signal<void> on_end_of_tracklist;
     } signals;
 };
@@ -219,6 +410,16 @@
                   std::ref(d),
                   std::placeholders::_1));
 
+    d->object->install_method_handler<mpris::TrackList::AddTracks>(
+        std::bind(&Private::handle_add_tracks_with_uri_at,
+                  std::ref(d),
+                  std::placeholders::_1));
+
+    d->object->install_method_handler<mpris::TrackList::MoveTrack>(
+        std::bind(&Private::handle_move_track,
+                  std::ref(d),
+                  std::placeholders::_1));
+
     d->object->install_method_handler<mpris::TrackList::RemoveTrack>(
         std::bind(&Private::handle_remove_track,
                   std::ref(d),
@@ -239,6 +440,11 @@
 {
 }
 
+/*
+ * NOTE We do not consider the loop status in this function due to the use of it
+ * we do in TrackListSkeleton::next() (the function is used to know whether we
+ * need to wrap when looping is active).
+ */
 bool media::TrackListSkeleton::has_next()
 {
     const auto n_tracks = tracks().get().size();
@@ -252,37 +458,46 @@
     // changed in player_implementation.cpp.
     // To avoid the crash we consider that current_track will be eventually
     // initialized to the first track when current_iterator() gets called.
-    if (d->current_track == d->empty_iterator) {
+    if (d->current_track == d->empty_iterator)
+    {
         if (n_tracks < 2)
             return false;
         else
             return true;
     }
 
-    const auto next_track = std::next(current_iterator());
-    return !is_last_track(next_track);
+    if (shuffle())
+    {
+        auto it = get_current_shuffled();
+        return ++it != shuffled_tracks().end();
+    }
+    else
+    {
+        const auto next_track = std::next(current_iterator());
+        return !is_last_track(next_track);
+    }
 }
 
+/*
+ * NOTE We do not consider the loop status in this function due to the use of it
+ * we do in TrackListSkeleton::previous() (the function is used to know whether we
+ * need to wrap when looping is active).
+ */
 bool media::TrackListSkeleton::has_previous()
 {
     if (tracks().get().empty() || d->current_track == d->empty_iterator)
         return false;
 
-    // If we are looping over the entire list, then there is always a previous track
-    if (d->loop_status == media::Player::LoopStatus::playlist)
-        return true;
-
-    return d->current_track != std::begin(tracks().get());
-}
-
-bool media::TrackListSkeleton::is_first_track(const ConstIterator &it)
-{
-    return it == std::begin(tracks().get());
-}
-
-bool media::TrackListSkeleton::is_last_track(const TrackList::ConstIterator &it)
-{
-    return it == std::end(tracks().get());
+    if (shuffle())
+        return get_current_shuffled() != shuffled_tracks().begin();
+    else
+        return d->current_track != std::begin(tracks().get());
+}
+
+media::TrackList::ConstIterator media::TrackListSkeleton::get_current_shuffled()
+{
+    auto current_id = *current_iterator();
+    return find(shuffled_tracks().begin(), shuffled_tracks().end(), current_id);
 }
 
 media::Track::Id media::TrackListSkeleton::next()
@@ -294,50 +509,67 @@
         return media::Track::Id{};
     }
 
-    const auto next_track = std::next(current_iterator());
-    bool do_go_to_next_track = false;
+    bool go_to_track = false;
 
     // End of the track reached so loop around to the beginning of the track
     if (d->loop_status == media::Player::LoopStatus::track)
     {
         std::cout << "Looping on the current track since LoopStatus is set to track" << std::endl;
-        do_go_to_next_track = true;
+        go_to_track = true;
     }
     // End of the tracklist reached so loop around to the beginning of the tracklist
     else if (d->loop_status == media::Player::LoopStatus::playlist && not has_next())
     {
         std::cout << "Looping on the tracklist since LoopStatus is set to playlist" << std::endl;
-        d->current_track = tracks().get().begin();
-        do_go_to_next_track = true;
+
+        if (shuffle())
+        {
+            const auto id = *shuffled_tracks().begin();
+            set_current_track(id);
+        }
+        else
+        {
+            d->current_track = tracks().get().begin();
+        }
+        go_to_track = true;
     }
     else
     {
-        // Next track is not the last track
-        if (not is_last_track(next_track))
+        if (shuffle())
         {
-            std::cout << "Advancing to next track: " << *(next_track) << std::endl;
-            d->current_track = next_track;
-            do_go_to_next_track = true;
+            auto it = get_current_shuffled();
+            if (++it != shuffled_tracks().end()) {
+                cout << "Advancing to next track: " << *it << endl;
+                set_current_track(*it);
+                go_to_track = true;
+            }
         }
-        // At the end of the tracklist and not set to loop, so we stop advancing the tracklist
         else
         {
-            std::cout << "End of tracklist reached, not advancing to next since LoopStatus is set to none" << std::endl;
-            on_end_of_tracklist()();
+            const auto it = std::next(current_iterator());
+            if (not is_last_track(it))
+            {
+                cout << "Advancing to next track: " << *it << endl;
+                d->current_track = it;
+                go_to_track = true;
+            }
         }
+
     }
 
-    if (do_go_to_next_track)
+    if (go_to_track)
     {
+        cout << "next track id is " << *(current_iterator()) << endl;
         on_track_changed()(*(current_iterator()));
-        // Don't automatically call stop() and play() in player_implementation.cpp on_go_to_track()
-        // since this breaks video playback when using open_uri() (stop() and play() are unwanted in
-        // this scenario since the qtubuntu-media will handle this automatically)
-        const bool toggle_player_state = false;
         const media::Track::Id id = *(current_iterator());
-        const std::pair<const media::Track::Id, bool> p = std::make_pair(id, toggle_player_state);
         // Signal the PlayerImplementation to play the next track
-        on_go_to_track()(p);
+        on_go_to_track()(id);
+    }
+    else
+    {
+        // At the end of the tracklist and not set to loop
+        cout << "End of tracklist reached" << endl;
+        on_end_of_tracklist()();
     }
 
     return *(current_iterator());
@@ -352,48 +584,69 @@
         return media::Track::Id{};
     }
 
-    bool do_go_to_previous_track = false;
+    bool go_to_track = false;
+    // Position is measured in nanoseconds
+    const uint64_t max_position = 5 * UINT64_C(1000000000);
 
+    // If we're playing the current track for > max_position time then
+    // repeat it from the beginning
+    if (d->current_position > max_position)
+    {
+        std::cout << "Repeating current track..." << std::endl;
+        go_to_track = true;
+    }
     // Loop on the current track forever
-    if (d->loop_status == media::Player::LoopStatus::track)
+    else if (d->loop_status == media::Player::LoopStatus::track)
     {
         std::cout << "Looping on the current track..." << std::endl;
-        do_go_to_previous_track = true;
+        go_to_track = true;
     }
     // Loop over the whole playlist and repeat
-    else if (d->loop_status == media::Player::LoopStatus::playlist && is_first_track(current_iterator()))
+    else if (d->loop_status == media::Player::LoopStatus::playlist && not has_previous())
     {
         std::cout << "Looping on the entire TrackList..." << std::endl;
-        d->current_track = std::prev(tracks().get().end());
-        do_go_to_previous_track = true;
+
+        if (shuffle())
+        {
+            const auto id = *std::prev(shuffled_tracks().end());
+            set_current_track(id);
+        }
+        else
+        {
+            d->current_track = std::prev(tracks().get().end());
+        }
+
+        go_to_track = true;
     }
     else
     {
-        // Current track is not the first track
-        if (not is_first_track(current_iterator()))
+        if (shuffle())
+        {
+            auto it = get_current_shuffled();
+            if (it != shuffled_tracks().begin()) {
+                set_current_track(*(--it));
+                go_to_track = true;
+            }
+        }
+        else if (not is_first_track(current_iterator()))
         {
             // Keep returning the previous track until the first track is reached
             d->current_track = std::prev(current_iterator());
-            do_go_to_previous_track = true;
-        }
-        // At the beginning of the tracklist and not set to loop, so we stop advancing the tracklist
-        else
-        {
-            std::cout << "Beginning of tracklist reached, not advancing to previous since LoopStatus is set to none" << std::endl;
-            on_end_of_tracklist()();
+            go_to_track = true;
         }
     }
 
-    if (do_go_to_previous_track)
+    if (go_to_track)
     {
         on_track_changed()(*(current_iterator()));
-        // Don't automatically call stop() and play() in player_implementation.cpp on_go_to_track()
-        // since this breaks video playback when using open_uri() (stop() and play() are unwanted in
-        // this scenario since the qtubuntu-media will handle this automatically)
-        const bool toggle_player_state = false;
         const media::Track::Id id = *(current_iterator());
-        const std::pair<const media::Track::Id, bool> p = std::make_pair(id, toggle_player_state);
-        on_go_to_track()(p);
+        on_go_to_track()(id);
+    }
+    else
+    {
+        // At the beginning of the tracklist and not set to loop
+        cout << "Beginning of tracklist reached" << endl;
+        on_end_of_tracklist()();
     }
 
     return *(current_iterator());
@@ -421,14 +674,45 @@
     return d->current_track;
 }
 
+bool media::TrackListSkeleton::update_current_iterator(const TrackList::ConstIterator &it)
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    if (it == tracks().get().end())
+        return false;
+
+    std::cout << "Updating current_track iterator" << std::endl;
+    d->current_track = it;
+
+    return true;
+}
+
 void media::TrackListSkeleton::reset_current_iterator_if_needed()
 {
-    // If all tracks got removed then we need to keep a sane current
-    // iterator for further use.
-    if (tracks().get().empty())
+    d->current_track = find(tracks().get().begin(), tracks().get().end(), d->id_after_remove);
+    if (d->current_track == tracks().get().end())
         d->current_track = d->empty_iterator;
 }
 
+media::Track::Id media::TrackListSkeleton::get_current_track(void)
+{
+    if (d->current_track == d->empty_iterator || tracks().get().empty())
+        return media::Track::Id{};
+
+    return *(current_iterator());
+}
+
+void media::TrackListSkeleton::set_current_track(const media::Track::Id& id)
+{
+    const auto id_it = find(tracks().get().begin(), tracks().get().end(), id);
+    if (id_it != tracks().get().end())
+        d->current_track = id_it;
+}
+
+void media::TrackListSkeleton::emit_on_end_of_tracklist()
+{
+    on_end_of_tracklist()();
+}
+
 const core::Property<bool>& media::TrackListSkeleton::can_edit_tracks() const
 {
     return *d->skeleton.properties.can_edit_tracks;
@@ -444,6 +728,11 @@
     return *d->skeleton.properties.tracks;
 }
 
+void media::TrackListSkeleton::on_position_changed(uint64_t position)
+{
+    d->current_position = position;
+}
+
 void media::TrackListSkeleton::on_loop_status_changed(const media::Player::LoopStatus& loop_status)
 {
     d->loop_status = loop_status;
@@ -456,21 +745,9 @@
 
 void media::TrackListSkeleton::on_shuffle_changed(bool shuffle)
 {
-    if (shuffle)
-        shuffle_tracks();
-    else
-    {
-        // Save the current Track::Id of what's currently playing to restore after unshuffle
-        const media::Track::Id current_id = *(current_iterator());
-
-        unshuffle_tracks();
-
-        // Since we use assign() in unshuffle_tracks, which invalidates existing iterators, we need
-        // to make sure that current is pointing to the right place
-        auto it = std::find(tracks().get().begin(), tracks().get().end(), current_id);
-        if (it != tracks().get().end())
-            d->current_track = it;
-    }
+    cout << __PRETTY_FUNCTION__ << endl;
+
+    set_shuffle(shuffle);
 }
 
 const core::Property<media::TrackList::Container>& media::TrackListSkeleton::tracks() const
@@ -490,17 +767,32 @@
     return d->signals.on_track_added;
 }
 
+const core::Signal<media::TrackList::ContainerURI>& media::TrackListSkeleton::on_tracks_added() const
+{
+    return d->signals.on_tracks_added;
+}
+
+const core::Signal<media::TrackList::TrackIdTuple>& media::TrackListSkeleton::on_track_moved() const
+{
+    return d->signals.on_track_moved;
+}
+
 const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_removed() const
 {
     return d->signals.on_track_removed;
 }
 
+const core::Signal<void>& media::TrackListSkeleton::on_track_list_reset() const
+{
+    return d->signals.on_track_list_reset;
+}
+
 const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_changed() const
 {
     return d->signals.on_track_changed;
 }
 
-const core::Signal<std::pair<media::Track::Id, bool>>& media::TrackListSkeleton::on_go_to_track() const
+const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_go_to_track() const
 {
     return d->signals.on_go_to_track;
 }
@@ -520,17 +812,32 @@
     return d->signals.on_track_added;
 }
 
+core::Signal<media::TrackList::ContainerURI>& media::TrackListSkeleton::on_tracks_added()
+{
+    return d->signals.on_tracks_added;
+}
+
+core::Signal<media::TrackList::TrackIdTuple>& media::TrackListSkeleton::on_track_moved()
+{
+    return d->signals.on_track_moved;
+}
+
 core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_removed()
 {
     return d->signals.on_track_removed;
 }
 
+core::Signal<void>& media::TrackListSkeleton::on_track_list_reset()
+{
+    return d->signals.on_track_list_reset;
+}
+
 core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_changed()
 {
     return d->signals.on_track_changed;
 }
 
-core::Signal<std::pair<media::Track::Id, bool>>& media::TrackListSkeleton::on_go_to_track()
+core::Signal<media::Track::Id>& media::TrackListSkeleton::on_go_to_track()
 {
     return d->signals.on_go_to_track;
 }

=== modified file 'src/core/media/track_list_skeleton.h'
--- src/core/media/track_list_skeleton.h	2015-09-28 13:20:01 +0000
+++ src/core/media/track_list_skeleton.h	2015-12-23 14:19:01 +0000
@@ -54,31 +54,51 @@
     core::Signal<ContainerTrackIdTuple>& on_track_list_replaced();
     const core::Signal<Track::Id>& on_track_added() const;
     core::Signal<Track::Id>& on_track_added();
+    const core::Signal<ContainerURI>& on_tracks_added() const;
+    core::Signal<ContainerURI>& on_tracks_added();
+    const core::Signal<TrackIdTuple>& on_track_moved() const;
+    core::Signal<TrackIdTuple>& on_track_moved();
     const core::Signal<Track::Id>& on_track_removed() const;
+    const core::Signal<void>& on_track_list_reset() const;
     const core::Signal<Track::Id>& on_track_changed() const;
     core::Signal<Track::Id>& on_track_changed();
-    const core::Signal<std::pair<Track::Id, bool>>& on_go_to_track() const;
-    core::Signal<std::pair<Track::Id, bool>>& on_go_to_track();
+    const core::Signal<Track::Id>& on_go_to_track() const;
+    core::Signal<Track::Id>& on_go_to_track();
     const core::Signal<void>& on_end_of_tracklist() const;
     core::Signal<void>& on_end_of_tracklist();
     core::Signal<Track::Id>& on_track_removed();
+    core::Signal<void>& on_track_list_reset();
 
     core::Property<Container>& tracks();
     void on_loop_status_changed(const core::ubuntu::media::Player::LoopStatus& loop_status);
     core::ubuntu::media::Player::LoopStatus loop_status() const;
 
+    void on_position_changed(uint64_t position);
+
     /** Gets called when the shuffle property on the Player interface is changed
      * by the client */
     void on_shuffle_changed(bool shuffle);
 
+    virtual void set_shuffle(bool shuffle) = 0;
+    virtual bool shuffle() = 0;
+    virtual const media::TrackList::Container& shuffled_tracks() = 0;
+
 protected:
-    inline bool is_first_track(const ConstIterator &it);
-    inline bool is_last_track(const ConstIterator &it);
-    inline const TrackList::ConstIterator& current_iterator();
+    inline bool is_first_track(const ConstIterator &it)
+    { return it == std::begin(tracks().get()); }
+    inline bool is_last_track(const ConstIterator &it)
+    { return it == std::end(tracks().get()); }
+    const TrackList::ConstIterator& current_iterator();
+    bool update_current_iterator(const TrackList::ConstIterator &it);
     void reset_current_iterator_if_needed();
+    media::Track::Id get_current_track(void);
+    void set_current_track(const media::Track::Id& id);
+    TrackList::ConstIterator get_current_shuffled();
 
     core::Property<bool>& can_edit_tracks();
 
+    void emit_on_end_of_tracklist();
+
     void reset();
 
 private:

=== modified file 'src/core/media/track_list_stub.cpp'
--- src/core/media/track_list_stub.cpp	2015-07-27 22:15:33 +0000
+++ src/core/media/track_list_stub.cpp	2015-12-23 14:19:01 +0000
@@ -52,7 +52,10 @@
           signals
           {
               object->get_signal<mpris::TrackList::Signals::TrackAdded>(),
+              object->get_signal<mpris::TrackList::Signals::TracksAdded>(),
+              object->get_signal<mpris::TrackList::Signals::TrackMoved>(),
               object->get_signal<mpris::TrackList::Signals::TrackRemoved>(),
+              object->get_signal<mpris::TrackList::Signals::TrackListReset>(),
               object->get_signal<mpris::TrackList::Signals::TrackListReplaced>(),
               object->get_signal<mpris::TrackList::Signals::TrackChanged>()
           }
@@ -70,22 +73,37 @@
     struct Signals
     {
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackAdded, mpris::TrackList::Signals::TrackAdded::ArgumentType> DBusTrackAddedSignal;
+        typedef core::dbus::Signal<mpris::TrackList::Signals::TracksAdded, mpris::TrackList::Signals::TracksAdded::ArgumentType> DBusTracksAddedSignal;
+        typedef core::dbus::Signal<mpris::TrackList::Signals::TrackMoved, mpris::TrackList::Signals::TrackMoved::ArgumentType> DBusTrackMovedSignal;
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackRemoved, mpris::TrackList::Signals::TrackRemoved::ArgumentType> DBusTrackRemovedSignal;
+        typedef core::dbus::Signal<
+            mpris::TrackList::Signals::TrackListReset,
+            mpris::TrackList::Signals::TrackListReset::ArgumentType>
+                DBusTrackListResetSignal;
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackListReplaced, mpris::TrackList::Signals::TrackListReplaced::ArgumentType> DBusTrackListReplacedSignal;
         typedef core::dbus::Signal<mpris::TrackList::Signals::TrackChanged, mpris::TrackList::Signals::TrackChanged::ArgumentType> DBusTrackChangedSignal;
 
         Signals(const std::shared_ptr<DBusTrackAddedSignal>& track_added,
+                const std::shared_ptr<DBusTracksAddedSignal>& tracks_added,
+                const std::shared_ptr<DBusTrackMovedSignal>& track_moved,
                 const std::shared_ptr<DBusTrackRemovedSignal>& track_removed,
+                const std::shared_ptr<DBusTrackListResetSignal>& track_list_reset,
                 const std::shared_ptr<DBusTrackListReplacedSignal>& track_list_replaced,
                 const std::shared_ptr<DBusTrackChangedSignal>& track_changed)
             : on_track_added(),
+              on_tracks_added(),
+              on_track_moved(),
               on_track_removed(),
+              on_track_list_reset(),
               on_track_list_replaced(),
               on_track_changed(),
               dbus
               {
                   track_added,
+                  tracks_added,
+                  track_moved,
                   track_removed,
+                  track_list_reset,
                   track_list_replaced,
                   track_changed,
               }
@@ -96,15 +114,33 @@
                 on_track_added(id);
             });
 
+            dbus.on_tracks_added->connect([this](const media::TrackList::ContainerURI& tracks)
+            {
+                std::cout << "OnTracksAdded signal arrived via the bus." << std::endl;
+                on_tracks_added(tracks);
+            });
+
+            dbus.on_track_moved->connect([this](const media::TrackList::TrackIdTuple& ids)
+            {
+                std::cout << "OnTrackMoved signal arrived via the bus." << std::endl;
+                on_track_moved(ids);
+            });
+
             dbus.on_track_removed->connect([this](const Track::Id& id)
             {
                 std::cout << "OnTrackRemoved signal arrived via the bus." << std::endl;
                 on_track_removed(id);
             });
 
+            dbus.on_track_list_reset->connect([this](void)
+            {
+                std::cout << "OnTrackListReset signal arrived via the bus." << std::endl;
+                on_track_list_reset();
+            });
+
             dbus.on_track_list_replaced->connect([this](const media::TrackList::ContainerTrackIdTuple& list)
             {
-                std::cout << "OnTrackListRemoved signal arrived via the bus." << std::endl;
+                std::cout << "OnTrackListReplaced signal arrived via the bus." << std::endl;
                 on_track_list_replaced(list);
             });
 
@@ -116,16 +152,22 @@
         }
 
         core::Signal<Track::Id> on_track_added;
+        core::Signal<media::TrackList::ContainerURI> on_tracks_added;
+        core::Signal<media::TrackList::TrackIdTuple> on_track_moved;
         core::Signal<Track::Id> on_track_removed;
+        core::Signal<void> on_track_list_reset;
         core::Signal<media::TrackList::ContainerTrackIdTuple> on_track_list_replaced;
         core::Signal<Track::Id> on_track_changed;
-        core::Signal<std::pair<Track::Id, bool>> on_go_to_track;
+        core::Signal<Track::Id> on_go_to_track;
         core::Signal<void> on_end_of_tracklist;
 
         struct DBus
         {
             std::shared_ptr<DBusTrackAddedSignal> on_track_added;
+            std::shared_ptr<DBusTracksAddedSignal> on_tracks_added;
+            std::shared_ptr<DBusTrackMovedSignal> on_track_moved;
             std::shared_ptr<DBusTrackRemovedSignal> on_track_removed;
+            std::shared_ptr<DBusTrackListResetSignal> on_track_list_reset;
             std::shared_ptr<DBusTrackListReplacedSignal> on_track_list_replaced;
             std::shared_ptr<DBusTrackChangedSignal> on_track_changed;
         } dbus;
@@ -184,16 +226,62 @@
 
 void media::TrackListStub::add_track_with_uri_at(
         const media::Track::UriType& uri,
-        const media::Track::Id& id,
+        const media::Track::Id& position,
         bool make_current)
 {
     auto op = d->object->invoke_method_synchronously<mpris::TrackList::AddTrack, void>(
                 uri,
-                id,
+                position,
                 make_current);
 
     if (op.is_error())
-        throw std::runtime_error("Problem adding track: " + op.error());
+    {
+        if (op.error().name() ==
+                mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name)
+            throw media::TrackList::Errors::InsufficientPermissionsToAddTrack{};
+        else
+            throw std::runtime_error{op.error().print()};
+    }
+}
+
+void media::TrackListStub::add_tracks_with_uri_at(const ContainerURI& uris, const Track::Id& position)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::TrackList::AddTracks, void>(
+                uris,
+                position);
+
+    if (op.is_error())
+    {
+        if (op.error().name() ==
+                mpris::TrackList::Error::InsufficientPermissionsToAddTrack::name)
+            throw media::TrackList::Errors::InsufficientPermissionsToAddTrack{};
+        else
+            throw std::runtime_error{op.error().print()};
+    }
+}
+
+bool media::TrackListStub::move_track(const media::Track::Id& id, const media::Track::Id& to)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::TrackList::MoveTrack, void>(id, to);
+
+    if (op.is_error())
+    {
+        if (op.error().name() ==
+                mpris::TrackList::Error::FailedToMoveTrack::name)
+            throw media::TrackList::Errors::FailedToMoveTrack{};
+        else if (op.error().name() ==
+                mpris::TrackList::Error::FailedToFindMoveTrackSource::name)
+            throw media::TrackList::Errors::FailedToFindMoveTrackSource{op.error().print()};
+        else if (op.error().name() ==
+                mpris::TrackList::Error::FailedToFindMoveTrackDest::name)
+            throw media::TrackList::Errors::FailedToFindMoveTrackDest{op.error().print()};
+        else
+            throw std::runtime_error{op.error().print()};
+
+        return false;
+    }
+
+    return true;
 }
 
 void media::TrackListStub::remove_track(const media::Track::Id& track)
@@ -202,14 +290,18 @@
                 track);
 
     if (op.is_error())
-        throw std::runtime_error("Problem removing track: " + op.error());
+    {
+        if (op.error().name() ==
+                mpris::TrackList::Error::TrackNotFound::name)
+            throw media::TrackList::Errors::TrackNotFound{};
+        else
+            throw std::runtime_error{"Problem removing track: " + op.error().print()};
+    }
 }
 
-void media::TrackListStub::go_to(const media::Track::Id& track, bool toggle_player_state)
+void media::TrackListStub::go_to(const media::Track::Id& track)
 {
-    (void) toggle_player_state;
-    auto op = d->object->invoke_method_synchronously<mpris::TrackList::GoTo, void>(
-                track);
+    auto op = d->object->invoke_method_synchronously<mpris::TrackList::GoTo, void>(track);
 
     if (op.is_error())
         throw std::runtime_error("Problem adding track: " + op.error());
@@ -227,16 +319,6 @@
     return media::Track::Id{"/empty/track/id"};
 }
 
-void media::TrackListStub::shuffle_tracks()
-{
-    std::cerr << "shuffle_tracks() does nothing from the client side" << std::endl;
-}
-
-void media::TrackListStub::unshuffle_tracks()
-{
-    std::cerr << "unshuffle_tracks() does nothing from the client side" << std::endl;
-}
-
 void media::TrackListStub::reset()
 {
     auto op = d->object->invoke_method_synchronously<mpris::TrackList::Reset, void>();
@@ -255,17 +337,32 @@
     return d->signals.on_track_added;
 }
 
+const core::Signal<media::TrackList::ContainerURI>& media::TrackListStub::on_tracks_added() const
+{
+    return d->signals.on_tracks_added;
+}
+
+const core::Signal<media::TrackList::TrackIdTuple>& media::TrackListStub::on_track_moved() const
+{
+    return d->signals.on_track_moved;
+}
+
 const core::Signal<media::Track::Id>& media::TrackListStub::on_track_removed() const
 {
     return d->signals.on_track_removed;
 }
 
+const core::Signal<void>& media::TrackListStub::on_track_list_reset() const
+{
+    return d->signals.on_track_list_reset;
+}
+
 const core::Signal<media::Track::Id>& media::TrackListStub::on_track_changed() const
 {
     return d->signals.on_track_changed;
 }
 
-const core::Signal<std::pair<media::Track::Id, bool>>& media::TrackListStub::on_go_to_track() const
+const core::Signal<media::Track::Id>& media::TrackListStub::on_go_to_track() const
 {
     return d->signals.on_go_to_track;
 }

=== modified file 'src/core/media/track_list_stub.h'
--- src/core/media/track_list_stub.h	2015-07-20 20:39:42 +0000
+++ src/core/media/track_list_stub.h	2015-12-23 14:19:01 +0000
@@ -48,23 +48,25 @@
     Track::UriType query_uri_for_track(const Track::Id& id);
 
     void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current);
+    void add_tracks_with_uri_at(const ContainerURI& uris, const Track::Id& position);
+    bool move_track(const Track::Id& id, const Track::Id& to);
     void remove_track(const Track::Id& id);
 
-    void go_to(const Track::Id& track, bool toggle_player_state);
+    void go_to(const Track::Id& track);
 
     Track::Id next();
     Track::Id previous();
 
-    void shuffle_tracks();
-    void unshuffle_tracks();
-
     void reset();
 
     const core::Signal<ContainerTrackIdTuple>& on_track_list_replaced() const;
     const core::Signal<Track::Id>& on_track_added() const;
+    const core::Signal<ContainerURI>& on_tracks_added() const;
+    const core::Signal<TrackIdTuple>& on_track_moved() const;
     const core::Signal<Track::Id>& on_track_removed() const;
+    const core::Signal<void>& on_track_list_reset() const;
     const core::Signal<Track::Id>& on_track_changed() const;
-    const core::Signal<std::pair<Track::Id, bool>>& on_go_to_track() const;
+    const core::Signal<Track::Id>& on_go_to_track() const;
     const core::Signal<void>& on_end_of_tracklist() const;
 
 private:

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-03-25 14:30:47 +0000
+++ tests/CMakeLists.txt	2015-12-23 14:19:01 +0000
@@ -50,6 +50,6 @@
     "COM_UBUNTU_MEDIA_SERVICE_AUDIO_SINK_NAME=fakesink"
 )
 
-# add_subdirectory(acceptance-tests)
+#add_subdirectory(acceptance-tests)
 add_subdirectory(test-track-list)
 add_subdirectory(unit-tests)

=== modified file 'tests/acceptance-tests/service.cpp'
--- tests/acceptance-tests/service.cpp	2015-03-03 22:41:22 +0000
+++ tests/acceptance-tests/service.cpp	2015-12-23 14:19:01 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013-2014 Canonical Ltd.
+ * Copyright © 2013-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License version 3,
@@ -26,15 +26,13 @@
 
 #include "test_data.h"
 
-#include <core/testing/cross_process_sync.h>
-#include <core/testing/fork_and_run.h>
-
 #include <gtest/gtest.h>
 
 #include <cstdio>
 
 #include <condition_variable>
 #include <functional>
+#include <iostream>
 #include <thread>
 
 namespace media = core::ubuntu::media;
@@ -70,382 +68,121 @@
 }
 }
 
-TEST(MusicService, DISABLED_accessing_and_creating_a_session_works)
-{
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_session(media::Player::Client::default_configuration());
-
-        EXPECT_TRUE(session != nullptr);
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
-}
-
-TEST(MusicService, DISABLED_accessing_and_creating_a_fixed_session_works)
-{
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_fixed_session("com.ubuntu.test-session", media::Player::Client::default_configuration());
-
-        EXPECT_TRUE(session != nullptr);
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
-}
-
-TEST(MusicService, DISABLED_resuming_a_session_works)
-{
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_session(media::Player::Client::default_configuration());
-
-        EXPECT_TRUE(session != nullptr);
-
-        auto resumed_session = service->resume_session(session->key());
-
-        EXPECT_TRUE(resumed_session != nullptr);
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
-}
-
-TEST(MusicService, DISABLED_remotely_querying_track_meta_data_works)
-{
-    const std::string test_file{"/tmp/test-audio.ogg"};
-    const std::string test_file_uri{"file:///tmp/test-audio.ogg"};
-    std::remove(test_file.c_str());
-    ASSERT_TRUE(test::copy_test_media_file_to("test-audio.ogg", test_file));
-
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        static const media::Track::UriType uri{"file:///tmp/test-audio.ogg"};
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_session(media::Player::Client::default_configuration());
-        auto track_list = session->track_list();
-
-        track_list->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), false);
-
-        EXPECT_EQ(std::uint32_t{1}, track_list->tracks()->size());
-
-        auto md = track_list->query_meta_data_for_track(track_list->tracks()->front());
-
-        for (auto pair : *md)
-        {
-            std::cout << pair.first << " -> " << pair.second << std::endl;
-        }
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
-}
-
-TEST(MusicService, DISABLED_play_pause_seek_after_open_uri_works)
-{
-    const std::string test_file{"/tmp/test-audio-1.ogg"};
-    std::remove(test_file.c_str());
-    ASSERT_TRUE(test::copy_test_media_file_to("test-audio-1.ogg", test_file));
-
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        static const media::Track::UriType uri{"file:///tmp/test-audio-1.ogg"};
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_session(media::Player::Client::default_configuration());
-
-        EXPECT_EQ(true, session->can_play().get());
-        EXPECT_EQ(true, session->can_pause().get());
-        EXPECT_EQ(true, session->can_seek().get());
-        EXPECT_EQ(true, session->can_go_previous().get());
-        EXPECT_EQ(true, session->can_go_next().get());
-        EXPECT_EQ(media::Player::PlaybackStatus::null, session->playback_status());
-        EXPECT_EQ(media::Player::LoopStatus::none, session->loop_status());
-        EXPECT_NEAR(1.f, session->playback_rate().get(), 1E-5);
-        EXPECT_EQ(true, session->is_shuffle());
-        EXPECT_EQ(true, session->track_list()->can_edit_tracks().get());
-
-        EXPECT_TRUE(session->open_uri(uri));
-
-        core::testing::WaitableStateTransition<media::Player::PlaybackStatus>
-                state_transition(
-                    media::Player::stopped);
-
-        session->playback_status().changed().connect(
-            std::bind(&core::testing::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
-                      std::ref(state_transition),
-                      std::placeholders::_1));
-
-        session->play();
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
-        session->stop();
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_EQ(media::Player::PlaybackStatus::stopped, session->playback_status());
-        session->play();
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
-        session->pause();
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_EQ(media::Player::PlaybackStatus::paused, session->playback_status());
-        session->stop();
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_EQ(media::Player::PlaybackStatus::stopped, session->playback_status());
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
-}
-
-TEST(MusicService, DISABLED_get_position_duration_work)
-{
-    const std::string test_file{"/tmp/test-audio-1.ogg"};
-    std::remove(test_file.c_str());
-    ASSERT_TRUE(test::copy_test_media_file_to("test-audio-1.ogg", test_file));
-
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        static const media::Track::UriType uri{"file:///tmp/test-audio-1.ogg"};
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_session(media::Player::Client::default_configuration());
-
-        EXPECT_TRUE(session->open_uri(uri));
-
-        core::testing::WaitableStateTransition<media::Player::PlaybackStatus>
-                state_transition(
-                    media::Player::stopped);
-
-        session->playback_status().changed().connect(
-            std::bind(&core::testing::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
-                      std::ref(state_transition),
-                      std::placeholders::_1));
-
-        session->play();
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_EQ(media::Player::PlaybackStatus::playing, session->playback_status());
-        sleep_for(std::chrono::seconds{1});
-        EXPECT_TRUE(session->position() > 1e9);
-        EXPECT_TRUE(session->duration() > 1e9);
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
-}
-
-TEST(MusicService, DISABLED_starting_playback_on_non_empty_playqueue_works)
-{
-    const std::string test_file{"/tmp/test-audio-1.ogg"};
-    std::remove(test_file.c_str());
-    ASSERT_TRUE(test::copy_test_media_file_to("test-audio-1.ogg", test_file));
-
-    core::testing::CrossProcessSync sync_service_start;
-
-    auto service = [this, &sync_service_start]()
-    {
-        SigTermCatcher sc;
-
-        auto service = std::make_shared<media::ServiceImplementation>();
-        std::thread t([&service](){service->run();});
-
-        sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
-
-        sc.wait_for_signal(); service->stop();
-
-        if (t.joinable())
-            t.join();
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    auto client = [this, &sync_service_start]()
-    {
-        sync_service_start.wait_for_signal_ready_for(std::chrono::milliseconds{500});
-
-        static const media::Track::UriType uri{"file:///tmp/test-audio-1.ogg"};
-        static const bool dont_make_current{false};
-
-        auto service = media::Service::Client::instance();
-        auto session = service->create_session(media::Player::Client::default_configuration());
-
-        EXPECT_EQ(true, session->can_play().get());
-        EXPECT_EQ(true, session->can_play().get());
-        EXPECT_EQ(true, session->can_pause().get());
-        EXPECT_EQ(true, session->can_seek().get());
-        EXPECT_EQ(true, session->can_go_previous().get());
-        EXPECT_EQ(true, session->can_go_next().get());
-        EXPECT_EQ(media::Player::PlaybackStatus::null, session->playback_status());
-        EXPECT_EQ(media::Player::LoopStatus::none, session->loop_status());
-        EXPECT_NEAR(1.f, session->playback_rate().get(), 1E-5);
-        EXPECT_EQ(true, session->is_shuffle());
-        EXPECT_EQ(true, session->track_list()->can_edit_tracks().get());
-
-        session->track_list()->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), dont_make_current);
-
-        EXPECT_EQ(std::uint32_t{1}, session->track_list()->tracks()->size());
-
-        core::testing::WaitableStateTransition<media::Player::PlaybackStatus>
-                state_transition(
-                    media::Player::stopped);
-
-        session->playback_status().changed().connect(
-            std::bind(&core::testing::WaitableStateTransition<media::Player::PlaybackStatus>::trigger,
-                      std::ref(state_transition),
-                      std::placeholders::_1));
-
-        session->play();
-
-        EXPECT_TRUE(state_transition.wait_for_state_for(
-                        media::Player::playing,
-                        std::chrono::milliseconds{2000}));
-
-        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
-    };
-
-    EXPECT_EQ(core::testing::ForkAndRunResult::empty,
-              core::testing::fork_and_run(service, client));
+TEST(MediaService, move_track_in_tracklist_works)
+{
+    auto service = media::Service::Client::instance();
+    auto session = service->create_session(media::Player::Client::default_configuration());
+    EXPECT_TRUE(session != nullptr);
+
+    std::vector<media::Track::Id> ids;
+
+    auto tracklist = session->track_list();
+
+    // Catch the new track Ids that are assigned each track that's added
+    core::Connection c = tracklist->on_track_added().connect([&ids](const media::Track::Id &new_id)
+    {
+        std::cout << "track added: " << new_id << std::endl;
+        ids.push_back(new_id);
+    });
+
+    const media::Track::UriType uri1{"file:///tmp/test-audio.ogg"};
+    const media::Track::UriType uri2{"file:///tmp/test-audio1.ogg"};
+    const media::Track::UriType uri3{"file:///tmp/test.mp3"};
+    const media::Track::UriType uri4{"file:///tmp/test-video.ogg"};
+
+    tracklist->add_track_with_uri_at(uri1, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri2, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri3, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri4, media::TrackList::after_empty_track(), false);
+    EXPECT_EQ(std::uint32_t{4}, tracklist->tracks()->size());
+
+    std::cout << "ids.at(0): " << ids.at(1) << std::endl;
+    std::cout << "ids.at(2): " << ids.at(2) << std::endl;
+    // Move track 3 into the second position in the TrackList
+    tracklist->move_track(ids.at(2), ids.at(1));
+
+    // Original list order and current order should be different
+    EXPECT_NE(ids, tracklist->tracks().get());
+    EXPECT_EQ(ids[1], tracklist->tracks()->at(2));
+    EXPECT_EQ(ids[2], tracklist->tracks()->at(1));
+}
+
+TEST(MediaService, move_track_to_first_position_in_tracklist_works)
+{
+    auto service = media::Service::Client::instance();
+    auto session = service->create_session(media::Player::Client::default_configuration());
+    EXPECT_TRUE(session != nullptr);
+
+    std::vector<media::Track::Id> ids;
+
+    auto tracklist = session->track_list();
+
+    // Catch the new track Ids that are assigned each track that's added
+    core::Connection c = tracklist->on_track_added().connect([&ids](const media::Track::Id &new_id)
+    {
+        std::cout << "track added: " << new_id << std::endl;
+        ids.push_back(new_id);
+    });
+
+    const media::Track::UriType uri1{"file:///tmp/test-audio.ogg"};
+    const media::Track::UriType uri2{"file:///tmp/test-audio1.ogg"};
+    const media::Track::UriType uri3{"file:///tmp/test.mp3"};
+    const media::Track::UriType uri4{"file:///tmp/test-video.ogg"};
+
+    tracklist->add_track_with_uri_at(uri1, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri2, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri3, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri4, media::TrackList::after_empty_track(), false);
+    EXPECT_EQ(std::uint32_t{4}, tracklist->tracks()->size());
+
+    std::cout << "ids.at(0): " << ids.at(0) << std::endl;
+    std::cout << "ids.at(2): " << ids.at(2) << std::endl;
+    // Move track 3 into the first position in the TrackList
+    tracklist->move_track(ids.at(2), ids.at(0));
+
+    // Original list order and current order should be different
+    EXPECT_NE(ids, tracklist->tracks().get());
+    EXPECT_EQ(ids[2], tracklist->tracks()->at(0));
+    EXPECT_EQ(ids[0], tracklist->tracks()->at(1));
+}
+
+TEST(MediaService, move_track_to_last_position_in_tracklist_works)
+{
+    auto service = media::Service::Client::instance();
+    auto session = service->create_session(media::Player::Client::default_configuration());
+    EXPECT_TRUE(session != nullptr);
+
+    std::vector<media::Track::Id> ids;
+
+    auto tracklist = session->track_list();
+
+    // Catch the new track Ids that are assigned each track that's added
+    core::Connection c = tracklist->on_track_added().connect([&ids](const media::Track::Id &new_id)
+    {
+        std::cout << "track added: " << new_id << std::endl;
+        ids.push_back(new_id);
+    });
+
+    const media::Track::UriType uri1{"file:///tmp/test-audio.ogg"};
+    const media::Track::UriType uri2{"file:///tmp/test-audio1.ogg"};
+    const media::Track::UriType uri3{"file:///tmp/test.mp3"};
+    const media::Track::UriType uri4{"file:///tmp/test-video.ogg"};
+
+    tracklist->add_track_with_uri_at(uri1, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri2, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri3, media::TrackList::after_empty_track(), false);
+    tracklist->add_track_with_uri_at(uri4, media::TrackList::after_empty_track(), false);
+    EXPECT_EQ(std::uint32_t{4}, tracklist->tracks()->size());
+
+    sleep(1);
+
+    std::cout << "ids.at(0): " << ids.at(0) << std::endl;
+    std::cout << "ids.at(3): " << ids.at(3) << std::endl;
+    // Move track 3 into the first position in the TrackList
+    tracklist->move_track(ids.at(0), ids.at(3));
+
+    // Original list order and current order should be different
+    EXPECT_NE(ids, tracklist->tracks().get());
+    EXPECT_EQ(ids[1], tracklist->tracks()->at(0));
+    EXPECT_EQ(ids[0], tracklist->tracks()->at(3));
 }

=== modified file 'tests/test-track-list/test_track_list.cpp'
--- tests/test-track-list/test_track_list.cpp	2015-04-20 15:56:26 +0000
+++ tests/test-track-list/test_track_list.cpp	2015-12-23 14:19:01 +0000
@@ -257,9 +257,8 @@
 
         const media::Track::Id id{m_hubTrackList->tracks().get()[3]};
         cout << "Going straight to the Track with Id " << id << std::endl;
-        const bool toggle_player_state = true;
-        m_hubTrackList->go_to(id, toggle_player_state);
-        
+        m_hubTrackList->go_to(id);
+
         cout << "Waiting for third track to finish playing..." << endl;
         wait_for_about_to_finish();
     }

=== modified file 'tests/test-track-list/test_track_list.h'
--- tests/test-track-list/test_track_list.h	2015-04-15 18:29:39 +0000
+++ tests/test-track-list/test_track_list.h	2015-12-23 14:19:01 +0000
@@ -57,7 +57,7 @@
 
     // Takes two uris and confirms that they remain after a detach/reattach
     void test_tracklist_resume(const std::string &uri1, const std::string &uri2, const std::string &uuid);
-    
+
     void test_ensure_tracklist_is_not_empty(const std::string &uri1, const std::string &uri2 = std::string{});
 
     // Takes in one or two files for playback, adds it/them to the TrackList, plays and makes sure