Merge lp:~thomas-voss/media-hub/enable-dual-landings into lp:media-hub

[Thomas Voß]

Enable dual landings.

Enable dual landings.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:160
http://jenkins.qa.ubuntu.com/job/media-hub-ci/378/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/218
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/218
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/218/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/218

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/media-hub-ci/378/rebuild

review: Approve (continuous-integration)

[lp:~thomas-voss/media-hub/enable-dual-landings]

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

* Set gstreamer context directly instead of using gobject to
  communicate with the video sink
[ CI Train Bot ]
* No-change rebuild.
[ Jim Hodapp ]
* Added move_track and various fixes for TrackList.
* Major bump for new TrackList API changes.
[ Alfonso Sanchez-Beato ]
* Make sure our iterator for the current track points to the right
  place when (un)shuffling (LP #1510219). Fix crash when client tries
  to set the player for a non-existing key. Do not add empty URIs to
  the list (LP: #1511029). (LP: #1511073, #1511385, #1510219,
  #1510227, #1511029)
* Force rebuild against dbus-cpp.

162. By Thomas Voß on 2015-12-16

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

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:161
http://jenkins.qa.ubuntu.com/job/media-hub-ci/379/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/219
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/219
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/219/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/219

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/media-hub-ci/379/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:162
http://jenkins.qa.ubuntu.com/job/media-hub-ci/380/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/220
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/220
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/220/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/220

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/media-hub-ci/380/rebuild

review: Approve (continuous-integration)

[Jim Hodapp (jhodapp)]

LGTM

review: Approve (code)

[Łukasz Zemczak (sil2100)]

Dual-landability-wise it looks ok, don't have any obvious concerns. The only concern I have is the lack of symbol files and/or anything else like a combination of shlibs+abi-compliance-checker. I also noticed that media-hub dropped its symbol files a while ago again and I was unable to find out who signed it off (maybe me?). If someone did, I wonder what was the agreement as I suppose no one sane would let this happen without some kind of a declaration like: "ok, we'll add those in x weeks".

So this is obviously my only concern. If some core-developer with more experience than me says: "ok, this is good to go without abi checks or symbols" then I guess it's fine.

review: Needs Information (packaging)

[lp:~thomas-voss/media-hub/enable-dual-landings]

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

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

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:163
http://jenkins.qa.ubuntu.com/job/media-hub-ci/384/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/224
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/224
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/224/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/224

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/media-hub-ci/384/rebuild

review: Approve (continuous-integration)

[Timo Jyrinki (timo-jyrinki)]

I checked and there's no unit test for the abi compliance testing. This'd be needed to fully implement https://wiki.ubuntu.com/citrain/LandingProcess#Dual-landing_and_handling_symbols

Like http://bazaar.launchpad.net/~unity-team/unity-scopes-api/devel/files/head:/test/abi-compliance/

review: Needs Information (packaging)

[Łukasz Zemczak (sil2100)]

I have the same concerns as Timo, but I have agreed to let this in without ACC temporarily. This project never had valid symbols files so it's no regression here. Thomas promised to take care of all the ABI compliance bits as a priority for the next release - so approving conditionally.

review: Approve (packaging)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-10-16 08:32:58 +0000
+++ CMakeLists.txt	2015-12-23 14:21:20 +0000
@@ -2,9 +2,32 @@
 
 project(ubuntu-media-hub)
 
-set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 4)
-set(UBUNTU_MEDIA_HUB_VERSION_MINOR 1)
-set(UBUNTU_MEDIA_HUB_VERSION_PATCH 0)
+# We haven't received version information via the packaging setup.
+# For that, we try to determine sensible values on our own, ensuring
+# plain old invocations to cmake still work as expected.
+if (NOT DEFINED UBUNTU_MEDIA_HUB_VERSION_MAJOR)
+  find_program(LSB_RELEASE lsb_release)
+  execute_process(
+    COMMAND ${LSB_RELEASE} -c -s
+    OUTPUT_VARIABLE DISTRO_CODENAME
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  # We explicitly ignore errors and only check if we are building for vivid.
+  # For all other cases:
+  #   - releases other than vivid
+  #   - other distros
+  #   - errors
+  # we define the version to be 5.0.0
+  if (${DISTRO_CODENAME} STREQUAL "vivid")
+    set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 4)
+    set(UBUNTU_MEDIA_HUB_VERSION_MINOR 1)
+    set(UBUNTU_MEDIA_HUB_VERSION_PATCH 0)
+  else ()
+    set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 5)
+    set(UBUNTU_MEDIA_HUB_VERSION_MINOR 0)
+    set(UBUNTU_MEDIA_HUB_VERSION_PATCH 0)
+  endif()
+endif()
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -fPIC -pthread")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -fno-strict-aliasing -Wextra -fPIC -pthread")

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

