Merge lp:~ricmm/media-hub/session-reattach-nonfixed into lp:media-hub

[Ricardo Mendoza]

Implement session detach/reattach for non-fixed sessions.

[lp:~ricmm/media-hub/session-reattach-nonfixed]

133. By Ricardo Mendoza on 2015-04-10

Remove some logging

134. By Ricardo Mendoza on 2015-04-10

More cleanup

135. By Ricardo Mendoza on 2015-04-10

API bump

136. By Ricardo Mendoza on 2015-04-13

Clean up some whitespace

137. By Ricardo Mendoza on 2015-04-13

Add some docs for the service methods

138. By Ricardo Mendoza on 2015-04-14

Merge lp:~phablet-team/media-hub/tracklist-cli

139. By Ricardo Mendoza on 2015-04-14

Expose UUID interface and implement track list tests

140. By Ricardo Mendoza on 2015-04-15

Address Jim's comments

141. By Ricardo Mendoza on 2015-04-15

Merge parent

142. By Ricardo Mendoza on 2015-04-16

Address review comments and plug through no-impl methods of the Service parts

143. By Ricardo Mendoza on 2015-04-16

Not a reference

144. By Ricardo Mendoza on 2015-04-17

Correctly propagate track list changes from bus to local and viceversa

145. By Ricardo Mendoza on 2015-04-17

Remove printfs

146. By Ricardo Mendoza on 2015-04-17

Revert last changes

147. By Ricardo Mendoza on 2015-04-17

Delete player instance instead of abandoning

148. By Ricardo Mendoza on 2015-04-17

Update tracklist cli for new api

149. By Ricardo Mendoza on 2015-04-17

Merge parent

150. By Ricardo Mendoza on 2015-04-17

Implement full player destruction

151. By Ricardo Mendoza on 2015-04-17

Merge parent

152. By Ricardo Mendoza on 2015-04-17

Syntax error

153. By Ricardo Mendoza on 2015-04-17

Sync test cli

154. By Ricardo Mendoza on 2015-04-17

Merge parent

155. By Ricardo Mendoza on 2015-04-20

Merge parent

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-01-23 13:00:36 +0000
+++ CMakeLists.txt	2015-04-14 02:48:44 +0000
@@ -3,7 +3,7 @@
 project(ubuntu-media-hub)
 
 set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 3)
-set(UBUNTU_MEDIA_HUB_VERSION_MINOR 0)
+set(UBUNTU_MEDIA_HUB_VERSION_MINOR 1)
 set(UBUNTU_MEDIA_HUB_VERSION_PATCH 0)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -fPIC -pthread")

=== modified file 'debian/changelog'
--- debian/changelog	2015-04-02 16:43:42 +0000
+++ debian/changelog	2015-04-14 02:48:44 +0000
@@ -1,3 +1,9 @@
+media-hub (3.1.0) UNRELEASED; urgency=medium
+
+  * Support for signalling player reconnection up the stack.
+
+ -- Ricardo Mendoza <[e-mail]>  Fri, 10 Apr 2015 18:20:32 +0200
+
 media-hub (3.0.0+15.04.20150402-0ubuntu1) vivid; urgency=medium
 
   [ Jim Hodapp ]

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2015-03-11 16:17:23 +0000
+++ include/core/media/player.h	2015-04-14 02:48:44 +0000
@@ -27,6 +27,7 @@
 #include <core/property.h>
 
 #include <chrono>
+#include <iosfwd>
 #include <memory>
 
 namespace core
@@ -125,6 +126,9 @@
     Player& operator=(const Player&) = delete;
     bool operator==(const Player&) const = delete;
 
+    virtual std::string uuid() const = 0;
+    virtual void reconnect() = 0;
+
     virtual std::shared_ptr<TrackList> track_list() = 0;
     virtual PlayerKey key() const = 0;
 
@@ -149,7 +153,7 @@
     virtual const core::Property<PlaybackStatus>& playback_status() const = 0;
     virtual const core::Property<LoopStatus>& loop_status() const = 0;
     virtual const core::Property<PlaybackRate>& playback_rate() const = 0;
-    virtual const core::Property<bool>& is_shuffle() const = 0;
+    virtual const core::Property<bool>& shuffle() const = 0;
     virtual const core::Property<Track::MetaData>& meta_data_for_current_track() const = 0;
     virtual const core::Property<Volume>& volume() const = 0;
     virtual const core::Property<PlaybackRate>& minimum_playback_rate() const = 0;
@@ -162,7 +166,7 @@
 
     virtual core::Property<LoopStatus>& loop_status() = 0;
     virtual core::Property<PlaybackRate>& playback_rate() = 0;
-    virtual core::Property<bool>& is_shuffle() = 0;
+    virtual core::Property<bool>& shuffle() = 0;
     virtual core::Property<Volume>& volume() = 0;
     virtual core::Property<AudioStreamRole>& audio_stream_role() = 0;
     virtual core::Property<Lifetime>& lifetime() = 0;
@@ -178,6 +182,42 @@
     Player();
 
 };
+
+// operator<< pretty prints the given playback status to the given output stream.
+inline std::ostream& operator<<(std::ostream& out, Player::PlaybackStatus status)
+{
+    switch (status)
+    {
+        case Player::PlaybackStatus::null:
+            return out << "PlaybackStatus::null";
+        case Player::PlaybackStatus::ready:
+            return out << "PlaybackStatus::ready";
+        case Player::PlaybackStatus::playing:
+            return out << "PlaybackStatus::playing";
+        case Player::PlaybackStatus::paused:
+            return out << "PlaybackStatus::paused";
+        case Player::PlaybackStatus::stopped:
+            return out << "PlaybackStatus::stopped";
+    }
+
+    return out;
+}
+
+inline std::ostream& operator<<(std::ostream& out, Player::LoopStatus loop_status)
+{
+    switch (loop_status)
+    {
+        case Player::LoopStatus::none:
+            return out << "LoopStatus::none";
+        case Player::LoopStatus::track:
+            return out << "LoopStatus::track";
+        case Player::LoopStatus::playlist:
+            return out << "LoopStatus::playlist";
+    }
+
+    return out;
+}
+
 }
 }
 }

=== modified file 'include/core/media/service.h'
--- include/core/media/service.h	2014-09-30 06:51:15 +0000
+++ include/core/media/service.h	2015-04-14 02:48:44 +0000
@@ -42,9 +42,25 @@
     Service& operator=(const Service&) = delete;
     bool operator==(const Service&) const = delete;
 
+    /** @brief Creates a session with the media-hub service. */
     virtual std::shared_ptr<Player> create_session(const Player::Configuration&) = 0;
+
+    /** @brief Detaches a UUID-identified session for later resuming. */
+    virtual void detach_session(const std::string& uuid, const Player::Configuration&) = 0;
+
+    /** @brief Reattaches to a UUID-identified session that is in detached state. */
+    virtual std::shared_ptr<Player> reattach_session(const std::string& uuid, const Player::Configuration&) = 0;
+
+    /** @brief Asks the service to destroy a session. The session is destroyed when the client exits. */
+    virtual void destroy_session(const std::string& uuid, const Player::Configuration&) = 0;
+
+    /** @brief Creates a fixed-named session with the media-hub service. */
     virtual std::shared_ptr<Player> create_fixed_session(const std::string& name, const Player::Configuration&) = 0;
+
+    /** @brief Resumes a fixed-name session directly by player key. */
     virtual std::shared_ptr<Player> resume_session(Player::PlayerKey) = 0;
+
+    /** @brief Pauses sessions other than the supplied one. */
     virtual void pause_other_sessions(Player::PlayerKey) = 0;
 
   protected:

=== modified file 'include/core/media/track_list.h'
--- include/core/media/track_list.h	2014-02-12 15:53:57 +0000
+++ include/core/media/track_list.h	2015-04-14 02:48:44 +0000
@@ -24,7 +24,8 @@
 #include <core/signal.h>
 
 #include <functional>
-#include <list>
+#include <iosfwd>
+#include <vector>
 #include <memory>
 
 namespace core
@@ -39,6 +40,7 @@
 {
   public:
     typedef std::vector<Track::Id> Container;
+    typedef std::tuple<std::vector<Track::Id>, Track::Id> ContainerTrackIdTuple;
     typedef Container::iterator Iterator;
     typedef Container::const_iterator ConstIterator;
 
@@ -50,23 +52,54 @@
     TrackList& operator=(const TrackList&) = delete;
     bool operator==(const TrackList&) const = delete;
 
+    /** If set to false, calling add_track_with_uri_at or remove_track will have no effect. */
     virtual const core::Property<bool>& can_edit_tracks() const = 0;
+
+    /** An array which contains the identifier of each track in the tracklist, in order. */
     virtual const core::Property<Container>& tracks() const = 0;
 
+    /** Gets all the metadata available for a given Track. */
     virtual Track::MetaData query_meta_data_for_track(const Track::Id& id) = 0;
+
+    /** Adds a URI in the TrackList. */
     virtual void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current) = 0;
+
+    /** Removes a Track from the TrackList. */
     virtual void remove_track(const Track::Id& id) = 0;
 
+    /** Skip to the specified TrackId. */
     virtual void go_to(const Track::Id& track) = 0;
 
-    virtual const core::Signal<void>& on_track_list_replaced() const = 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 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 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<Track::Id>& on_go_to_track() const = 0;
+
 protected:
     TrackList();
 };
+
 }
 }
 }

=== modified file 'src/core/media/engine.h'
--- src/core/media/engine.h	2015-01-26 09:23:41 +0000
+++ src/core/media/engine.h	2015-04-14 02:48:44 +0000
@@ -38,6 +38,7 @@
 
     enum class State
     {
+        no_media,
         ready,
         busy,
         playing,
@@ -75,7 +76,7 @@
 
     virtual const core::Property<State>& state() const = 0;
 
-    virtual bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri) = 0;
+    virtual bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri, bool do_pipeline_reset) = 0;
     virtual bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri, const Player::HeadersType&) = 0;
     // Throws core::ubuntu::media::Player::Error::OutOfProcessBufferStreamingNotSupported if the implementation does not
     // support this feature.

=== modified file 'src/core/media/gstreamer/engine.cpp'
--- src/core/media/gstreamer/engine.cpp	2015-03-11 16:17:23 +0000
+++ src/core/media/gstreamer/engine.cpp	2015-04-14 02:48:44 +0000
@@ -313,12 +313,13 @@
 gstreamer::Engine::Engine() : d(new Private{})
 {
     cout << "Creating a new Engine instance in " << __PRETTY_FUNCTION__ << endl;
-    d->state = media::Engine::State::ready;
+    d->state = media::Engine::State::no_media;
 }
 
 gstreamer::Engine::~Engine()
 {
     stop();
+    d->state = media::Engine::State::no_media;
 }
 
 const std::shared_ptr<media::Engine::MetaDataExtractor>& gstreamer::Engine::meta_data_extractor() const
@@ -331,9 +332,9 @@
     return d->state;
 }
 
-bool gstreamer::Engine::open_resource_for_uri(const media::Track::UriType& uri)
+bool gstreamer::Engine::open_resource_for_uri(const media::Track::UriType& uri, bool do_pipeline_reset)
 {
-    d->playbin.set_uri(uri, core::ubuntu::media::Player::HeadersType{});
+    d->playbin.set_uri(uri, core::ubuntu::media::Player::HeadersType{}, do_pipeline_reset);
     return true;
 }
 
@@ -356,6 +357,7 @@
     {
         d->state = media::Engine::State::playing;
         cout << __PRETTY_FUNCTION__ << endl;
+        cout << "Engine: playing uri: " << d->playbin.uri() << endl;
         d->playback_status_changed(media::Player::PlaybackStatus::playing);
     }
 

=== modified file 'src/core/media/gstreamer/engine.h'
--- src/core/media/gstreamer/engine.h	2015-01-26 09:23:41 +0000
+++ src/core/media/gstreamer/engine.h	2015-04-14 02:48:44 +0000
@@ -33,7 +33,7 @@
 
     const core::Property<State>& state() const;
 