=== added file 'debian/VERSION'
--- debian/VERSION	1970-01-01 00:00:00 +0000
+++ debian/VERSION	2015-12-23 14:21:20 +0000
@@ -0,0 +1,1 @@
+5.0.0
\ No newline at end of file

=== added file 'debian/VERSION.vivid'
--- debian/VERSION.vivid	1970-01-01 00:00:00 +0000
+++ debian/VERSION.vivid	2015-12-23 14:21:20 +0000
@@ -0,0 +1,1 @@
+4.1.0
\ No newline at end of file

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

=== modified file 'debian/control'
--- debian/control	2015-09-07 10:15:51 +0000
+++ debian/control	2015-12-23 14:21:20 +0000
@@ -1,3 +1,8 @@
+# This file is autogenerated. DO NOT EDIT!
+#
+# Modifications should be made to control.in instead.
+# This file is regenerated automatically in the clean target.
+#
 Source: media-hub
 Priority: optional
 Section: libs
@@ -22,6 +27,7 @@
                libproperties-cpp-dev,
                libgstreamer1.0-dev,
                libgstreamer-plugins-base1.0-dev,
+               lsb-release,
                pkg-config,
                libpulse-dev,
                qtbase5-dev,

=== added file 'debian/control.in'
--- debian/control.in	1970-01-01 00:00:00 +0000
+++ debian/control.in	2015-12-23 14:21:20 +0000
@@ -0,0 +1,94 @@
+Source: media-hub
+Priority: optional
+Section: libs
+Maintainer: Ubuntu Developers <[e-mail]>
+Build-Depends: cmake,
+               dbus-test-runner,
+               debhelper (>= 9),
+               dh-apparmor,
+               doxygen,
+               google-mock,
+               graphviz,
+               gstreamer1.0-plugins-good,
+               libboost-dev (>=1.53),
+               libboost-filesystem-dev (>=1.53),
+               libboost-program-options-dev (>=1.53),
+               libboost-system-dev (>=1.53),
+               libdbus-1-dev,
+               libdbus-cpp-dev (>= 4.3.0),
+               libgoogle-glog-dev,
+               libhybris-dev (>=0.1.0+git20131207+e452e83-0ubuntu30),
+               libprocess-cpp-dev,
+               libproperties-cpp-dev,
+               libgstreamer1.0-dev,
+               libgstreamer-plugins-base1.0-dev,
+               lsb-release,
+               pkg-config,
+               libpulse-dev,
+               qtbase5-dev,
+               libtelepathy-qt5-dev,
+Standards-Version: 3.9.6
+Homepage: https://launchpad.net/media-hub
+# If you aren't a member of ~phablet-team but need to upload packaging changes,
+# just go ahead.  ~phablet-team will notice and sync up the code again.
+Vcs-Bzr: https://code.launchpad.net/~phablet-team/media-hub/trunk
+
+Package: libmedia-hub-dev
+Section: libdevel
+Architecture: any
+Multi-Arch: same
+Depends: libmedia-hub-common@MEDIA_HUB_SOVERSION@ (= ${binary:Version}),
+         libmedia-hub-client@MEDIA_HUB_SOVERSION@ (= ${binary:Version}),
+         ${misc:Depends},
+         libproperties-cpp-dev,
+Suggests: libmedia-hub-doc
+Description: Simple and lightweight media playback service - development files
+ Media Hub is a simple and lightweight service for media playback using
+ DBus.
+ .
+ This package contains the development files.
+
+Package: media-hub
+Architecture: any
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Suggests: apparmor (>= 2.8.95~2430-0ubuntu4~)
+Description: Simple and lightweight media playback service
+ Media Hub is a simple and lightweight service for media playback using
+ DBus.
+ .
+ This package contains the runtime.
+
+Package: libmedia-hub-common@MEDIA_HUB_SOVERSION@
+Architecture: any
+Multi-Arch: same
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Simple and lightweight media playback service
+ Media Hub is a simple and lightweight service for media playback using
+ DBus.
+ .
+ This package contains the common libraries.
+
+Package: libmedia-hub-client@MEDIA_HUB_SOVERSION@
+Architecture: any
+Multi-Arch: same
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Simple and lightweight media playback service
+ Media Hub is a simple and lightweight service for media playback using
+ DBus.
+ .
+ This package contains the client libraries.
+
+Package: libmedia-hub-doc
+Section: doc
+Architecture: all
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Recommends: libmedia-hub-dev
+Description: Simple and lightweight media playback service - documentation
+ Media Hub is a simple and lightweight service for media playback using
+ DBus.
+ .
+ This package contains the documentation.

=== added file 'debian/gen-debian-files.sh'
--- debian/gen-debian-files.sh	1970-01-01 00:00:00 +0000
+++ debian/gen-debian-files.sh	2015-12-23 14:21:20 +0000
@@ -0,0 +1,102 @@
+#!/bin/sh
+
+# Copyright (C) 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: Michi Henning <[e-mail]>
+#              Thomas Voß <[e-mail]>
+
+#
+# Script to generate debian files for dual landing in Vivid (gcc 4.9 ABI)
+# and Wily and later (gcc 5 ABI).
+#
+# This script is called from debian/rules and generates:
+#
+# - control
+# - libtrust-store${soversion}.install.${target_arch}
+#
+# For all but control, this is a straight substition and/or renaming exercise for each file.
+# For control, if building on Wily or later, we also fix the "Replaces:" and "Conflicts:"
+# entries, so we don't end up with two packages claiming ownership of the same places
+# in the file system.
+#
+# Because the debian files for the different distributions are generated on the fly,
+# this allows us to keep a single source tree for both distributions. See ../HACKING
+# for more explanations.
+#
+
+set -e  # Fail if any command fails.
+
+progname=$(basename $0)
+
+[ $# -ne 1 ] && {
+    echo "usage: $progname path-to-debian-dir" >&2
+    exit 1
+}
+dir=$1
+version_dir=$(mktemp -d)
+
+# Dump version numbers into files and initialize vars from those files.
+
+sh ${dir}/get-versions.sh ${dir} ${version_dir}
+
+full_version=$(cat "${version_dir}"/libmedia-hub.full-version)
+major_minor=$(cat "${version_dir}"/libmedia-hub.major-minor-version)
+soversion=$(cat "${version_dir}"/libmedia-hub.soversion)
+vivid_soversion=$(cat "${version_dir}"/libmedia-hub.vivid-soversion)
+
+warning=$(mktemp -t gen-debian-files-msg.XXX)
+
+trap "rm -fr $warning $version_dir" 0 INT TERM QUIT
+
+warning_msg()
+{
+    cat >$warning <<EOF
+# This file is autogenerated. DO NOT EDIT!
+#
+# Modifications should be made to $(basename "$1") instead.
+# This file is regenerated automatically in the clean target.
+#
+EOF
+}
+
+# Generate debian/control from debian/control.in, substituting the soversion for both libs.
+# For wily onwards, we also add an entry for the vivid versions to "Conflicts:" and "Replaces:".
+
+infile="${dir}"/control.in
+outfile="${dir}"/control
+warning_msg $infile
+cat $warning $infile \
+    | sed -e "s/@MEDIA_HUB_SOVERSION@/${soversion}/" > "$outfile"
+
+[ "$distro" != "vivid" ] && {
+    sed -i -e "/Replaces: libdbus-cpp4,/a\
+\          libdbus-cpp${vivid_soversion}," \
+        "$outfile"
+}
+
+# Generate the install files, naming them according to the soversion.
+
+# Install file for binary package
+infile="${dir}"/libmedia-hub-client.install.in
+outfile="${dir}"/libmedia-hub-client${soversion}.install
+warning_msg "$infile"
+cat $warning "$infile" >"$outfile"
+
+infile="${dir}"/libmedia-hub-common.install.in
+outfile="${dir}"/libmedia-hub-common${soversion}.install
+warning_msg "$infile"
+cat $warning "$infile" >"$outfile"
+
+exit 0