-    bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri);
+    bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri, bool do_pipeline_reset);
     bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri, const core::ubuntu::media::Player::HeadersType& headers);
     void create_video_sink(uint32_t texture_id);
 

=== modified file 'src/core/media/gstreamer/meta_data_extractor.h'
--- src/core/media/gstreamer/meta_data_extractor.h	2014-10-14 20:05:20 +0000
+++ src/core/media/gstreamer/meta_data_extractor.h	2015-04-14 02:48:44 +0000
@@ -177,7 +177,7 @@
             bus.on_new_message.connect(
                     [&](const gstreamer::Bus::Message& msg)
                     {
-                        std::cout << __PRETTY_FUNCTION__ << gst_message_type_get_name(msg.type) << std::endl;
+                        //std::cout << __PRETTY_FUNCTION__ << gst_message_type_get_name(msg.type) << std::endl;
                         if (msg.type == GST_MESSAGE_TAG)
                         {
                             MetaDataExtractor::on_tag_available(msg.detail.tag, meta_data);

=== modified file 'src/core/media/gstreamer/playbin.cpp'
--- src/core/media/gstreamer/playbin.cpp	2015-03-11 16:17:23 +0000
+++ src/core/media/gstreamer/playbin.cpp	2015-04-14 02:48:44 +0000
@@ -24,6 +24,8 @@
 #include <hybris/media/surface_texture_client_hybris.h>
 #include <hybris/media/media_codec_layer.h>
 
+#include <utility>
+
 namespace
 {
 void setup_video_sink_for_buffer_streaming(GstElement* video_sink)
@@ -149,6 +151,7 @@
 void gstreamer::Playbin::reset_pipeline()
 {
     std::cout << __PRETTY_FUNCTION__ << std::endl;
+    //TODO: Don't set state to NULL on playbin when about_to_finish calls next()
     auto ret = gst_element_set_state(pipeline, GST_STATE_NULL);
     switch(ret)
     {
@@ -365,9 +368,11 @@
 
 void gstreamer::Playbin::set_uri(
     const std::string& uri,
-    const core::ubuntu::media::Player::HeadersType& headers = core::ubuntu::media::Player::HeadersType())
+    const core::ubuntu::media::Player::HeadersType& headers = core::ubuntu::media::Player::HeadersType(),
+    bool do_pipeline_reset)
 {
-    reset_pipeline();
+    if (do_pipeline_reset)
+        reset_pipeline();
 
     g_object_set(pipeline, "uri", uri.c_str(), NULL);
     if (is_video_file(uri))
@@ -411,8 +416,27 @@
     return result;
 }
 
-bool gstreamer::Playbin::set_state_and_wait(GstState new_state)
-{
+gboolean gstreamer::Playbin::add_set_state_to_main_context(gpointer user_data)
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    std::pair<gstreamer::Playbin*, GstState> *p = static_cast<std::pair<gstreamer::Playbin*, GstState>*>(user_data);
+    gstreamer::Playbin *playbin = p->first;
+    const GstState new_state = p->second;
+    playbin->set_state_and_wait(new_state, false);
+    std::cout << "Deleting std::pair" << std::endl;
+    delete p;
+    return false;
+}
+
+bool gstreamer::Playbin::set_state_and_wait(GstState new_state, bool add_to_main_context)
+{
+    if (add_to_main_context)
+    {
+        std::cout << "Making call to set_state_and_wait on main loop context" << std::endl;
+        std::pair<gstreamer::Playbin*, GstState> *p = new std::pair<gstreamer::Playbin*, GstState>(this, new_state);
+        guint i = g_idle_add(gstreamer::Playbin::add_set_state_to_main_context, (gpointer)p);
+    }
+
     static const std::chrono::nanoseconds state_change_timeout
     {
         // We choose a quite high value here as tests are run under valgrind

=== modified file 'src/core/media/gstreamer/playbin.h'
--- src/core/media/gstreamer/playbin.h	2015-03-11 16:17:23 +0000
+++ src/core/media/gstreamer/playbin.h	2015-04-14 02:48:44 +0000
@@ -89,12 +89,14 @@
     uint64_t position() const;
     uint64_t duration() const;
 
-    void set_uri(const std::string& uri, const core::ubuntu::media::Player::HeadersType& headers);
+    void set_uri(const std::string& uri, const core::ubuntu::media::Player::HeadersType& headers, bool do_pipeline_reset = true);
     std::string uri() const;
 
     void setup_source(GstElement *source);
 
-    bool set_state_and_wait(GstState new_state);
+    // Sets the pipeline's state (stopped, playing, paused, etc). Optional parameter makes this call
+    // in the main_loop context.
+    bool set_state_and_wait(GstState new_state, bool add_to_main_context = false);
     bool seek(const std::chrono::microseconds& ms);
 
     core::ubuntu::media::video::Dimensions get_video_dimensions() const;
@@ -131,6 +133,9 @@
         core::Signal<core::ubuntu::media::video::Dimensions> on_video_dimensions_changed;
         core::Signal<void> client_disconnected;
     } signals;
+
+private:
+    static gboolean add_set_state_to_main_context(gpointer user_data);
 };
 }
 

=== modified file 'src/core/media/mpris/player.h'
--- src/core/media/mpris/player.h	2015-03-11 16:17:23 +0000
+++ src/core/media/mpris/player.h	2015-04-14 02:48:44 +0000
@@ -271,7 +271,7 @@
             properties.orientation->set(core::ubuntu::media::Player::Orientation::rotate0);
             properties.lifetime->set(core::ubuntu::media::Player::Lifetime::normal);
             properties.playback_rate->set(configuration.defaults.playback_rate);
-            properties.is_shuffle->set(configuration.defaults.shuffle);
+            properties.shuffle->set(configuration.defaults.shuffle);
             properties.position->set(configuration.defaults.position);
             properties.duration->set(configuration.defaults.duration);
             properties.minimum_playback_rate->set(configuration.defaults.minimum_rate);
@@ -302,6 +302,11 @@
             {
                 on_property_value_changed<Properties::LoopStatus>(status);
             });
+
+            properties.shuffle->changed().connect([this](bool shuffle)
+            {
+                on_property_value_changed<Properties::Shuffle>(shuffle);
+            });
         }
 
         template<typename Property>
@@ -332,7 +337,7 @@
             dict[Properties::Orientation::name()] = dbus::types::Variant::encode(properties.orientation->get());
             dict[Properties::Lifetime::name()] = dbus::types::Variant::encode(properties.lifetime->get());
             dict[Properties::PlaybackRate::name()] = dbus::types::Variant::encode(properties.playback_rate->get());
-            dict[Properties::Shuffle::name()] = dbus::types::Variant::encode(properties.is_shuffle->get());
+            dict[Properties::Shuffle::name()] = dbus::types::Variant::encode(properties.shuffle->get());
             dict[Properties::Duration::name()] = dbus::types::Variant::encode(properties.duration->get());
             dict[Properties::Position::name()] = dbus::types::Variant::encode(properties.position->get());
             dict[Properties::MinimumRate::name()] = dbus::types::Variant::encode(properties.minimum_playback_rate->get());
@@ -363,7 +368,7 @@
             std::shared_ptr<core::dbus::Property<Properties::Orientation>> orientation;
             std::shared_ptr<core::dbus::Property<Properties::Lifetime>> lifetime;
             std::shared_ptr<core::dbus::Property<Properties::PlaybackRate>> playback_rate;
-            std::shared_ptr<core::dbus::Property<Properties::Shuffle>> is_shuffle;
+            std::shared_ptr<core::dbus::Property<Properties::Shuffle>> shuffle;
             std::shared_ptr<core::dbus::Property<Properties::TypedMetaData>> typed_meta_data_for_current_track;
             std::shared_ptr<core::dbus::Property<Properties::Volume>> volume;
             std::shared_ptr<core::dbus::Property<Properties::Position>> position;

=== modified file 'src/core/media/mpris/service.h'
--- src/core/media/mpris/service.h	2014-09-30 06:51:15 +0000
+++ src/core/media/mpris/service.h	2015-04-14 02:48:44 +0000
@@ -48,6 +48,42 @@
             }
         };
 
+        struct DetachingSession
+        {
+            static const std::string& name()
+            {
+                static const std::string s
+                {
+                    "core.ubuntu.media.Service.Error.DetachingSession"
+                };
+                return s;
+            }
+        };
+
+        struct ReattachingSession
+        {
+            static const std::string& name()
+            {
+                static const std::string s
+                {
+                    "core.ubuntu.media.Service.Error.ReattachingSession"
+                };
+                return s;
+            }
+        };
+
+        struct DestroyingSession
+        {
+            static const std::string& name()
+            {
+                static const std::string s
+                {
+                    "core.ubuntu.media.Service.Error.DestroyingSession"
+                };
+                return s;
+            }
+        };
+
         struct CreatingFixedSession
         {
             static const std::string& name()
@@ -74,6 +110,9 @@
     };
 
     DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(CreateSession, Service, 1000)
+    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(DetachSession, Service, 1000)
+    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(ReattachSession, Service, 1000)
+    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(DestroySession, Service, 1000)
     DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(CreateFixedSession, Service, 1000)
     DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(ResumeSession, Service, 1000)
     DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(PauseOtherSessions, Service, 1000)

=== modified file 'src/core/media/mpris/track_list.h'
--- src/core/media/mpris/track_list.h	2014-08-25 10:18:32 +0000
+++ src/core/media/mpris/track_list.h	2015-04-14 02:48:44 +0000
@@ -22,7 +22,10 @@
 #include <core/dbus/macros.h>
 
 #include <core/dbus/types/any.h>
+#include <core/dbus/macros.h>
 #include <core/dbus/types/object_path.h>
+#include <core/dbus/object.h>
+#include <core/dbus/property.h>
 #include <core/dbus/types/variant.h>
 
 #include <boost/utility/identity_type.hpp>
@@ -37,38 +40,42 @@
 {
 struct TrackList
 {
+    typedef std::map<std::string, core::dbus::types::Variant> Dictionary;
+
     static const std::string& name()
     {
-        static const std::string s{"core.ubuntu.media.Service.Player.TrackList"};
+        static const std::string s{"org.mpris.MediaPlayer2.TrackList"};
         return s;
     }
 
-    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(GetTracksMetadata, TrackList, 1000)
-    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(AddTrack, TrackList, 1000)
-    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(RemoveTrack, TrackList, 1000)
-    DBUS_CPP_METHOD_WITH_TIMEOUT_DEF(GoTo, TrackList, 1000)
+    DBUS_CPP_METHOD_DEF(GetTracksMetadata, TrackList)
+    DBUS_CPP_METHOD_DEF(AddTrack, TrackList)
+    DBUS_CPP_METHOD_DEF(RemoveTrack, TrackList)
+    DBUS_CPP_METHOD_DEF(GoTo, TrackList)
 
     struct Signals
     {
+        Signals() = delete;
+
         DBUS_CPP_SIGNAL_DEF
         (
             TrackListReplaced,
             TrackList,
-            BOOST_IDENTITY_TYPE((std::tuple<std::vector<dbus::types::ObjectPath>, dbus::types::ObjectPath>))
+            BOOST_IDENTITY_TYPE((std::tuple<std::vector<core::ubuntu::media::Track::Id>, core::ubuntu::media::Track::Id>))
         )
 
         DBUS_CPP_SIGNAL_DEF
         (
             TrackAdded,
             TrackList,
-            BOOST_IDENTITY_TYPE((std::tuple<std::map<std::string, dbus::types::Variant>, dbus::types::ObjectPath>))
+            core::ubuntu::media::Track::Id
         )
 
         DBUS_CPP_SIGNAL_DEF
         (
             TrackRemoved,
             TrackList,
-            dbus::types::ObjectPath
+            core::ubuntu::media::Track::Id
         )
 
         DBUS_CPP_SIGNAL_DEF
@@ -81,9 +88,92 @@
 
     struct Properties
     {
+        Properties() = delete;
+
         DBUS_CPP_READABLE_PROPERTY_DEF(Tracks, TrackList, std::vector<std::string>)
         DBUS_CPP_READABLE_PROPERTY_DEF(CanEditTracks, TrackList, bool)
     };
+
+    struct Skeleton
+    {
+        static const std::vector<std::string>& the_empty_list_of_invalidated_properties()
+        {
+            static const std::vector<std::string> instance; return instance;
+        }
+
+        // Object instance creation time properties go here.
+        struct Configuration
+        {
+            // The dbus object that should implement org.mpris.MediaPlayer2
+            core::dbus::Object::Ptr object;
+            // Default values assigned to exported dbus interface properties on construction
+            struct Defaults
+            {
+                Properties::CanEditTracks::ValueType can_edit_tracks{true};
+            } defaults;
+        };
+
+        Skeleton(const Configuration& configuration)
+            : configuration(configuration),
+              properties
+              {
+                  configuration.object->get_property<Properties::Tracks>(),
+                  configuration.object->get_property<Properties::CanEditTracks>(),
+              },
+              signals
+              {
+                  configuration.object->get_signal<Signals::TrackListReplaced>(),
+                  configuration.object->get_signal<Signals::TrackAdded>(),
+                  configuration.object->get_signal<Signals::TrackRemoved>(),
+                  configuration.object->get_signal<Signals::TrackMetadataChanged>(),
+                  configuration.object->template get_signal<core::dbus::interfaces::Properties::Signals::PropertiesChanged>()
+              }
+        {
+            // Set the default value of the properties on the MPRIS TrackList dbus interface
+            properties.can_edit_tracks->set(configuration.defaults.can_edit_tracks);
+        }
+
+        template<typename Property>
+        void on_property_value_changed(const typename Property::ValueType& value)
+        {
+            Dictionary dict;
+            dict[Property::name()] = dbus::types::Variant::encode(value);
+
+            signals.properties_changed->emit(std::make_tuple(
+                            dbus::traits::Service<TrackList>::interface_name(),
+                            dict,
+                            the_empty_list_of_invalidated_properties()));
+        }
+
+        std::map<std::string, core::dbus::types::Variant> get_all_properties()
+        {
+            std::map<std::string, core::dbus::types::Variant> dict;
+            dict[Properties::Tracks::name()] = core::dbus::types::Variant::encode(properties.tracks->get());
+            dict[Properties::CanEditTracks::name()] = core::dbus::types::Variant::encode(properties.can_edit_tracks->get());
+
+            return dict;
+        }
+
+        Configuration configuration;
+
+        struct
+        {
+            std::shared_ptr<core::dbus::Property<Properties::Tracks>> tracks;
+            std::shared_ptr<core::dbus::Property<Properties::CanEditTracks>> can_edit_tracks;
+        } properties;
+
+        struct
+        {
+            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::TrackRemoved, Signals::TrackRemoved::ArgumentType>::Ptr track_removed;
+            core::dbus::Signal<Signals::TrackMetadataChanged, Signals::TrackMetadataChanged::ArgumentType>::Ptr track_metadata_changed;
+
+            dbus::Signal <core::dbus::interfaces::Properties::Signals::PropertiesChanged,
+                core::dbus::interfaces::Properties::Signals::PropertiesChanged::ArgumentType
+            >::Ptr properties_changed;
+        } signals;
+    };
 };
 }
 

=== modified file 'src/core/media/player_configuration.h'
--- src/core/media/player_configuration.h	2014-11-26 16:23:19 +0000
+++ src/core/media/player_configuration.h	2015-04-14 02:48:44 +0000
@@ -27,7 +27,7 @@
 // to the implementation in a way that is opaque to the client.
 struct core::ubuntu::media::Player::Configuration
 {
-    // Unique key for identifying the session.
+    // Unique key for identifying the session path.
     core::ubuntu::media::Player::PlayerKey key;
     // The bus connection to expose objects on.
     std::shared_ptr<core::dbus::Bus> bus;

=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2015-03-19 19:08:47 +0000
+++ src/core/media/player_implementation.cpp	2015-04-14 02:48:44 +0000
@@ -1,4 +1,5 @@
 /*
+ * 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,
@@ -23,7 +24,6 @@
 
 #include "client_death_observer.h"
 #include "engine.h"
-#include "null_track_list.h"
 #include "track_list_implementation.h"
 
 #include "gstreamer/engine.h"
@@ -58,14 +58,16 @@
           display_state_lock(config.power_state_controller->display_state_lock()),
           system_state_lock(config.power_state_controller->system_state_lock()),
           engine(std::make_shared<gstreamer::Engine>()),
-          track_list(std::make_shared<NullTrackList>()),
+          track_list(std::make_shared<TrackListImplementation>(
+                      dbus::types::ObjectPath(config.parent.session->path().as_string() + "/TrackList"),
+                      engine->meta_data_extractor())),
           system_wakelock_count(0),
           display_wakelock_count(0),
           previous_state(Engine::State::stopped),
           engine_state_change_connection(engine->state().changed().connect(make_state_change_handler())),
-          engine_playback_status_change_connection(engine->playback_status_changed_signal().connect(make_playback_status_change_handler()))
+          engine_playback_status_change_connection(engine->playback_status_changed_signal().connect(make_playback_status_change_handler())),
+          doing_go_to_track(false)
     {
-        std::cout << "Private parent instance: " << parent << std::endl;
         // Poor man's logging of release/acquire events.
         display_state_lock->acquired().connect([](media::power::DisplayState state)
         {
@@ -99,7 +101,6 @@
         // by disconnecting the state change signal
         engine_state_change_connection.disconnect();
 
-        std::cout << "** Disconnecting playback_status_changed_signal connection";
         // The engine destructor can lead to a playback status change which will
         // trigger the playback status change handler. Ensure the handler is not called
         // by disconnecting the playback status change signal
@@ -169,7 +170,7 @@
     {
         return [this](const media::Player::PlaybackStatus& status)
         {
-            std::cout << "Emiting playback_status_changed for parent: " << parent << std::endl;
+            std::cout << "Emiting playback_status_changed signal: " << status << std::endl;
             parent->emit_playback_status_changed(status);
         };
     }
@@ -290,13 +291,15 @@
     media::power::StateController::Lock<media::power::SystemState>::Ptr system_state_lock;
 
     std::shared_ptr<Engine> engine;
-    std::shared_ptr<media::NullTrackList> track_list;
+    std::shared_ptr<media::TrackListImplementation> track_list;
     std::atomic<int> system_wakelock_count;
     std::atomic<int> display_wakelock_count;
     Engine::State previous_state;
     core::Signal<> on_client_disconnected;
     core::Connection engine_state_change_connection;
     core::Connection engine_playback_status_change_connection;
+    // Prevent the TrackList from auto advancing to the next track
+    std::atomic<bool> doing_go_to_track;
 };
 
 template<typename Parent>
@@ -312,7 +315,7 @@
     Parent::can_go_next().set(true);
     Parent::is_video_source().set(false);
     Parent::is_audio_source().set(false);
-    Parent::is_shuffle().set(true);
+    Parent::shuffle().set(false);
     Parent::playback_rate().set(1.f);
     Parent::playback_status().set(Player::PlaybackStatus::null);
     Parent::loop_status().set(Player::LoopStatus::none);
@@ -352,6 +355,20 @@
     };
     Parent::is_audio_source().install(audio_type_getter);
 
+    // When the client changes the loop status, make sure to update the TrackList
+    Parent::loop_status().changed().connect([this](media::Player::LoopStatus loop_status)
+    {
+        std::cout << "Player::LoopStatus value changed: " << loop_status << std::endl;
+        d->track_list->on_loop_status_changed(loop_status);
+    });
+
+    // When the client changes the shuffle setting, make sure to update the TrackList
+    Parent::shuffle().changed().connect([this](bool shuffle)
+    {
+        std::cout << "Player::Shuffle value changed: " << (shuffle ? "shuffling" : "not shuffling") << std::endl;
+        d->track_list->on_shuffle_changed(shuffle);
+    });
+
     // Make sure that the audio_stream_role property gets updated on the Engine side
     // whenever the client side sets the role
     Parent::audio_stream_role().changed().connect([this](media::Player::AudioStreamRole new_role)
@@ -375,12 +392,21 @@
     {
         Parent::about_to_finish()();
 
-        if (d->track_list->has_next())
+        if (!d->doing_go_to_track)
         {
-            Track::UriType uri = d->track_list->query_uri_for_track(d->track_list->next());
-            if (!uri.empty())
-                d->parent->open_uri(uri);
+            const media::Track::Id prev_track_id = d->track_list->current();
+            // Make sure that the TrackList keeps advancing. The logic for what gets played next,
+            // if anything at all, occurs in TrackListSkeleton::next()
+            const Track::UriType uri = d->track_list->query_uri_for_track(d->track_list->next());
+            if (prev_track_id != d->track_list->current() && !uri.empty())
+            {
+                std::cout << "Setting next track on playbin: " << uri << std::endl;
+                static const bool do_pipeline_reset = false;
+                d->engine->open_resource_for_uri(uri, do_pipeline_reset);
+            }
         }
+        else
+            std::cout << "Not auto-advancing the TrackList since doing_go_to_track is true" << std::endl;
     });
 
     d->engine->client_disconnected_signal().connect([this]()
@@ -388,6 +414,7 @@
         // If the client disconnects, make sure both wakelock types
         // are cleared
         d->clear_wakelocks();
+        d->track_list->reset();
         // And tell the outside world that the client has gone away
         d->on_client_disconnected();
     });
@@ -412,6 +439,35 @@
         Parent::error()(e);
     });
 
+    d->track_list->on_go_to_track().connect([this](const media::Track::Id& id)
+    {
+        // This prevents the TrackList from auto advancing in other areas such as the about_to_finish signal
+        // handler.
+        d->doing_go_to_track = true;
+
+        std::cout << "** on_go_to_track was signaled in PlayerImplementation, stopping playback" << std::endl;
+        d->engine->stop();
+
+        const Track::UriType uri = d->track_list->query_uri_for_track(id);
+        if (!uri.empty())
+        {
+            std::cout << "Setting next track on playbin (on_go_to_track signal): " << uri << std::endl;
+            std::cout << "\twith a Track::Id: " << id << std::endl;
+            static const bool do_pipeline_reset = true;
+            d->engine->open_resource_for_uri(uri, do_pipeline_reset);
+        }
+
+        d->engine->play();
+
+        d->doing_go_to_track = false;
+    });
+
+    d->track_list->on_track_removed().connect([this](const media::Track::Id& id)
+    {
+        std::cout << "Track removed, detected from Player" << std::endl;
+        (void) id;
+    });
+
     // Everything is setup, we now subscribe to death notifications.
     std::weak_ptr<Private> wp{d};
 
@@ -465,6 +521,19 @@
 }
 
 template<typename Parent>
+std::string media::PlayerImplementation<Parent>::uuid() const
+{
+    // No impl for now, as not needed internally.
+}
+
+template<typename Parent>
+void media::PlayerImplementation<Parent>::reconnect()
+{
+    // TODO: Reconnect all signals that would've expired on session dettachment
+    d->config.client_death_observer->register_for_death_notifications_with_key(d->config.key);
+}
+
+template<typename Parent>
 std::shared_ptr<media::TrackList> media::PlayerImplementation<Parent>::track_list()
 {
     return d->track_list;
@@ -487,7 +556,12 @@
 template<typename Parent>
 bool media::PlayerImplementation<Parent>::open_uri(const Track::UriType& uri)
 {
-    return d->engine->open_resource_for_uri(uri);
+    if (d->track_list != nullptr)
+        // Set new track as the current track to play
+        d->track_list->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), true);
+
+    static const bool do_pipeline_reset = true;
+    return d->engine->open_resource_for_uri(uri, do_pipeline_reset);
 }
 
 template<typename Parent>
@@ -509,6 +583,16 @@
 template<typename Parent>
 void media::PlayerImplementation<Parent>::play()
 {
+    if (d->track_list != nullptr && d->track_list->tracks()->size() > 0 && d->engine->state() == media::Engine::State::no_media)
+    {
+        // 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 << "No media loaded yet, calling open_uri on first track in track_list" << std::endl;
+        static const bool do_pipeline_reset = true;
+        d->engine->open_resource_for_uri(d->track_list->query_uri_for_track(d->track_list->current()), do_pipeline_reset);
+        std::cout << *d->track_list << endl;
+    }
+
     d->engine->play();
 }
 

=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2015-03-19 19:08:47 +0000
+++ src/core/media/player_implementation.h	2015-04-14 02:48:44 +0000
@@ -55,6 +55,9 @@
     PlayerImplementation(const Configuration& configuration);
     ~PlayerImplementation();
 
+    virtual std::string uuid() const;
+    virtual void reconnect();
+
     virtual std::shared_ptr<TrackList> track_list();
     virtual Player::PlayerKey key() const;
 
@@ -78,8 +81,8 @@
     struct Private;
     std::shared_ptr<Private> d;
 };
+
 }
 }
 }
 #endif // CORE_UBUNTU_MEDIA_PLAYER_IMPLEMENTATION_H_
-

=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2015-03-11 16:17:23 +0000
+++ src/core/media/player_skeleton.cpp	2015-04-14 02:48:44 +0000
@@ -407,9 +407,9 @@
     return *d->skeleton.properties.playback_rate;
 }
 
-const core::Property<bool>& media::PlayerSkeleton::is_shuffle() const
+const core::Property<bool>& media::PlayerSkeleton::shuffle() const
 {
-    return *d->skeleton.properties.is_shuffle;
+    return *d->skeleton.properties.shuffle;
 }
 
 const core::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track() const
@@ -467,9 +467,9 @@
     return *d->skeleton.properties.playback_rate;
 }
 
-core::Property<bool>& media::PlayerSkeleton::is_shuffle()
+core::Property<bool>& media::PlayerSkeleton::shuffle()
 {
-    return *d->skeleton.properties.is_shuffle;
+    return *d->skeleton.properties.shuffle;
 }
 
 core::Property<media::Player::Volume>& media::PlayerSkeleton::volume()

=== modified file 'src/core/media/player_skeleton.h'
--- src/core/media/player_skeleton.h	2015-03-11 16:17:23 +0000
+++ src/core/media/player_skeleton.h	2015-04-14 02:48:44 +0000
@@ -73,7 +73,7 @@
     virtual const core::Property<PlaybackStatus>& playback_status() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
-    virtual const core::Property<bool>& is_shuffle() const;
+    virtual const core::Property<bool>& shuffle() const;
     virtual const core::Property<Track::MetaData>& meta_data_for_current_track() const;
     virtual const core::Property<Volume>& volume() const;
     virtual const core::Property<PlaybackRate>& minimum_playback_rate() const;
@@ -86,7 +86,7 @@
 
     virtual core::Property<LoopStatus>& loop_status();
     virtual core::Property<PlaybackRate>& playback_rate();
-    virtual core::Property<bool>& is_shuffle();
+    virtual core::Property<bool>& shuffle();
     virtual core::Property<Volume>& volume();
     virtual core::Property<AudioStreamRole>& audio_stream_role();
     virtual core::Property<Lifetime>& lifetime();

=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2015-03-16 14:54:47 +0000
+++ src/core/media/player_stub.cpp	2015-04-14 02:48:44 +0000
@@ -43,10 +43,12 @@
 struct media::PlayerStub::Private
 {
     Private(const std::shared_ptr<Service>& parent,
-            const std::shared_ptr<core::dbus::Object>& object
+            const std::shared_ptr<core::dbus::Object>& object,
+            const std::string uuid
             ) : parent(parent),
                 object(object),
                 key(object->invoke_method_synchronously<mpris::Player::Key, media::Player::PlayerKey>().value()),
+                uuid(uuid),
                 sink_factory(media::video::make_platform_default_sink_factory(key)),
                 properties
                 {
@@ -93,6 +95,7 @@
     std::shared_ptr<TrackList> track_list;
     dbus::Object::Ptr object;
     media::Player::PlayerKey key;
+    std::string uuid;
     media::video::SinkFactory sink_factory;
     struct
     {
@@ -108,7 +111,7 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::TypedPlaybackStatus>> playback_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::TypedLoopStatus>> loop_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackRate>> playback_rate;
-        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Shuffle>> is_shuffle;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Shuffle>> shuffle;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::TypedMetaData>> meta_data_for_current_track;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Volume>> volume;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Position>> position;
@@ -153,7 +156,7 @@
         {
             dbus.seeked_to->connect([this](std::uint64_t value)
             {
-                std::cout << "seeked_to signal arrived via the bus." << std::endl;
+                std::cout << "SeekedTo signal arrived via the bus." << std::endl;
                 seeked_to(value);
             });
 
@@ -209,8 +212,9 @@
 
 media::PlayerStub::PlayerStub(
     const std::shared_ptr<Service>& parent,
-    const std::shared_ptr<core::dbus::Object>& object)
-        : d(new Private{parent, object})
+    const std::shared_ptr<core::dbus::Object>& object,
+    std::string uuid)
+        : d(new Private{parent, object, uuid})
 {
 }
 
@@ -218,6 +222,16 @@
 {
 }
 
+std::string media::PlayerStub::uuid() const
+{
+    return d->uuid;
+}
+
+void media::PlayerStub::reconnect()
+{
+    // No implementation
+}
+
 std::shared_ptr<media::TrackList> media::PlayerStub::track_list()
 {
     if (!d->track_list)
@@ -362,9 +376,9 @@
     return *d->properties.playback_rate;
 }
 
-const core::Property<bool>& media::PlayerStub::is_shuffle() const
+const core::Property<bool>& media::PlayerStub::shuffle() const
 {
-    return *d->properties.is_shuffle;
+    return *d->properties.shuffle;
 }
 
 const core::Property<media::Track::MetaData>& media::PlayerStub::meta_data_for_current_track() const
@@ -422,9 +436,9 @@
     return *d->properties.playback_rate;
 }
 
-core::Property<bool>& media::PlayerStub::is_shuffle()
+core::Property<bool>& media::PlayerStub::shuffle()
 {
-    return *d->properties.is_shuffle;
+    return *d->properties.shuffle;
 }
 
 core::Property<media::Player::Volume>& media::PlayerStub::volume()

=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2015-03-11 16:17:23 +0000
+++ src/core/media/player_stub.h	2015-04-14 02:48:44 +0000
@@ -39,10 +39,14 @@
   public:
     explicit PlayerStub(
         const std::shared_ptr<Service>& parent,
-        const std::shared_ptr<core::dbus::Object>& object);
+        const std::shared_ptr<core::dbus::Object>& object,
+        std::string uuid = "");
 
     ~PlayerStub();
 
+    virtual std::string uuid() const;
+    virtual void reconnect();
+
     virtual std::shared_ptr<TrackList> track_list();
     virtual PlayerKey key() const;
 
@@ -67,7 +71,7 @@
     virtual const core::Property<PlaybackStatus>& playback_status() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
-    virtual const core::Property<bool>& is_shuffle() const;
+    virtual const core::Property<bool>& shuffle() const;
     virtual const core::Property<Track::MetaData>& meta_data_for_current_track() const;
     virtual const core::Property<Volume>& volume() const;
     virtual const core::Property<PlaybackRate>& minimum_playback_rate() const;
@@ -80,7 +84,7 @@
 
     virtual core::Property<LoopStatus>& loop_status();
     virtual core::Property<PlaybackRate>& playback_rate();
-    virtual core::Property<bool>& is_shuffle();
+    virtual core::Property<bool>& shuffle();
     virtual core::Property<Volume>& volume();
     virtual core::Property<AudioStreamRole>& audio_stream_role();
     virtual core::Property<Lifetime>& lifetime();

=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2014-12-15 14:43:44 +0000
+++ src/core/media/server/server.cpp	2015-04-14 02:48:44 +0000
@@ -123,7 +123,7 @@
     {
         impl,
         player_store,
-
+        external_services
     });
 
     std::thread service_worker

=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2015-04-02 14:46:52 +0000
+++ src/core/media/service_implementation.cpp	2015-04-14 02:48:44 +0000
@@ -53,6 +53,8 @@
 
 struct media::ServiceImplementation::Private
 {
+    // Create all of the appropriate observers and helper class instances to be
+    // passed to the PlayerImplementation
     Private(const ServiceImplementation::Configuration& configuration)
         : configuration(configuration),
           resume_key(std::numeric_limits<std::uint32_t>::max()),
@@ -72,7 +74,7 @@
     media::ServiceImplementation::Configuration configuration;
     // This holds the key of the multimedia role Player instance that was paused
     // when the battery level reached 10% or 5%
-    media::Player::PlayerKey resume_key;    
+    media::Player::PlayerKey resume_key;
     media::power::BatteryObserver::Ptr battery_observer;
     media::power::StateController::Ptr power_state_controller;
     media::power::StateController::Lock<media::power::DisplayState>::Ptr display_state_lock;
@@ -262,17 +264,17 @@
 void media::ServiceImplementation::pause_all_multimedia_sessions(bool resume_play_after_phonecall)
 {
     d->configuration.player_store->enumerate_players([this, resume_play_after_phonecall](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
-                      {
-                          if (player->playback_status() == Player::playing
-                              && player->audio_stream_role() == media::Player::multimedia)
-                          {
-                              auto paused_player_pair = std::make_pair(key, resume_play_after_phonecall);
-                              d->paused_sessions.push_back(paused_player_pair);
-                              std::cout << "Pausing Player with key: " << key << ", resuming after phone call? "
-                                  << (resume_play_after_phonecall ? "yes" : "no") << std::endl;
-                              player->pause();
-                          }
-                      });
+    {
+        if (player->playback_status() == Player::playing
+            && player->audio_stream_role() == media::Player::multimedia)
+        {
+            auto paused_player_pair = std::make_pair(key, resume_play_after_phonecall);
+            d->paused_sessions.push_back(paused_player_pair);
+            std::cout << "Pausing Player with key: " << key << ", resuming after phone call? "
+                << (resume_play_after_phonecall ? "yes" : "no") << std::endl;
+            player->pause();
+        }
+    });
 }
 
 void media::ServiceImplementation::resume_paused_multimedia_sessions(bool resume_video_sessions)

=== modified file 'src/core/media/service_skeleton.cpp'
--- src/core/media/service_skeleton.cpp	2014-12-15 14:43:44 +0000
+++ src/core/media/service_skeleton.cpp	2015-04-14 02:48:44 +0000
@@ -35,6 +35,10 @@
 
 #include <core/posix/this_process.h>
 
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
 #include <map>
 #include <regex>
 #include <sstream>
@@ -50,17 +54,33 @@
 struct media::ServiceSkeleton::Private
 {
     Private(media::ServiceSkeleton* impl, const ServiceSkeleton::Configuration& config)
-        : impl(impl),
+        : request_context_resolver(media::apparmor::ubuntu::make_platform_default_request_context_resolver(config.external_services)),
+          impl(impl),
           object(impl->access_service()->add_object_for_path(
-                     dbus::traits::Service<media::Service>::object_path())),          
-          exported(impl->access_bus(), config.cover_art_resolver),
-          configuration(config)
+                     dbus::traits::Service<media::Service>::object_path())),
+          configuration(config),
+          exported(impl->access_bus(), config.cover_art_resolver)
     {
         object->install_method_handler<mpris::Service::CreateSession>(
                     std::bind(
                         &Private::handle_create_session,
                         this,
                         std::placeholders::_1));
+        object->install_method_handler<mpris::Service::DetachSession>(
+                    std::bind(
+                        &Private::handle_detach_session,
+                        this,
+                        std::placeholders::_1));
+        object->install_method_handler<mpris::Service::ReattachSession>(
+                    std::bind(
+                        &Private::handle_reattach_session,
+                        this,
+                        std::placeholders::_1));
+        object->install_method_handler<mpris::Service::DestroySession>(
+                    std::bind(
+                        &Private::handle_destroy_session,
+                        this,
+                        std::placeholders::_1));
         object->install_method_handler<mpris::Service::CreateFixedSession>(
                     std::bind(
                         &Private::handle_create_fixed_session,
@@ -78,24 +98,26 @@
                         std::placeholders::_1));
     }
 
-    std::pair<std::string, media::Player::PlayerKey> create_session_info()
+    std::tuple<std::string, media::Player::PlayerKey, std::string> create_session_info()
     {
         static unsigned int session_counter = 0;
 
         unsigned int current_session = session_counter++;
+        boost::uuids::uuid uuid = gen();
 
         std::stringstream ss;
         ss << "/core/ubuntu/media/Service/sessions/" << current_session;
 
-        return std::make_pair(ss.str(), media::Player::PlayerKey(current_session));
+        return std::make_tuple(ss.str(), media::Player::PlayerKey(current_session), to_string(uuid));
     }
 
     void handle_create_session(const core::dbus::Message::Ptr& msg)
     {
-        auto  session_info = create_session_info();
+        auto session_info = create_session_info();
 
-        dbus::types::ObjectPath op{session_info.first};
-        media::Player::PlayerKey key{session_info.second};
+        dbus::types::ObjectPath op{std::get<0>(session_info)};
+        media::Player::PlayerKey key{std::get<1>(session_info)};
+        std::string uuid{std::get<2>(session_info)};
 
         media::Player::Configuration config
         {
@@ -104,11 +126,21 @@
             impl->access_service()->add_object_for_path(op)
         };
 
+        std::cout << "Session created by request of: " << msg->sender() << ", uuid: " << uuid << ", path:" << op << std::endl;
+
         try
         {
             configuration.player_store->add_player_for_key(key, impl->create_session(config));
+            uuid_player_map.insert(std::make_pair(uuid, key));
+
+            request_context_resolver->resolve_context_for_dbus_name_async(msg->sender(), [this, key, msg](const media::apparmor::ubuntu::Context& context)
+            {
+                fprintf(stderr, "%s():%d -- app_name='%s', attached\n", __func__, __LINE__, context.str().c_str());
+                player_owner_map.insert(std::make_pair(key, std::make_tuple(context.str(), true, msg->sender())));
+            });
+            
             auto reply = dbus::Message::make_method_return(msg);
-            reply->writer() << op;
+            reply->writer() << std::make_tuple(op, uuid);
 
             impl->access_bus()->send(reply);
         } catch(const std::runtime_error& e)
@@ -121,6 +153,169 @@
         }
     }
 
+    void handle_detach_session(const core::dbus::Message::Ptr& msg)
+    {
+        try
+        {
+            std::string uuid;
+            msg->reader() >> uuid;
+
+            auto key = uuid_player_map.at(uuid);
+
+            if (player_owner_map.count(key) != 0) {
+                auto info = player_owner_map.at(key);
+                if (std::get<1>(info) && (std::get<2>(info) == msg->sender())) { // Player is attached
+                    std::get<1>(info) = false; // Detached
+                    std::get<2>(info).clear(); // Clear registered sender/peer
+                    auto player = configuration.player_store->player_for_key(key);
+                    player->lifetime().set(media::Player::Lifetime::resumable);
+                }
+            }
+            
+            auto reply = dbus::Message::make_method_return(msg);
+            impl->access_bus()->send(reply);
+
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::DetachingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply);
+        }
+    }
+
+    void handle_reattach_session(const core::dbus::Message::Ptr& msg)
+    {
+        try
+        {
+            std::string uuid;
+            msg->reader() >> uuid;
+
+            if (uuid_player_map.count(uuid) != 0) {
+                auto key = uuid_player_map.at(uuid);
+                if (not configuration.player_store->has_player_for_key(key)) {
+                    auto reply = dbus::Message::make_error(
+                                msg,
+                                mpris::Service::Errors::ReattachingSession::name(),
+                                "Unable to locate player session");
+                    impl->access_bus()->send(reply);
+                    return;
+                }
+                std::stringstream ss;
+                ss << "/core/ubuntu/media/Service/sessions/" << key;
+                dbus::types::ObjectPath op{ss.str()};
+
+                request_context_resolver->resolve_context_for_dbus_name_async(msg->sender(), [this, msg, key, op](const media::apparmor::ubuntu::Context& context)
+                {
+                    auto info = player_owner_map.at(key);
+                    fprintf(stderr, "%s():%d -- reattach app_name='%s', info='%s', '%s'\n", __func__, __LINE__, context.str().c_str(), std::get<0>(info).c_str(), std::get<2>(info).c_str());
+                    if (std::get<0>(info) == context.str()) {
+                        std::get<1>(info) = true; // Set to Attached
+                        std::get<2>(info) = msg->sender(); // Register new owner
+
+                        // Signal player reconnection
+                        auto player = configuration.player_store->player_for_key(key);
+                        player->reconnect();
+
+                        auto reply = dbus::Message::make_method_return(msg);
+                        reply->writer() << op;
+
+                        impl->access_bus()->send(reply);
+                    }
+                    else {
+                        auto reply = dbus::Message::make_error(
+                                    msg,
+                                    mpris::Service::Errors::ReattachingSession::name(),
+                                    "Invalid permissions for the requested session");
+                        impl->access_bus()->send(reply);
+                        return;
+                    }
+                });
+            }
+            else {
+               auto reply = dbus::Message::make_error(
+                           msg,
+                           mpris::Service::Errors::ReattachingSession::name(),
+                           "Invalid session");
+               impl->access_bus()->send(reply);
+               return;
+            }
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::ReattachingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply);
+        }
+    }
+
+    void handle_destroy_session(const core::dbus::Message::Ptr& msg)
+    {
+     
+        try
+        {
+            std::string uuid;
+            msg->reader() >> uuid;
+
+            if (uuid_player_map.count(uuid) != 0) {
+                auto key = uuid_player_map.at(uuid);
+                if (not configuration.player_store->has_player_for_key(key)) {
+                    auto reply = dbus::Message::make_error(
+                                msg,
+                                mpris::Service::Errors::DestroyingSession::name(),
+                                "Unable to locate player session");
+                    impl->access_bus()->send(reply);
+                    return;
+                }
+
+                // Remove control entries from the map, at this point
+                // the session is no longer usable.
+                uuid_player_map.erase(uuid);
+
+                request_context_resolver->resolve_context_for_dbus_name_async(msg->sender(), [this, msg, key](const media::apparmor::ubuntu::Context& context)
+                {
+                    auto info = player_owner_map.at(key);
+                    fprintf(stderr, "%s():%d -- Destroying app_name='%s', info='%s', '%s'\n", __func__, __LINE__, context.str().c_str(), std::get<0>(info).c_str(), std::get<2>(info).c_str());
+                    if (std::get<0>(info) == context.str()) {
+                        player_owner_map.erase(key);
+
+                        // Signal player reconnection
+                        auto player = configuration.player_store->player_for_key(key);
+                        player->lifetime().set(media::Player::Lifetime::normal);
+
+                        auto reply = dbus::Message::make_method_return(msg);
+                        impl->access_bus()->send(reply);
+                    }
+                    else {
+                        auto reply = dbus::Message::make_error(
+                                    msg,
+                                    mpris::Service::Errors::DestroyingSession::name(),
+                                    "Invalid permissions for the requested session");
+                        impl->access_bus()->send(reply);
+                        return;
+                    }
+                });
+            }
+            else {
+               auto reply = dbus::Message::make_error(
+                           msg,
+                           mpris::Service::Errors::DestroyingSession::name(),
+                           "Invalid session");
+               impl->access_bus()->send(reply);
+               return;
+            }
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::DestroyingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply);
+        }
+    }
+
     void handle_create_fixed_session(const core::dbus::Message::Ptr& msg)
     {
         try
@@ -132,8 +327,8 @@
                 // Create new session
                 auto  session_info = create_session_info();
 
-                dbus::types::ObjectPath op{session_info.first};
-                media::Player::PlayerKey key{session_info.second};
+                dbus::types::ObjectPath op{std::get<0>(session_info)};
+                media::Player::PlayerKey key{std::get<1>(session_info)};
 
                 media::Player::Configuration config
                 {
@@ -147,7 +342,6 @@
 
                 configuration.player_store->add_player_for_key(key, session);
 
-
                 named_player_map.insert(std::make_pair(name, key));
 
                 auto reply = dbus::Message::make_method_return(msg);
@@ -231,6 +425,7 @@
         impl->access_bus()->send(reply);
     }
 
+    media::apparmor::ubuntu::RequestContextResolver::Ptr request_context_resolver;
     media::ServiceSkeleton* impl;
     dbus::Object::Ptr object;
 
@@ -238,6 +433,14 @@
     ServiceSkeleton::Configuration configuration;
     // We map named/fixed player instances to their respective keys.
     std::map<std::string, media::Player::PlayerKey> named_player_map;
+    // We map UUIDs to their respective keys.
+    std::map<std::string, media::Player::PlayerKey> uuid_player_map;
+    // We keep a list of keys and their respective owners and states.
+    // value: (owner context, attached state, attached dbus name)
+    std::map<media::Player::PlayerKey, std::tuple<std::string, bool, std::string>> player_owner_map;
+    
+    boost::uuids::random_generator gen;
+     
     // We expose the entire service as an MPRIS player.
     struct Exported
     {
@@ -266,6 +469,7 @@
 
         static std::string service_name()
         {
+#if 0
             static const bool export_to_indicator_sound_via_mpris
             {
                 core::posix::this_process::env::get("UBUNTU_MEDIA_HUB_EXPORT_TO_INDICATOR_VIA_MPRIS", "0") == "1"
@@ -273,6 +477,9 @@
 
             return export_to_indicator_sound_via_mpris ? "org.mpris.MediaPlayer2.MediaHub" :
                                                          "hidden.org.mpris.MediaPlayer2.MediaHub";
+#else
+            return "org.mpris.MediaPlayer2.MediaHub";
+#endif
         }
 
         explicit Exported(const dbus::Bus::Ptr& bus, const media::CoverArtResolver& cover_art_resolver)

=== modified file 'src/core/media/service_skeleton.h'
--- src/core/media/service_skeleton.h	2014-12-15 14:43:44 +0000
+++ src/core/media/service_skeleton.h	2015-04-14 02:48:44 +0000
@@ -19,6 +19,8 @@
 #ifndef CORE_UBUNTU_MEDIA_SERVICE_SKELETON_H_
 #define CORE_UBUNTU_MEDIA_SERVICE_SKELETON_H_
 
+#include "apparmor/ubuntu.h"
+
 #include <core/media/service.h>
 
 #include "cover_art_resolver.h"
@@ -43,6 +45,7 @@
     {
         std::shared_ptr<Service> impl;
         KeyedPlayerStore::Ptr player_store;
+        helper::ExternalServices& external_services;
         CoverArtResolver cover_art_resolver;
     };
 

=== modified file 'src/core/media/service_stub.cpp'
--- src/core/media/service_stub.cpp	2014-10-23 14:42:59 +0000
+++ src/core/media/service_stub.cpp	2015-04-14 02:48:44 +0000
@@ -58,16 +58,51 @@
 std::shared_ptr<media::Player> media::ServiceStub::create_session(const media::Player::Configuration&)
 {
     auto op = d->object->invoke_method_synchronously<mpris::Service::CreateSession,
-         dbus::types::ObjectPath>();
-
-    if (op.is_error())
-        throw std::runtime_error("Problem creating session: " + op.error());
-
-    return std::shared_ptr<media::Player>(new media::PlayerStub
-    {
-        shared_from_this(),
-        access_service()->object_for_path(op.value())
-    });
+         std::tuple<dbus::types::ObjectPath, std::string>>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem creating session: " + op.error());
+
+    return std::shared_ptr<media::Player>(new media::PlayerStub
+    {
+        shared_from_this(),
+        access_service()->object_for_path(std::get<0>(op.value())),
+        std::get<1>(op.value())
+    });
+}
+
+void media::ServiceStub::detach_session(const std::string& uuid, const media::Player::Configuration&)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Service::DetachSession,
+         void>(uuid);
+
+    if (op.is_error())
+        throw std::runtime_error("Problem detaching session: " + op.error());
+}
+
+std::shared_ptr<media::Player> media::ServiceStub::reattach_session(const std::string& uuid, const media::Player::Configuration&)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Service::ReattachSession,
+         dbus::types::ObjectPath>(uuid);
+
+    if (op.is_error())
+        throw std::runtime_error("Problem reattaching session: " + op.error());
+
+    return std::shared_ptr<media::Player>(new media::PlayerStub
+    {
+        shared_from_this(),
+        access_service()->object_for_path(op.value()),
+        uuid
+    });
+}
+
+void media::ServiceStub::destroy_session(const std::string& uuid, const media::Player::Configuration&)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Service::DestroySession,
+         void>(uuid);
+
+    if (op.is_error())
+        throw std::runtime_error("Problem creating session: " + op.error());
 }
 
 std::shared_ptr<media::Player> media::ServiceStub::create_fixed_session(const std::string& name, const media::Player::Configuration&)

=== modified file 'src/core/media/service_stub.h'
--- src/core/media/service_stub.h	2014-10-23 14:42:59 +0000
+++ src/core/media/service_stub.h	2015-04-14 02:48:44 +0000
@@ -40,6 +40,9 @@
     ~ServiceStub();
 
     std::shared_ptr<Player> create_session(const Player::Configuration&);
+    void detach_session(const std::string& uuid, const Player::Configuration&);
+    std::shared_ptr<Player> reattach_session(const std::string& uuid, const Player::Configuration&);
+    void destroy_session(const std::string& uuid, const Player::Configuration&);
     std::shared_ptr<Player> create_fixed_session(const std::string& name, const Player::Configuration&);
     std::shared_ptr<Player> resume_session(Player::PlayerKey key);
     void pause_other_sessions(Player::PlayerKey key);

=== modified file 'src/core/media/track_list_implementation.cpp'
--- src/core/media/track_list_implementation.cpp	2014-03-25 14:57:15 +0000
+++ src/core/media/track_list_implementation.cpp	2015-04-14 02:48:44 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 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,
@@ -16,8 +16,10 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include <algorithm>
 #include <stdio.h>
 #include <stdlib.h>
+#include <tuple>
 
 #include "track_list_implementation.h"
 
@@ -31,15 +33,19 @@
     typedef std::map<Track::Id, std::tuple<Track::UriType, Track::MetaData>> MetaDataCache;
 
     dbus::types::ObjectPath path;
+    size_t track_counter;
     MetaDataCache meta_data_cache;
     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::TrackListImplementation::TrackListImplementation(
         const dbus::types::ObjectPath& op,
         const std::shared_ptr<media::Engine::MetaDataExtractor>& extractor)
     : media::TrackListSkeleton(op),
-      d(new Private{op, Private::MetaDataCache{}, extractor})
+      d(new Private{op, 0, Private::MetaDataCache{}, extractor, media::TrackList::Container{}})
 {
     can_edit_tracks().set(true);
 }
@@ -73,9 +79,9 @@
         const media::Track::Id& position,
         bool make_current)
 {
-    static size_t track_counter = 0;
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
 
-    std::stringstream ss; ss << d->path.as_string() << "/" << track_counter++;
+    std::stringstream ss; ss << d->path.as_string() << "/" << d->track_counter++;
     Track::Id id{ss.str()};
 
     auto result = tracks().update([this, id, position, make_current](TrackList::Container& container)
@@ -100,6 +106,7 @@
         if (make_current)
             go_to(id);
 
+        // Signal to the client that a track was added to the TrackList
         on_track_added()(id);
     }
 }
@@ -123,5 +130,62 @@
 
 void media::TrackListImplementation::go_to(const media::Track::Id& track)
 {
-    (void) track;
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    // Signal the Player instance to go to a specific track for playback
+    on_go_to_track()(track);
+    on_track_changed()(track);
+}
+
+void media::TrackListImplementation::shuffle_tracks()
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+    auto result = tracks().update([this](TrackList::Container& container)
+    {
+        std::cout << "Storing original TrackList order" << std::endl;
+        d->original_tracklist.assign(container.begin(), container.end());
+        std::cout << "Shuffling the track container" << std::endl;
+        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;
+
+    auto result = tracks().update([this](TrackList::Container& container)
+    {
+        std::cout << "Restoring original TrackList order" << std::endl;
+        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::reset()
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+
+    auto result = tracks().update([this](TrackList::Container& container)
+    {
+        std::cout << "Clearing the TrackList" << std::endl;
+        container.clear();
+        container.resize(0);
+        d->track_counter = 0;
+        return true;
+    });
+
+    (void) result;
 }

=== modified file 'src/core/media/track_list_implementation.h'
--- src/core/media/track_list_implementation.h	2014-03-25 14:57:15 +0000
+++ src/core/media/track_list_implementation.h	2015-04-14 02:48:44 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 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,
@@ -43,6 +43,9 @@
     void remove_track(const Track::Id& id);
 
     void go_to(const Track::Id& track);
+    void shuffle_tracks();
+    void unshuffle_tracks();
+    void reset();
 
 private:
     struct Private;

=== modified file 'src/core/media/track_list_skeleton.cpp'
--- src/core/media/track_list_skeleton.cpp	2014-03-25 14:57:15 +0000
+++ src/core/media/track_list_skeleton.cpp	2015-04-14 02:48:44 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "track_list_skeleton.h"
+#include "track_list_implementation.h"
 
 #include <core/media/player.h>
 #include <core/media/track_list.h>
@@ -35,6 +36,7 @@
 #include <core/dbus/types/stl/map.h>
 #include <core/dbus/types/stl/vector.h>
 
+#include <iostream>
 #include <limits>
 
 namespace dbus = core::dbus;
@@ -49,8 +51,17 @@
           can_edit_tracks(object->get_property<mpris::TrackList::Properties::CanEditTracks>()),
           tracks(object->get_property<mpris::TrackList::Properties::Tracks>()),
           current_track(tracks->get().begin()),
-          empty_iterator(tracks->get().begin())
+          empty_iterator(tracks->get().begin()),
+          loop_status(media::Player::LoopStatus::none),
+          skeleton{mpris::TrackList::Skeleton::Configuration{object, mpris::TrackList::Skeleton::Configuration::Defaults{}}},
+          signals
+          {
+              skeleton.signals.track_added,
+              skeleton.signals.track_removed,
+              skeleton.signals.tracklist_replaced
+          }
     {
+        std::cout << "Creating new TrackListSkeleton::Private" << std::endl;
     }
 
     void handle_get_tracks_metadata(const core::dbus::Message::Ptr& msg)
@@ -92,6 +103,8 @@
         media::Track::Id track;
         msg->reader() >> track;
 
+        std::cout << "Setting Track::Id: " << track << " to current track" << std::endl;
+        current_track = std::find(tracks->get().begin(), tracks->get().end(), track);
         impl->go_to(track);
 
         auto reply = dbus::Message::make_method_return(msg);
@@ -105,11 +118,46 @@
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::Tracks>> tracks;
     TrackList::ConstIterator current_track;
     TrackList::ConstIterator empty_iterator;
-
-    core::Signal<void> on_track_list_replaced;
-    core::Signal<Track::Id> on_track_added;
-    core::Signal<Track::Id> on_track_removed;
-    core::Signal<Track::Id> on_track_changed;
+    media::Player::LoopStatus loop_status;
+
+    mpris::TrackList::Skeleton skeleton;
+
+    struct Signals
+    {
+        typedef core::dbus::Signal<mpris::TrackList::Signals::TrackAdded, mpris::TrackList::Signals::TrackAdded::ArgumentType> DBusTrackAddedSignal;
+        typedef core::dbus::Signal<mpris::TrackList::Signals::TrackRemoved, mpris::TrackList::Signals::TrackRemoved::ArgumentType> DBusTrackRemovedSignal;
+        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<DBusTrackRemovedSignal>& remote_track_removed,
+                const std::shared_ptr<DBusTrackListReplacedSignal>& remote_track_list_replaced)
+        {
+            // Connect all of the MPRIS interface signals to be emitted over dbus
+            on_track_added.connect([remote_track_added](const media::Track::Id &id)
+            {
+                std::cout << "Emitting remote_track_added()" << std::endl;
+                remote_track_added->emit(id);
+            });
+
+            on_track_removed.connect([remote_track_removed](const media::Track::Id &id)
+            {
+                std::cout << "Emitting remote_track_removed()" << std::endl;
+                remote_track_removed->emit(id);
+            });
+
+            on_track_list_replaced.connect([remote_track_list_replaced](const media::TrackList::ContainerTrackIdTuple &tltuple)
+            {
+                std::cout << "Emitting remote_track_list_replaced()" << std::endl;
+                remote_track_list_replaced->emit(tltuple);
+            });
+        }
+
+        core::Signal<Track::Id> on_track_added;
+        core::Signal<Track::Id> on_track_removed;
+        core::Signal<TrackList::ContainerTrackIdTuple> on_track_list_replaced;
+        core::Signal<Track::Id> on_track_changed;
+        core::Signal<Track::Id> on_go_to_track;
+    } signals;
 };
 
 media::TrackListSkeleton::TrackListSkeleton(
@@ -117,6 +165,7 @@
     : dbus::Skeleton<media::TrackList>(the_session_bus()),
       d(new Private(this, access_service()->add_object_for_path(op)))
 {
+    std::cout << "Creating new TrackListSkeleton" << std::endl;
     d->object->install_method_handler<mpris::TrackList::GetTracksMetadata>(
         std::bind(&Private::handle_get_tracks_metadata,
                   std::ref(d),
@@ -144,21 +193,52 @@
 
 bool media::TrackListSkeleton::has_next() const
 {
-    return d->current_track != d->tracks->get().end();
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    const auto next_track = std::next(d->current_track);
+    std::cout << "has_next track? " << (next_track != d->tracks->get().end() ? "yes" : "no") << std::endl;
+    return next_track != d->tracks->get().end();
 }
 
 const media::Track::Id& media::TrackListSkeleton::next()
 {
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
     if (d->tracks->get().empty())
         return *(d->current_track);
 
+    std::cout << "next() LoopStatus: " << d->loop_status << std::endl;
+
+    // Loop on the current track forever
+    if (d->loop_status == media::Player::LoopStatus::track)
+    {
+        std::cout << "Looping on the current track..." << std::endl;
+        return *(d->current_track);
+    }
+    // Loop over the whole playlist and repeat
+    else if (d->loop_status == media::Player::LoopStatus::playlist && !has_next())
+    {
+        std::cout << "Looping on the entire TrackList..." << std::endl;
+        d->current_track = d->tracks->get().begin();
+        return *(d->current_track);
+    }
+    else if (has_next())
+    {
+        // Keep returning the next track until the last track is reached
+        std::cout << "Current track id before next(): " << *d->current_track << std::endl;
+        d->current_track = std::next(d->current_track);
+        std::cout << "Current track id after next(): " << *d->current_track << std::endl;
+        std::cout << *this << std::endl;
+    }
+
+    return *(d->current_track);
+}
+
+const media::Track::Id& media::TrackListSkeleton::current()
+{
     if (d->tracks->get().size() && (d->current_track == d->empty_iterator))
-    {        
+    {
+        std::cout << "current_track id == the end()" << std::endl;
         d->current_track = d->tracks->get().begin();
-        return *(d->current_track = std::next(d->current_track));
     }
-
-    d->current_track = std::next(d->current_track);
     return *(d->current_track);
 }
 
@@ -177,47 +257,100 @@
     return *d->tracks;
 }
 
+void media::TrackListSkeleton::on_loop_status_changed(const media::Player::LoopStatus& loop_status)
+{
+    d->loop_status = loop_status;
+}
+
+media::Player::LoopStatus media::TrackListSkeleton::loop_status() const
+{
+    return d->loop_status;
+}
+
+void media::TrackListSkeleton::on_shuffle_changed(bool shuffle)
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    if (shuffle)
+        shuffle_tracks();
+    else
+        unshuffle_tracks();
+
+}
+
 const core::Property<media::TrackList::Container>& media::TrackListSkeleton::tracks() const
 {
     return *d->tracks;
 }
 
-const core::Signal<void>& media::TrackListSkeleton::on_track_list_replaced() const
+const core::Signal<media::TrackList::ContainerTrackIdTuple>& media::TrackListSkeleton::on_track_list_replaced() const
 {
-    return d->on_track_list_replaced;
+    // Print the TrackList instance
+    std::cout << *this << std::endl;
+    return d->signals.on_track_list_replaced;
 }
 
 const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_added() const
 {
-    return d->on_track_added;
+    return d->signals.on_track_added;
 }
 
 const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_removed() const
 {
-    return d->on_track_removed;
+    return d->signals.on_track_removed;
 }
 
 const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_changed() const
 {
-    return d->on_track_changed;
-}
-
-core::Signal<void>& media::TrackListSkeleton::on_track_list_replaced()
-{
-    return d->on_track_list_replaced;
+    return d->signals.on_track_changed;
+}
+
+const core::Signal<media::Track::Id>& media::TrackListSkeleton::on_go_to_track() const
+{
+    return d->signals.on_go_to_track;
+}
+
+core::Signal<media::TrackList::ContainerTrackIdTuple>& media::TrackListSkeleton::on_track_list_replaced()
+{
+    // Print the TrackList instance
+    std::cout << *this << std::endl;
+    return d->signals.on_track_list_replaced;
 }
 
 core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_added()
 {
-    return d->on_track_added;
+    return d->signals.on_track_added;
 }
 
 core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_removed()
 {
-    return d->on_track_removed;
+    return d->signals.on_track_removed;
 }
 
 core::Signal<media::Track::Id>& media::TrackListSkeleton::on_track_changed()
 {
-    return d->on_track_changed;
-}
+    return d->signals.on_track_changed;
+}
+
+core::Signal<media::Track::Id>& media::TrackListSkeleton::on_go_to_track()
+{
+    return d->signals.on_go_to_track;
+}
+
+// operator<< pretty prints the given TrackList to the given output stream.
+std::ostream& media::operator<<(std::ostream& out, const media::TrackList& tracklist)
+{
+    auto non_const_tl = const_cast<media::TrackList*>(&tracklist);
+    out << "TrackList\n---------------" << std::endl;
+    for (const media::Track::Id &id : tracklist.tracks().get())
+    {
+        // '*' denotes the current track
+        out << "\t" << ((dynamic_cast<media::TrackListSkeleton*>(non_const_tl)->current() == id) ? "*" : "");
+        out << "Track Id: " << id << std::endl;
+        out << "\t\turi: " << dynamic_cast<media::TrackListImplementation*>(non_const_tl)->query_uri_for_track(id) << std::endl;
+        //out << "\t\thas_next: " << tracklist.has_next(
+    }
+
+    out << "---------------\nEnd TrackList" << std::endl;
+    return out;
+}
+

=== modified file 'src/core/media/track_list_skeleton.h'
--- src/core/media/track_list_skeleton.h	2014-03-25 14:57:15 +0000
+++ src/core/media/track_list_skeleton.h	2015-04-14 02:48:44 +0000
@@ -39,29 +39,42 @@
 
     bool has_next() const;
     const Track::Id& next();
+    const Track::Id& current();
 
     const core::Property<bool>& can_edit_tracks() const;
     const core::Property<Container>& tracks() const;
 
-    const core::Signal<void>& on_track_list_replaced() const;
+    const core::Signal<ContainerTrackIdTuple>& on_track_list_replaced() const;
     const core::Signal<Track::Id>& on_track_added() const;
     const core::Signal<Track::Id>& on_track_removed() const;
     const core::Signal<Track::Id>& on_track_changed() const;
+    const core::Signal<Track::Id>& on_go_to_track() const;
+    core::Signal<Track::Id>& on_go_to_track();
+    core::Signal<Track::Id>& on_track_removed();
 
     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;
+
+    /** Gets called when the shuffle property on the Player interface is changed
+     * by the client */
+    void on_shuffle_changed(bool shuffle);
 
 protected:
     core::Property<bool>& can_edit_tracks();
 
-    core::Signal<void>& on_track_list_replaced();
+    core::Signal<ContainerTrackIdTuple>& on_track_list_replaced();
     core::Signal<Track::Id>& on_track_added();
-    core::Signal<Track::Id>& on_track_removed();
     core::Signal<Track::Id>& on_track_changed();
 
 private:
     struct Private;
     std::unique_ptr<Private> d;
 };
+
+// operator<< pretty prints the given TrackList status to the given output stream.
+std::ostream& operator<<(std::ostream& out, const core::ubuntu::media::TrackList& tracklist);
+
 }
 }
 }