=== added file 'debian/get-versions.sh'
--- debian/get-versions.sh	1970-01-01 00:00:00 +0000
+++ debian/get-versions.sh	2015-12-23 14:21:20 +0000
@@ -0,0 +1,68 @@
+#!/bin/sh
+
+# Copyright (C) 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: Michi Henning <[e-mail]>
+
+#
+# Script to read the version numbers from VERSION and QT-VERSION
+# and write the version components and the soversion numbers
+# into separate files, so we can pick them up from both
+# gen-debian-files.sh and CMakeLists.txt.
+#
+
+set -e  # Fail if any command fails.
+
+progname=$(basename $0)
+
+[ $# -lt 1 -o $# -gt 2 ] && {
+    echo "usage: $progname path-to-debian-dir [output-dir]" >&2
+    exit 1
+}
+dir=$1
+output_dir=`pwd`
+[ $# -eq 2 ] && output_dir=$2
+
+# Write the various version numbers into a bunch of files. This allows
+# us to easily pick them up from both gen-debian-files.sh and CMakeLists.txt.
+
+distro=$(lsb_release -c -s)
+
+full_version=$(cat "${dir}"/VERSION)
+
+major=$(echo $full_version | cut -d'.' -f1)
+minor=$(echo $full_version | cut -d'.' -f2)
+micro=$(echo $full_version | cut -d'.' -f3)
+major_minor="${major}.${minor}"
+
+vivid_full_version=$(cat "${dir}"/VERSION.vivid)
+vivid_major=$(echo $vivid_full_version | cut -d'.' -f1)
+vivid_soversion=$vivid_major
+
+if [ "$distro" = "vivid" ]
+then
+    soversion=${vivid_soversion}
+else
+    soversion="${major}"
+fi
+[ -n $soversion ]
+
+echo ${full_version} >${output_dir}/libmedia-hub.full-version
+echo ${major} >${output_dir}/libmedia-hub.major-version
+echo ${minor} >${output_dir}/libmedia-hub.minor-version
+echo ${micro} >${output_dir}/libmedia-hub.micro-version
+echo ${major_minor} >${output_dir}/libmedia-hub.major-minor-version
+echo ${soversion} >${output_dir}/libmedia-hub.soversion
+echo ${vivid_soversion} >${output_dir}/libmedia-hub.vivid-soversion

=== renamed file 'debian/libmedia-hub-client4.install' => 'debian/libmedia-hub-client.install.in'
=== renamed file 'debian/libmedia-hub-common4.install' => 'debian/libmedia-hub-common.install.in'
=== modified file 'debian/rules'
--- debian/rules	2015-09-01 08:30:08 +0000
+++ debian/rules	2015-12-23 14:21:20 +0000
@@ -8,12 +8,31 @@
 
 include /usr/share/dpkg/default.mk
 
+distro=$(shell lsb_release -c -s)
+
+ifeq ($(distro),vivid)
+	full_version=$(shell cat $(CURDIR)/debian/VERSION.vivid)
+else
+	full_version=$(shell cat $(CURDIR)/debian/VERSION)
+endif
+
+major=$(shell echo $(full_version) | cut -d'.' -f1)
+minor=$(shell echo $(full_version) | cut -d'.' -f2)
+patch=$(shell echo $(full_version) | cut -d'.' -f3)
+
 %:
 	dh $@ --fail-missing --parallel -- -B build 
 
+override_dh_auto_configure:
+	dh_auto_configure -- -DUBUNTU_MEDIA_HUB_VERSION_MAJOR=$(major) -DUBUNTU_MEDIA_HUB_VERSION_MINOR=$(minor) -DUBUNTU_MEDIA_HUB_VERSION_PATCH=$(patch)
+
 override_dh_auto_test:
 	env -u LD_PRELOAD dh_auto_test
 
 override_dh_installdeb:
 	dh_apparmor --profile-name=usr.bin.media-hub-server -pmedia-hub
 	dh_installdeb
+
+override_dh_auto_clean:
+	/bin/sh $(CURDIR)/debian/gen-debian-files.sh $(CURDIR)/debian
+	dh_auto_clean

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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