=== modified file 'src/core/media/track_list_stub.cpp'
--- src/core/media/track_list_stub.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_stub.cpp	2015-04-14 02:48:44 +0000
@@ -59,10 +59,11 @@
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::CanEditTracks>> can_edit_tracks;
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::Tracks>> tracks;
 
-    core::Signal<void> on_track_list_replaced;
+    core::Signal<media::TrackList::ContainerTrackIdTuple> on_track_list_replaced;
     core::Signal<Track::Id> on_track_added;
     core::Signal<Track::Id> on_track_removed;
     core::Signal<Track::Id> on_track_changed;
+    core::Signal<Track::Id> on_go_to_track;
 };
 
 media::TrackListStub::TrackListStub(
@@ -137,18 +138,36 @@
         throw std::runtime_error("Problem adding track: " + op.error());
 }
 
-const core::Signal<void>& media::TrackListStub::on_track_list_replaced() const
-{
+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()
+{
+    std::cerr << "reset() does nothing from the client side" << std::endl;
+}
+
+const core::Signal<media::TrackList::ContainerTrackIdTuple>& media::TrackListStub::on_track_list_replaced() const
+{
+    std::cout << "Signal on_track_list_replaced arrived via the bus" << std::endl;
     return d->on_track_list_replaced;
 }
 
 const core::Signal<media::Track::Id>& media::TrackListStub::on_track_added() const
 {
+    std::cout << "Signal on_track_added arrived via the bus" << std::endl;
     return d->on_track_added;
 }
 
 const core::Signal<media::Track::Id>& media::TrackListStub::on_track_removed() const
 {
+    std::cout << "Signal on_track_removed arrived via the bus" << std::endl;
     return d->on_track_removed;
 }
 
@@ -156,3 +175,8 @@
 {
     return d->on_track_changed;
 }
+
+const core::Signal<media::Track::Id>& media::TrackListStub::on_go_to_track() const
+{
+    return d->on_go_to_track;
+}

=== modified file 'src/core/media/track_list_stub.h'
--- src/core/media/track_list_stub.h	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_stub.h	2015-04-14 02:48:44 +0000
@@ -51,10 +51,16 @@
 
     void go_to(const Track::Id& track);
 
-    const core::Signal<void>& on_track_list_replaced() const;
+    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<Track::Id>& on_track_removed() const;
     const core::Signal<Track::Id>& on_track_changed() const;
+    const core::Signal<Track::Id>& on_go_to_track() const;
 
 private:
     struct Private;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-11-26 11:04:57 +0000
+++ tests/CMakeLists.txt	2015-04-14 02:48:44 +0000
@@ -51,4 +51,5 @@
 )
 
 # add_subdirectory(acceptance-tests)
+add_subdirectory(test-track-list)
 add_subdirectory(unit-tests)

=== added directory 'tests/test-track-list'
=== added file 'tests/test-track-list/CMakeLists.txt'
--- tests/test-track-list/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/test-track-list/CMakeLists.txt	2015-04-14 02:48:44 +0000
@@ -0,0 +1,17 @@
+include_directories(
+    ${CMAKE_SOURCE_DIR}/src)
+
+add_executable(
+    test_track_list
+    test_track_list.cpp
+  )
+
+target_link_libraries(
+    test_track_list
+
+    media-hub-client
+
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${DBUS_LIBRARIES}
+    ${PROCESS_CPP_LDFLAGS}
+)

=== added file 'tests/test-track-list/test_track_list.cpp'
--- tests/test-track-list/test_track_list.cpp	1970-01-01 00:00:00 +0000
+++ tests/test-track-list/test_track_list.cpp	2015-04-14 02:48:44 +0000
@@ -0,0 +1,397 @@
+/*
+ * 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,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY {} without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#include "test_track_list.h"
+#include "../../src/core/media/util/timeout.h"
+
+#include <core/media/service.h>
+#include <core/media/track_list.h>
+
+#include <cassert>
+#include <future>
+#include <iostream>
+#include <thread>
+
+namespace media = core::ubuntu::media;
+using namespace std;
+
+media::TestTrackList::TestTrackList()
+{
+    try {
+        m_hubService = media::Service::Client::instance();
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to connect to media-hub service: " << e.what() << endl;
+    }
+}
+
+media::TestTrackList::~TestTrackList()
+{
+}
+
+std::string media::TestTrackList::create_new_player_session()
+{
+    try {
+        m_hubPlayerSession = m_hubService->create_session(media::Player::Client::default_configuration());
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to start a new media-hub player session: " << e.what() << endl;
+    }
+
+    try {
+        m_hubTrackList = m_hubPlayerSession->track_list();
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to retrieve the current player's TrackList: " << e.what() << endl;
+    }
+
+    std::string uuid;
+    try {
+        uuid.assign(m_hubPlayerSession->uuid());
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to retrieve the current player's uuid: " << e.what() << endl;
+    }
+
+    cout << "Connected to session " << uuid << endl;
+    return uuid;
+}
+
+void media::TestTrackList::detach_player_session(const std::string &uuid)
+{
+    try {
+        m_hubService->detach_session(uuid, media::Player::Client::default_configuration());
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to detach the media-hub player session: " << e.what() << endl;
+    }
+    
+    cout << "Detached session " << uuid << endl;
+}
+
+void media::TestTrackList::reattach_player_session(const std::string &uuid)
+{
+    try {
+        m_hubPlayerSession = m_hubService->reattach_session(uuid, media::Player::Client::default_configuration());
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to reattach the media-hub player session: " << e.what() << endl;
+    }
+
+    try {
+        m_hubTrackList = m_hubPlayerSession->track_list();
+    }
+    catch (std::runtime_error &e) {
+        cerr << "FATAL: Failed to retrieve the current player's TrackList: " << e.what() << endl;
+    }
+    
+    cout << "Re-connected to session " << uuid << endl;
+}
+
+void media::TestTrackList::destroy_player_session(const std::string &uuid)
+{
+    // TODO: explicitly add a destroy session to the Service class after ricmm lands his new creation_session
+    // that returns a session ID. This will allow me to clear the tracklist after each test.
+    m_hubPlayerSession.reset();
+}
+
+void media::TestTrackList::add_track(const string &uri, bool make_current)
+{
+    assert (m_hubTrackList.get() != nullptr);
+
+    cout << "Adding " << uri << " to the TrackList for playback." << endl;
+
+    try {
+        bool can_edit_tracks = m_hubTrackList->can_edit_tracks();
+        cout << "can_edit_tracks: " << (can_edit_tracks ? "yes" : "no") << std::endl;
+        if (can_edit_tracks)
+            m_hubTrackList->add_track_with_uri_at(uri, media::TrackList::after_empty_track(), make_current);
+        else
+            cerr << "Can't add track to TrackList since can_edit_tracks is false" << endl;
+    }
+    catch (std::runtime_error &e) {
+        cerr << "ERROR: Failed to add track " << uri << " to tracklist: " << e.what() << endl;
+    }
+}
+
+#include <unistd.h>
+void media::TestTrackList::test_basic_playback(const std::string &uri1, const std::string &uri2)
+{
+    cout << "--> Running test: test_basic_playback" << std::endl;
+
+    core::Connection c =m_hubTrackList->on_track_added().connect([](const media::Track::Id &new_id)
+    {
+        cout << "Added track to TrackList with Id: " << new_id << endl;
+    });
+
+    //create_new_player_session();
+
+    m_hubPlayerSession->open_uri(uri1);
+    if (!uri2.empty())
+        add_track(uri2);
+
+    //cout << "Waiting for track to be added to TrackList" << endl;
+    //media::Track::Id id = wait_for_on_track_added();
+
+    m_hubPlayerSession->play();
+    m_hubPlayerSession->loop_status() = media::Player::LoopStatus::none;
+
+    if (m_hubPlayerSession->playback_status() == media::Player::PlaybackStatus::playing)
+    {
+        cout << "Waiting for first track to finish playing..." << endl;
+        wait_for_about_to_finish();
+        cout << "Basic playback was successful" << endl;
+    }
+
+    c.disconnect();
+
+    //destroy_player_session();
+}
+
+void media::TestTrackList::test_tracklist_resume(const std::string &uri1, const std::string &uri2, const std::string &uuid)
+{
+    cout << "--> Running test: test_tracklist_resume" << std::endl;
+
+    //create_new_player_session();
+
+    add_track(uri1);
+    add_track(uri2);
+
+    int initial_size = m_hubTrackList->tracks().get().size();
+    cout << "Tracklist size: " << initial_size << endl;
+    detach_player_session(uuid);
+    reattach_player_session(uuid);
+    cout << "Tracklist size: " << m_hubTrackList->tracks().get().size() << endl;
+
+    m_hubPlayerSession->play();
+
+    if (initial_size != m_hubTrackList->tracks().get().size())
+        cout << "Tracklist sizes are different, error in resuming" << endl;
+
+    //destroy_player_session();
+}
+void media::TestTrackList::test_has_next_track(const std::string &uri1, const std::string &uri2)
+{
+    cout << "--> Running test: test_has_next_track" << std::endl;
+
+    //create_new_player_session();
+
+    add_track(uri1);
+    add_track(uri2);
+
+    m_hubPlayerSession->play();
+    m_hubPlayerSession->loop_status() = media::Player::LoopStatus::none;
+
+    if (m_hubPlayerSession->playback_status() == media::Player::PlaybackStatus::playing)
+    {
+        cout << "Waiting for first track to finish playing..." << endl;
+        wait_for_about_to_finish();
+        cout << "Waiting for second track to finish playing..." << endl;
+        wait_for_about_to_finish();
+        cout << "Both tracks played successfully" << endl;
+    }
+    else
+        cerr << "Playback did not start successfully" << endl;
+
+    //destroy_player_session();
+}
+
+void media::TestTrackList::test_shuffle(const std::string &uri1, const std::string &uri2, const std::string &uri3)
+{
+    cout << "--> Running test: test_shuffle" << std::endl;
+
+    add_track(uri1);
+    add_track(uri2);
+    add_track(uri3);
+    add_track(uri3);
+    add_track(uri2);
+    add_track(uri1);
+    add_track(uri1);
+    add_track(uri2);
+
+    m_hubPlayerSession->play();
+    m_hubPlayerSession->loop_status() = media::Player::LoopStatus::playlist;
+    m_hubPlayerSession->shuffle() = true;
+
+    if (m_hubPlayerSession->playback_status() == media::Player::PlaybackStatus::playing)
+    {
+        cout << "Waiting for first track to finish playing..." << endl;
+        wait_for_about_to_finish();
+
+        cout << "Turning off shuffle mode" << endl;
+        m_hubPlayerSession->shuffle() = false;
+
+        cout << "Waiting for second track to finish playing..." << endl;
+        wait_for_about_to_finish();
+
+        cout << "Going straight to the Track with Id of '/core/ubuntu/media/Service/sessions/0/TrackList/4'" << std::endl;
+        const media::Track::Id id{"/core/ubuntu/media/Service/sessions/0/TrackList/4"};
+        m_hubTrackList->go_to(id);
+        cout << "Waiting for third track to finish playing..." << endl;
+        wait_for_about_to_finish();
+    }
+    else
+        cerr << "Playback did not start successfully" << endl;
+}
+
+void media::TestTrackList::test_remove_track(const std::string &uri1, const std::string &uri2, const std::string &uri3)
+{
+    cout << "--> Running test: test_remove_track" << std::endl;
+
+    core::Connection c =m_hubTrackList->on_track_removed().connect([](const media::Track::Id &new_id)
+    {
+        cout << "Removed track from TrackList with Id: " << new_id << endl;
+    });
+
+    add_track(uri1);
+    add_track(uri2);
+    add_track(uri3);
+
+    m_hubPlayerSession->play();
+
+    if (m_hubPlayerSession->playback_status() == media::Player::PlaybackStatus::playing)
+    {
+        cout << "Waiting for first track to finish playing..." << endl;
+        wait_for_about_to_finish();
+
+        const media::Track::Id id{"/core/ubuntu/media/Service/sessions/0/TrackList/1"};
+        m_hubTrackList->remove_track(id);
+
+        cout << "Waiting for track after removed track to finish playing..." << endl;
+        wait_for_about_to_finish();
+    }
+    else
+        cerr << "Playback did not start successfully" << endl;
+}
+
+template<class T>
+bool media::TestTrackList::verify_signal_is_emitted(const core::Signal<T> &signal, const std::chrono::milliseconds &timeout)
+{
+    bool signal_emitted = false;
+#if 0
+            static const std::chrono::milliseconds timeout{1000};
+            media::timeout(timeout.count(), true, [wp]()
+            {
+                if (auto sp = wp.lock())
+                    sp->on_client_died();
+            });
+    signal.connect([signal_emitted]()
+    {
+    });
+#endif
+
+    return false;
+}
+
+void media::TestTrackList::wait_for_about_to_finish()
+{
+    bool received_about_to_finish = false;
+    core::Connection c = m_hubPlayerSession->about_to_finish().connect([&received_about_to_finish]()
+    {
+        cout << "AboutToFinish signaled" << endl;
+        received_about_to_finish = true;
+    });
+    while (!received_about_to_finish)
+        std::this_thread::yield();
+
+    c.disconnect();
+}
+
+void media::TestTrackList::wait_for_end_of_stream()
+{
+    bool reached_end_of_first_track = false;
+    core::Connection c = m_hubPlayerSession->end_of_stream().connect([&reached_end_of_first_track]()
+    {
+        cout << "EndOfStream signaled" << endl;
+        reached_end_of_first_track = true;
+    });
+    while (!reached_end_of_first_track)
+        std::this_thread::yield();
+
+    c.disconnect();
+}
+
+void media::TestTrackList::wait_for_playback_status_changed(core::ubuntu::media::Player::PlaybackStatus status)
+{
+    bool received_playback_status_changed = false;
+    core::Connection c = m_hubPlayerSession->playback_status().changed().connect([&received_playback_status_changed, &status](media::Player::PlaybackStatus new_status)
+    {
+        cout << "PlaybackStatusChanged signaled" << endl;
+        if (new_status == status)
+            received_playback_status_changed = true;
+    });
+    while (!received_playback_status_changed)
+        std::this_thread::yield();
+
+    c.disconnect();
+}
+
+core::ubuntu::media::Track::Id media::TestTrackList::wait_for_on_track_added()
+{
+    media::Track::Id id;
+    bool received_on_track_added = false;
+    core::Connection c = m_hubTrackList->on_track_added().connect([&received_on_track_added, &id](const media::Track::Id &new_id)
+    {
+        cout << "OnTrackAdded signaled" << endl;
+        id = new_id;
+        received_on_track_added = true;
+    });
+    while (!received_on_track_added)
+        std::this_thread::yield();
+
+    c.disconnect();
+
+    return id;
+}
+
+int main (int argc, char **argv)
+{
+    shared_ptr<media::TestTrackList> tracklist = make_shared<media::TestTrackList>();
+
+    if (argc == 2)
+    {
+        tracklist->create_new_player_session();
+        tracklist->test_basic_playback(argv[1]);
+    }
+    else if (argc == 3)
+    {
+        tracklist->create_new_player_session();
+        tracklist->test_basic_playback(argv[1], argv[2]);
+        tracklist->test_has_next_track(argv[1], argv[2]);
+    }
+    else if (argc == 4)
+    {
+        tracklist->create_new_player_session();
+        tracklist->test_basic_playback(argv[1]);
+        tracklist->test_has_next_track(argv[1], argv[2]);
+        tracklist->test_shuffle(argv[1], argv[2], argv[3]);
+        tracklist->test_remove_track(argv[1], argv[2], argv[3]);
+    }
+    else if (argc == 5)
+    {
+        std::string uuid = tracklist->create_new_player_session();
+        tracklist->test_tracklist_resume(argv[1], argv[2], uuid);
+    }
+    else
+    {
+        cout << "Can't test TrackList, no track(s) specified." << endl;
+        cout << argv[0] << " <track_uri_1> [<track_uri_2>] [<track_uri_3>]" << endl;
+    }
+
+    return 0;
+}

=== added file 'tests/test-track-list/test_track_list.h'
--- tests/test-track-list/test_track_list.h	1970-01-01 00:00:00 +0000
+++ tests/test-track-list/test_track_list.h	2015-04-14 02:48:44 +0000
@@ -0,0 +1,88 @@
+/*
+ * 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,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY {} without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#ifndef TEST_TRACK_LIST_H_
+#define TEST_TRACK_LIST_H_
+
+#include <core/media/player.h>
+#include <core/media/track.h>
+
+#include <core/dbus/signal.h>
+
+#include <chrono>
+#include <memory>
+#include <string>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+
+class Player;
+class Service;
+class TrackList;
+
+class TestTrackList
+{
+public:
+    TestTrackList();
+    ~TestTrackList();
+
+    std::string create_new_player_session();
+    void detach_player_session(const std::string &uuid);
+    void reattach_player_session(const std::string &uuid);
+    void destroy_player_session(const std::string &uuid);
+
+    void add_track(const std::string &uri, bool make_current = false);
+
+    // Takes in one or two files for playback, adds it/them to the TrackList, and plays
+    void test_basic_playback(const std::string &uri1, const std::string &uri2 = std::string{});
+
+    // 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);
+    // Takes in one or two files for playback, adds it/them to the TrackList, plays and makes sure
+    // that the Player advances the TrackList
+    void test_has_next_track(const std::string &uri1, const std::string &uri2);
+
+    void test_shuffle(const std::string &uri1, const std::string &uri2, const std::string &uri3);
+
+    void test_remove_track(const std::string &uri1, const std::string &uri2, const std::string &uri3);
+
+protected:
+    // Synchronously verify that a signal is emitted waiting up to timeout milliseconds
+    template<class T>
+    bool verify_signal_is_emitted(const core::Signal<T> &signal, const std::chrono::milliseconds &timeout);
+
+    void wait_for_about_to_finish();
+    void wait_for_end_of_stream();
+    void wait_for_playback_status_changed(core::ubuntu::media::Player::PlaybackStatus status);
+    core::ubuntu::media::Track::Id wait_for_on_track_added();
+
+private:
+    std::shared_ptr<core::ubuntu::media::Service> m_hubService;
+    std::shared_ptr<core::ubuntu::media::Player> m_hubPlayerSession;
+    std::shared_ptr<core::ubuntu::media::TrackList> m_hubTrackList;
+};
+
+} // media
+} // ubuntu
+} // core
+
+#endif

=== modified file 'tests/unit-tests/test-gstreamer-engine.cpp'
--- tests/unit-tests/test-gstreamer-engine.cpp	2015-03-03 22:41:22 +0000
+++ tests/unit-tests/test-gstreamer-engine.cpp	2015-04-14 02:48:44 +0000
@@ -103,7 +103,8 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri));
+    static const bool do_pipeline_reset = true;
+    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
     EXPECT_TRUE(engine.play());
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
@@ -144,7 +145,8 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri));
+    static const bool do_pipeline_reset = true;
+    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
     EXPECT_TRUE(engine.play());
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
@@ -234,7 +236,8 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri));
+    static const bool do_pipeline_reset = true;
+    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
     EXPECT_TRUE(engine.play());
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
@@ -282,7 +285,8 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri));
+    static const bool do_pipeline_reset = true;
+    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
     EXPECT_TRUE(engine.play());
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
@@ -328,7 +332,8 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri));
+    static const bool do_pipeline_reset = true;
+    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
     EXPECT_TRUE(engine.play());
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
@@ -363,7 +368,8 @@
                     &core::testing::WaitableStateTransition<core::ubuntu::media::Engine::State>::trigger,
                     std::ref(wst),
                     std::placeholders::_1));
-    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri));
+    static const bool do_pipeline_reset = true;
+    EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
     EXPECT_TRUE(engine.play());
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,