Merge lp:~thomas-voss/music-hub/add-backend-and-service-implementation into lp:music-hub

[Thomas Voß]

Add backend and server implementation headers.

Add backend and server implementation headers.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3
http://jenkins.qa.ubuntu.com/job/music-hub-ci/5/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/music-hub-saucy-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/music-hub-saucy-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/music-hub-saucy-armhf-ci/5/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/music-hub-saucy-i386-ci/5

Click here to trigger a rebuild:
http://s-jenkins:8080/job/music-hub-ci/5/rebuild

review: Approve (continuous-integration)

[David Henningsson (diwic)]

Not sure what this is supposed to add, but all files in src/com/ubuntu/music/service/* are empty, and there is no CMakeLists for building them either. Are you sure you pushed the right branch?

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:10
http://jenkins.qa.ubuntu.com/job/music-hub-ci/8/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/1/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/music-hub-ci/8/rebuild

review: Needs Fixing (continuous-integration)

[lp:~thomas-voss/music-hub/add-backend-and-service-implementation]

11. By Thomas Voß on 2013-11-07

Add missing build dep on google-mock.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:11
http://jenkins.qa.ubuntu.com/job/music-hub-ci/9/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/2/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/music-hub-ci/9/rebuild

review: Needs Fixing (continuous-integration)

[lp:~thomas-voss/music-hub/add-backend-and-service-implementation]

12. By Thomas Voß on 2013-11-08

Add missing build-dependency on libgstreamer1.0-dev.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:12
http://jenkins.qa.ubuntu.com/job/music-hub-ci/10/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/3/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/music-hub-ci/10/rebuild

review: Needs Fixing (continuous-integration)

[lp:~thomas-voss/music-hub/add-backend-and-service-implementation]

13. By Thomas Voß on 2013-11-08

Add missing build dependencies.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:13
http://jenkins.qa.ubuntu.com/job/music-hub-ci/11/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/4/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/music-hub-ci/11/rebuild

review: Needs Fixing (continuous-integration)

[lp:~thomas-voss/music-hub/add-backend-and-service-implementation]

14. By Thomas Voß on 2013-11-08

Fix build dependencies on libboost-system-dev.
Disable two failing tests.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:14
http://jenkins.qa.ubuntu.com/job/music-hub-ci/12/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/5/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/music-hub-ci/12/rebuild

review: Needs Fixing (continuous-integration)

[lp:~thomas-voss/music-hub/add-backend-and-service-implementation]

15. By Thomas Voß on 2013-11-08

Add build-dependency on libboost-program-options-dev.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:15
http://jenkins.qa.ubuntu.com/job/music-hub-ci/13/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/6/console

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/music-hub-ci/13/rebuild

review: Needs Fixing (continuous-integration)

[lp:~thomas-voss/music-hub/add-backend-and-service-implementation]

16. By Thomas Voß on 2013-11-11

Add fakesink for testing purposes.

17. By Thomas Voß on 2013-11-11

Ensure that the audio sink is set to a fake sink for unit testing purposes.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:17
http://jenkins.qa.ubuntu.com/job/music-hub-ci/14/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-amd64-ci/7/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-armhf-ci/7/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/music-hub-trusty-i386-ci/7

Click here to trigger a rebuild:
http://s-jenkins:8080/job/music-hub-ci/14/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

17. By Thomas Voß on 2013-11-11

Ensure that the audio sink is set to a fake sink for unit testing purposes.

16. By Thomas Voß on 2013-11-11

Add fakesink for testing purposes.

15. By Thomas Voß on 2013-11-08

Add build-dependency on libboost-program-options-dev.

14. By Thomas Voß on 2013-11-08

Fix build dependencies on libboost-system-dev.
Disable two failing tests.

13. By Thomas Voß on 2013-11-08

Add missing build dependencies.

12. By Thomas Voß on 2013-11-08

Add missing build-dependency on libgstreamer1.0-dev.

11. By Thomas Voß on 2013-11-07

Add missing build dep on google-mock.

10. By Thomas Voß on 2013-10-08

More tests passing.

9. By Thomas Voß on 2013-10-07

More refactoring of local spike.

8. By Thomas Voß on 2013-09-22

Add first wave of acceptance tests and ensure that they are passing.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-08-14 18:05:23 +0000
+++ CMakeLists.txt	2013-11-11 13:09:24 +0000
@@ -20,7 +20,7 @@
 include(GNUInstallDirs)
 
 find_package(PkgConfig)
-find_package(Boost 1.49 COMPONENTS system program_options)
+find_package(Boost COMPONENTS filesystem system program_options REQUIRED)
 find_package(GLog)
 pkg_check_modules(DBUS dbus-1 REQUIRED)
 pkg_check_modules(DBUS_CPP dbus-cpp REQUIRED)
@@ -57,6 +57,7 @@
 add_subdirectory(include)
 add_subdirectory(doc)
 add_subdirectory(src)
+add_subdirectory(tests)
 
 # There's no nice way to format this. Thanks CMake.
 add_test(LGPL-required

=== modified file 'debian/control'
--- debian/control	2013-08-23 09:51:12 +0000
+++ debian/control	2013-11-11 13:09:24 +0000
@@ -7,9 +7,18 @@
                dbus-test-runner,
                debhelper (>= 9),
                doxygen,
+               google-mock,
+               graphviz,
+               gstreamer1.0-plugins-good,
+               gstreamer1.0-fluendo-mp3,
                libboost-dev (>=1.53),
+               libboost-filesystem-dev (>=1.53),
+               libboost-program-options-dev (>=1.53),
+               libboost-system-dev (>=1.53),
                libdbus-1-dev,
                libgoogle-glog-dev,
+               gstreamer1.0-libav,
+               libgstreamer1.0-dev,
                pkg-config,
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/music-hub

=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2013-08-14 18:05:23 +0000
+++ doc/Doxyfile.in	2013-11-11 13:09:24 +0000
@@ -668,7 +668,7 @@
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@ @CMAKE_CURRENT_SOURCE_DIR@/../include
+INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/../include @CMAKE_CURRENT_SOURCE_DIR@/../src
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

=== modified file 'include/com/ubuntu/music/connection.h'
--- include/com/ubuntu/music/connection.h	2013-08-13 14:07:37 +0000
+++ include/com/ubuntu/music/connection.h	2013-11-11 13:09:24 +0000
@@ -29,21 +29,17 @@
 {
 class Connection
 {
-  private:
-    struct Private;
+  public:
+    typedef std::function<void()> Disconnector;
 
-  public:
-    Connection(const std::shared_ptr<Private>& d);
-    Connection(const Connection& rhs);    
+    Connection(const Disconnector& disconnector);
     ~Connection();
 
-    Connection& operator=(const Connection& rhs);
-    bool operator==(const Connection& rhs) const;
-
     bool is_connected() const;
     void disconnect();
     
   private:
+    struct Private;
     std::shared_ptr<Private> d;
 };
 

=== modified file 'include/com/ubuntu/music/player.h'
--- include/com/ubuntu/music/player.h	2013-09-08 11:42:36 +0000
+++ include/com/ubuntu/music/player.h	2013-11-11 13:09:24 +0000
@@ -18,8 +18,7 @@
 #ifndef COM_UBUNTU_MUSIC_PLAYER_H_
 #define COM_UBUNTU_MUSIC_PLAYER_H_
 
-#include "com/ubuntu/music/connection.h"
-#include "com/ubuntu/music/track.h"
+#include <com/ubuntu/music/track.h>
 
 #include <chrono>
 #include <memory>
@@ -30,17 +29,30 @@
 {
 namespace music
 {
+template<typename T> class Property;
 class Service;
+template<typename T> class Signal;
 class TrackList;
 
-class Player
+class Player : public std::enable_shared_from_this<Player>
 {
   public:
     typedef double PlaybackRate;
     typedef double Volume;
     
+    struct Configuration;
+
+    struct Client
+    {
+        Client() = delete;
+
+        static const Configuration& default_configuration();
+    };
+
     enum PlaybackStatus
     {
+        null,
+        ready,
         playing,
         paused,
         stopped
@@ -54,62 +66,45 @@
     };
 
     Player(const Player&) = delete;
-    ~Player();
+    virtual ~Player();
 
     Player& operator=(const Player&) = delete;
     bool operator==(const Player&) const = delete;
 
-    const std::shared_ptr<TrackList>& track_list() const;
-
-    bool can_go_next();
-    void next();
-    
-    bool can_go_previous();
-    void previous();
-    
-    bool can_play();
-    void play();
-    
-    bool can_pause();
-    void pause();
-    
-    bool can_seek();
-    void seek_to(const std::chrono::microseconds& offset);
-
-    void stop();
-    
-    PlaybackStatus playback_status() const;
-    Connection on_playback_status_changed(const std::function<void(PlaybackStatus)>& handler);
-    
-    LoopStatus loop_status() const;
-    void set_loop_status(LoopStatus new_status);
-    Connection on_loop_status_changed(const std::function<void(LoopStatus)>& handler);
-
-    PlaybackRate playback_rate() const;
-    void set_playback_rate(PlaybackRate rate);
-    Connection on_playback_rate_changed(const std::function<void(PlaybackRate)>& handler);
-
-    bool is_shuffle() const;
-    void set_shuffle(bool b);
-    Connection on_shuffle_changed(const std::function<void(bool)>& handler);
-
-    Track::MetaData meta_data_for_current_track() const;
-    Connection on_meta_data_for_current_track_changed(const std::function<void(const Track::MetaData&)>& handler);
-
-    Volume volume() const;
-    void set_volume(Volume new_volume);
-    Connection on_volume_changed(const std::function<void(Volume)>& handler);
-
-    PlaybackRate minimum_playback_rate() const;
-    PlaybackRate maximum_playback_rate() const;
-    
-  private:
-    friend class Service;
-
-    Player(const std::shared_ptr<Service>& parent);
-
-    struct Private;
-    std::unique_ptr<Private> d;
+    virtual std::shared_ptr<TrackList> track_list() = 0;
+
+    virtual bool open_uri(const Track::UriType& uri) = 0;
+    virtual void next() = 0;
+    virtual void previous() = 0;
+    virtual void play() = 0;
+    virtual void pause() = 0;
+    virtual void stop() = 0;
+    virtual void seek_to(const std::chrono::microseconds& offset) = 0;
+
+    virtual const Property<bool>& can_play() const = 0;
+    virtual const Property<bool>& can_pause() const = 0;
+    virtual const Property<bool>& can_seek() const = 0;
+    virtual const Property<bool>& can_go_previous() const = 0;
+    virtual const Property<bool>& can_go_next() const = 0;
+    virtual const Property<PlaybackStatus>& playback_status() const = 0;    
+    virtual const Property<LoopStatus>& loop_status() const = 0;
+    virtual const Property<PlaybackRate>& playback_rate() const = 0;
+    virtual const Property<bool>& is_shuffle() const = 0;
+    virtual const Property<Track::MetaData>& meta_data_for_current_track() const = 0;
+    virtual const Property<Volume>& volume() const = 0;
+    virtual const Property<PlaybackRate>& minimum_playback_rate() const = 0;
+    virtual const Property<PlaybackRate>& maximum_playback_rate() const = 0;
+        
+    virtual Property<LoopStatus>& loop_status() = 0;
+    virtual Property<PlaybackRate>& playback_rate() = 0;
+    virtual Property<bool>& is_shuffle() = 0;
+    virtual Property<Volume>& volume() = 0;
+    
+    virtual const Signal<uint64_t>& seeked_to() const = 0;
+
+  protected:
+    Player();
+
 };
 }
 }

=== added file 'include/com/ubuntu/music/property.h'
--- include/com/ubuntu/music/property.h	1970-01-01 00:00:00 +0000
+++ include/com/ubuntu/music/property.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_MUSIC_PROPERTY_H_
+#define COM_UBUNTU_MUSIC_PROPERTY_H_
+
+#include <com/ubuntu/music/signal.h>
+
+#include <iostream>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+template<typename T>
+class Property
+{
+  private:
+    inline static T& mutable_default_value()
+    {
+        static T default_value = T{};
+        return default_value;
+    }
+
+  public:
+    typedef T ValueType;
+
+    inline static const T& default_value()
+    {
+        return mutable_default_value(); 
+    }
+
+    inline static void set_default_value(const T& new_default_value)
+    {
+        mutable_default_value() = new_default_value;
+    }
+
+    inline explicit Property(const T& t = Property<T>::default_value()) : value{t}
+    {
+    }
+
+    inline Property(const Property<T>& rhs) : value{rhs.value}
+    {
+    }
+
+    inline virtual ~Property() = default;
+
+    inline Property& operator=(const T& rhs)
+    {
+        set(rhs);
+        return *this;
+    }
+
+    inline Property& operator=(const Property<T>& rhs)
+    {
+        set(rhs.value);
+        return *this;
+    }
+
+    inline operator const T&() const
+    {
+        return get();
+    }
+
+    inline const T* operator->() const
+    {
+        return &get();
+    }
+
+    friend inline bool operator==(const Property<T>& lhs, const T& rhs)
+    {
+        return lhs.get() == rhs.get();
+    }
+
+    friend inline bool operator==(const Property<T>& lhs, const Property<T>& rhs)
+    {
+        return lhs.get() == rhs.get();
+    }
+
+    inline virtual void set(const T& new_value)
+    {
+        if (value != new_value)
+        {
+            value = new_value;
+            signal_changed(value);
+        }
+    }
+
+    inline virtual const T& get() const
+    {
+        return value;
+    }
+
+    inline const Signal<T>& changed() const
+    {
+        return signal_changed;
+    }
+
+    inline virtual bool update(const std::function<bool(T& t)>& update_functor)
+    {
+        if (update_functor(mutable_get()))
+        {
+            set(value); signal_changed(value);
+            return true;
+        }
+
+        return false;
+    }
+
+  protected:    
+    inline T& mutable_get() const
+    {
+        return value;
+    }
+
+  private:
+    mutable T value;
+    Signal<T> signal_changed;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_PROPERTY_H_

=== modified file 'include/com/ubuntu/music/service.h'
--- include/com/ubuntu/music/service.h	2013-08-13 14:07:37 +0000
+++ include/com/ubuntu/music/service.h	2013-11-11 13:09:24 +0000
@@ -18,6 +18,8 @@
 #ifndef COM_UBUNTU_MUSIC_SERVICE_H_
 #define COM_UBUNTU_MUSIC_SERVICE_H_
 
+#include <com/ubuntu/music/player.h>
+
 #include <memory>
 
 namespace com
@@ -35,16 +37,15 @@
     };
 
     Service(const Service&) = delete;
-    ~Service();
+    virtual ~Service() = default;
 
     Service& operator=(const Service&) = delete;
     bool operator==(const Service&) const = delete;
 
-    std::shared_ptr<Player> create_session();
-    
-  private:
-    friend struct Client;
-    Service();
+    virtual std::shared_ptr<Player> create_session(const Player::Configuration&) = 0;
+
+  protected:
+    Service() = default;
 };
 }
 }

=== added file 'include/com/ubuntu/music/signal.h'
--- include/com/ubuntu/music/signal.h	1970-01-01 00:00:00 +0000
+++ include/com/ubuntu/music/signal.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,149 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_MUSIC_SIGNAL_H_
+#define COM_UBUNTU_MUSIC_SIGNAL_H_
+
+#include <com/ubuntu/music/connection.h>
+
+#include <functional>
+#include <iostream>
+#include <list>
+#include <mutex>
+#include <set>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+template<typename T>
+class Signal
+{
+  public:
+    static unsigned int& tag()
+    {
+        static unsigned int counter = 0;
+        return counter;
+    }
+
+    typedef std::function<void(const T&)> Slot;
+
+    inline Signal() : d(new Private())
+    {
+    }
+
+    Signal(const Signal&) = delete;
+    inline ~Signal() = default;
+
+    Signal& operator=(const Signal&) = delete;
+    bool operator==(const Signal&) const = delete;
+
+    inline Connection connect(const Slot& slot) const
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        auto result = d->slots.insert(d->slots.end(), slot);
+
+        return Connection(
+            std::bind(
+                &Private::disconnect_slot_for_iterator,
+                d,
+                result));
+    }
+
+    void operator()(const T& value)
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        for(auto slot : d->slots)
+        {
+            slot(value);
+        }
+    }
+
+  private:
+    struct Private
+    {
+        void disconnect_slot_for_iterator(typename std::list<Slot>::iterator it)
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            slots.erase(it);
+        }
+        
+        std::mutex guard;
+        std::list<Slot> slots;
+        unsigned int counter = Signal<T>::tag()++;
+    };
+    std::shared_ptr<Private> d;
+};
+
+template<>
+class Signal<void>
+{
+  public:
+    typedef std::function<void()> Slot;
+
+    inline Signal() : d(new Private())
+    {
+    }
+
+    Signal(const Signal&) = delete;
+    inline ~Signal() = default;
+
+    Signal& operator=(const Signal&) = delete;
+    bool operator==(const Signal&) const = delete;
+
+    inline Connection connect(const Slot& slot) const
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        auto result = d->slots.insert(d->slots.end(), slot);
+
+        return Connection(
+            std::bind(
+                &Private::disconnect_slot_for_iterator,
+                d,
+                result));
+    }
+
+    void operator()()
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        for(auto slot : d->slots)
+        {
+            slot();
+        }
+    }
+
+  private:
+    struct Private
+    {
+        void disconnect_slot_for_iterator(typename std::list<Slot>::iterator it)
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            slots.erase(it);
+        }
+
+        std::mutex guard;
+        std::list<Slot> slots;
+    };
+    std::shared_ptr<Private> d;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_SIGNAL_H_

=== modified file 'include/com/ubuntu/music/track.h'
--- include/com/ubuntu/music/track.h	2013-08-13 14:07:37 +0000
+++ include/com/ubuntu/music/track.h	2013-11-11 13:09:24 +0000
@@ -20,9 +20,13 @@
 
 #include "com/ubuntu/music/connection.h"
 
+#include <chrono>
 #include <functional>
+#include <map>
 #include <memory>
+#include <sstream>
 #include <string>
+#include <vector>
 
 namespace com
 {
@@ -30,53 +34,127 @@
 {
 namespace music
 {
+template<typename T> class Property;
+
 class Track
 {
 public:
     typedef std::string UriType;
+    typedef std::string Id;
 
     class MetaData
     {
-      public:
-        typedef std::string KeyType;
-        typedef std::string ValueType;
-        
-        static const KeyType& track_id_key();
-
-        ~MetaData();
-        MetaData(const MetaData&);
-        MetaData& operator=(const MetaData&);
-        bool operator==(const MetaData&) const;
-        
-        bool has_value_for_key(const KeyType& key) const;
-        const ValueType& value_for_key(const KeyType& key) const;
-
-        void for_each(const std::function<void(const KeyType&, const ValueType&)>& f); 
-
-      private:
-        friend class Player;
-        friend class Track;
-
-        MetaData();
-        
-        struct Private;
-        std::unique_ptr<Private> d;
+    public:
+        bool operator==(const MetaData& rhs) const
+        {
+            return map == rhs.map;
+        }
+
+        bool operator!=(const MetaData& rhs) const
+        {
+            return map != rhs.map;
+        }
+
+        template<typename Tag>
+        std::size_t count() const
+        {
+            return count(Tag::name());
+        }
+
+        template<typename Tag>
+        void set(const typename Tag::ValueType& value)
+        {
+            std::stringstream ss; ss << value;
+            set(Tag::name(), ss.str());
+        }
+
+        template<typename Tag>
+        typename Tag::ValueType get() const
+        {
+            std::stringstream ss(get(Tag::name()));
+            typename Tag::ValueType value; ss >> value;
+
+            return std::move(value);
+        }
+
+        std::size_t count(const std::string& key) const
+        {
+            return map.count(key);
+        }
+
+        void set(const std::string& key, const std::string& value)
+        {
+            map[key] = value;
+        }
+
+        const std::string& get(const std::string& key) const
+        {
+            return map.at(key);
+        }
+
+        const std::map<std::string, std::string>& operator*() const
+        {
+            return map;
+        }
+
+    private:
+        std::map<std::string, std::string> map;
     };
 
-    Track(const Track&);
-    ~Track();
+    Track(const Id& id);
+    Track(const Track&) = delete;
+    virtual ~Track();
 
     Track& operator=(const Track&);
     bool operator==(const Track&) const;
 
-    const UriType& uri() const;
-
-    const MetaData& meta_data() const;
-    Connection on_meta_data_changed(const std::function<void(const MetaData&)>& f);
-    
-  private:
-    explicit Track(const UriType& uri, const MetaData& meta_data);
-
+    virtual const Id& id() const;
+    /*
+    class MetaData
+    {
+    public:
+        MetaData() = default;
+        MetaData(const MetaData&) = default;
+        ~MetaData() = default;
+
+        MetaData& operator=(const MetaData&) = default;
+
+        bool operator==(const MetaData&) const
+        {
+            return true;
+        }
+
+        bool operator!=(const MetaData&) const
+        {
+            return false;
+        }
+
+        struct NotImplementedFields
+        {
+            NotImplementedFields() = default;
+
+            virtual const UriType& uri() const = 0;
+            virtual const std::chrono::microseconds length() const = 0;
+            virtual const UriType& art_uri() const = 0;
+            virtual const std::string& album() const = 0;
+            virtual const std::vector<std::string>& album_artist() const = 0;
+            virtual const std::vector<std::string>& artist() const = 0;
+            virtual const std::string& as_text() const = 0;
+            virtual unsigned int audio_bpm() const = 0;
+            virtual float auto_rating() const = 0;
+            virtual const std::vector<std::string>& comment() const = 0;
+            virtual const std::vector<std::string>& composer() const = 0;
+            virtual unsigned int disc_number() const = 0;
+            virtual const std::vector<std::string>& genre() const = 0;
+            virtual const std::vector<std::string>& lyricist() const = 0;
+            virtual const std::string title() const = 0;
+            virtual unsigned int track_number() const = 0;
+            virtual unsigned int use_count() const = 0;
+            virtual float user_rating() const = 0;
+        };
+    };
+*/
+private:
     struct Private;
     std::unique_ptr<Private> d;
 };

=== modified file 'include/com/ubuntu/music/track_list.h'
--- include/com/ubuntu/music/track_list.h	2013-08-13 14:07:37 +0000
+++ include/com/ubuntu/music/track_list.h	2013-11-11 13:09:24 +0000
@@ -18,9 +18,10 @@
 #ifndef COM_UBUNTU_MUSIC_TRACK_LIST_H_
 #define COM_UBUNTU_MUSIC_TRACK_LIST_H_
 
-#include "com/ubuntu/music/track.h"
+#include <com/ubuntu/music/track.h>
 
 #include <functional>
+#include <list>
 #include <memory>
 
 namespace com
@@ -29,33 +30,41 @@
 {
 namespace music
 {
-class TrackList
+class Player;
+template<typename T> class Property;
+template<typename T> class Signal;
+
+class TrackList : public std::enable_shared_from_this<TrackList>
 {
   public:
-    TrackList();
-    TrackList(const TrackList& rhs);
+    typedef std::list<Track::Id> Container;
+    typedef Container::iterator Iterator;
+    typedef Container::const_iterator ConstIterator;
+
+    static const Track::Id& after_empty_track();
+
+    TrackList(const TrackList&) = delete;
     ~TrackList();
 
-    TrackList& operator=(const TrackList&);
-    bool operator==(const TrackList&) const;
-
-    bool is_editable();
-
-    void add_track_with_uri(const Track::UriType& uri, const Track& after, bool make_current);
-    void remove_track(const Track& track);
-
-    void for_each(const std::function<void(const Track&)> functor) const;
-
-    void go_to(const Track& track);
-
-    Connection on_track_list_replaced(const std::function<void()>& slot);
-    Connection on_track_added(const std::function<void(const Track& t)>& slot);
-    Connection on_track_removed(const std::function<void(const Track& t)>& slot);
-    Connection on_current_track_changed(const std::function<void(const Track&)>& slot);
+    TrackList& operator=(const TrackList&) = delete;
+    bool operator==(const TrackList&) const = delete;
+
+    virtual const Property<bool>& can_edit_tracks() const = 0;
+    virtual const Property<Container>& tracks() const = 0;
+
+    virtual Track::MetaData query_meta_data_for_track(const Track::Id& id) = 0;
+    virtual void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current) = 0;
+    virtual void remove_track(const Track::Id& id) = 0;
+
+    virtual void go_to(const Track::Id& track) = 0;
+
+    virtual const Signal<void>& on_track_list_replaced() const = 0;
+    virtual const Signal<Track::Id>& on_track_added() const = 0;
+    virtual const Signal<Track::Id>& on_track_removed() const = 0;
+    virtual const Signal<Track::Id>& on_track_changed() const = 0;
     
-  private:
-    struct Private;
-    std::unique_ptr<Private> d;
+protected:
+    TrackList();
 };
 }
 }

=== modified file 'src/com/ubuntu/music/CMakeLists.txt'
--- src/com/ubuntu/music/CMakeLists.txt	2013-08-14 20:10:09 +0000
+++ src/com/ubuntu/music/CMakeLists.txt	2013-11-11 13:09:24 +0000
@@ -1,15 +1,36 @@
-add_library(
-  music_hub SHARED
+pkg_check_modules(PC_GSTREAMER_1_0 REQUIRED gstreamer-1.0)
+
+include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS})
+
+add_library(
+  music-hub-common SHARED
+
+  the_session_bus.cpp
+)
+
+target_link_libraries(
+  music-hub-common
+
+  ${Boost_LIBRARIES}
+  ${DBUS_LIBRARIES}
+)
+
+add_library(
+  music-hub-client SHARED
   
   connection.cpp
   player.cpp
   service.cpp
   track.cpp
   track_list.cpp
+
+  player_stub.cpp
+  service_stub.cpp
+  track_list_stub.cpp
 )
 
 set_target_properties(
-  music_hub
+  music-hub-client
 
   PROPERTIES
   VERSION ${UBUNTU_MUSIC_HUB_VERSION_MAJOR}.${UBUNTU_MUSIC_HUB_VERSION_MINOR}.${UBUNTU_MUSIC_HUB_VERSION_PATCH}
@@ -17,13 +38,39 @@
 )
 
 target_link_libraries(
-  music_hub
+  music-hub-client
+
+  music-hub-common
 
   ${DBUS_LIBRARIES}
   ${GLog_LIBRARY}
 )
 
 install(
-  TARGETS music_hub
+  TARGETS music-hub-client
   DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
\ No newline at end of file
+)
+
+add_library(
+    music-hub-service
+
+    engine.cpp
+    gstreamer/engine.cpp
+
+    player_skeleton.cpp
+    player_implementation.cpp
+    service_skeleton.cpp
+    service_implementation.cpp
+    track_list_skeleton.cpp
+    track_list_implementation.cpp
+)
+
+target_link_libraries(
+  music-hub-service
+
+  music-hub-common
+
+  ${DBUS_LIBRARIES}
+  ${GLog_LIBRARY}
+  ${PC_GSTREAMER_1_0_LIBRARIES}
+)

=== added file 'src/com/ubuntu/music/codec.h'
--- src/com/ubuntu/music/codec.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/codec.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef CODEC_H_
+#define CODEC_H_
+
+#include <com/ubuntu/music/track.h>
+
+#include <org/freedesktop/dbus/codec.h>
+
+namespace org
+{
+namespace freedesktop
+{
+namespace dbus
+{
+namespace helper
+{
+template<>
+struct TypeMapper<com::ubuntu::music::Track::MetaData>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return ArgumentType::floating_point;
+    }
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+    constexpr static bool requires_signature()
+    {
+        return false;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = TypeMapper<double>::signature();
+        return s;
+    }
+};
+}
+
+template<>
+struct Codec<com::ubuntu::music::Track::MetaData>
+{
+    static void encode_argument(DBusMessageIter* out, const com::ubuntu::music::Track::MetaData& in)
+    {
+        Codec<typename com::ubuntu::location::units::Quantity<T>::value_type>::encode_argument(out, in.value());
+    }
+
+    static void decode_argument(DBusMessageIter* out, com::ubuntu::location::units::Quantity<T>& in)
+    {
+        typename com::ubuntu::location::units::Quantity<T>::value_type value;
+        Codec<typename com::ubuntu::location::units::Quantity<T>::value_type>::decode_argument(out, value);
+        in = com::ubuntu::location::units::Quantity<T>::from_value(value);
+        dbus_message_iter_next(out);
+    }
+};
+}
+}
+}
+
+#endif // CODEC_H_

=== modified file 'src/com/ubuntu/music/connection.cpp'
--- src/com/ubuntu/music/connection.cpp	2013-08-13 14:07:37 +0000
+++ src/com/ubuntu/music/connection.cpp	2013-11-11 13:09:24 +0000
@@ -18,18 +18,41 @@
 
 #include "com/ubuntu/music/connection.h"
 
-#include "connection_private.h"
-
 #include <functional>
 #include <memory>
+#include <mutex>
 
 namespace music = com::ubuntu::music;
 
-music::Connection::Connection(const std::shared_ptr<music::Connection::Private>& p) : d(p)
+struct music::Connection::Private
 {
-}
-
-music::Connection::Connection(const music::Connection& rhs) : d(rhs.d)
+    Private(const music::Connection::Disconnector& disconnector)
+            : disconnector(disconnector)
+    {
+    }
+
+    ~Private()
+    {
+    }
+
+    void disconnect()
+    {
+        static const music::Connection::Disconnector empty_disconnector{};
+
+        std::lock_guard<std::mutex> lg(guard);
+
+        if (!disconnector)
+            return;
+
+        disconnector();
+        disconnector = empty_disconnector;
+    }
+
+    std::mutex guard;
+    music::Connection::Disconnector disconnector;
+};
+
+music::Connection::Connection(const music::Connection::Disconnector& disconnector) : d(new Private(disconnector))
 {
 }
     
@@ -37,23 +60,12 @@
 {
 }
 
-music::Connection& music::Connection::operator=(const music::Connection& rhs)
-{
-    d = rhs.d;
-    return *this;
-}
-
-bool music::Connection::operator==(const music::Connection& rhs) const
-{
-    return d == rhs.d;
-}
-
 bool music::Connection::is_connected() const
 {
-    return d->connection.connected();
+    return (d->disconnector ? true : false);
 }
 
 void music::Connection::disconnect()
 {
-    d->connection.disconnect();
+    d->disconnect();
 }

=== added file 'src/com/ubuntu/music/engine.cpp'
--- src/com/ubuntu/music/engine.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/engine.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include "engine.h"
+
+#include <exception>
+
+namespace music = com::ubuntu::music;
+
+const std::string& music::Engine::Xesam::album()
+{
+    static const std::string s{"xesam:album"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::album_artist()
+{
+    static const std::string s{"xesam:album_artist"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::artist()
+{
+    static const std::string s{"xesam:artist"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::as_text()
+{
+    static const std::string s{"xesam:as_text"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::audio_bpm()
+{
+    static const std::string s{"xesam:audio_bmp"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::auto_rating()
+{
+    static const std::string s{"xesam:autoRating"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::comment()
+{
+    static const std::string s{"xesam:comment"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::composer()
+{
+    static const std::string s{"xesam:composer"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::content_created()
+{
+    static const std::string s{"xesam:contentCreated"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::disc_number()
+{
+    static const std::string s{"xesam:discNumber"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::first_used()
+{
+    static const std::string s{"xesam:firstUsed"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::genre()
+{
+    static const std::string s{"xesam:genre"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::last_used()
+{
+    static const std::string s{"xesam:lastUsed"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::lyricist()
+{
+    static const std::string s{"xesam:lyricist"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::title()
+{
+    static const std::string s{"xesam:title"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::track_number()
+{
+    static const std::string s{"xesam:trackNumber"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::url()
+{
+    static const std::string s{"xesam:url"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::use_count()
+{
+    static const std::string s{"xesam:useCount"};
+    return s;
+}
+
+const std::string& music::Engine::Xesam::user_rating()
+{
+    static const std::string s{"xesam:userRating"};
+    return s;
+}
+
+double music::Engine::Volume::min()
+{
+    return 0.;
+}
+
+double music::Engine::Volume::max()
+{
+    return 1.;
+}
+
+music::Engine::Volume::Volume(double v) : value(v)
+{
+    if (value < min() || value > max())
+        throw std::runtime_error("Value exceeds limits");
+}
+
+bool music::Engine::Volume::operator!=(const music::Engine::Volume& rhs) const
+{
+    return value != rhs.value;
+}
+
+bool music::Engine::Volume::operator==(const music::Engine::Volume& rhs) const
+{
+    return value == rhs.value;
+}

=== added file 'src/com/ubuntu/music/engine.h'
--- src/com/ubuntu/music/engine.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/engine.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_MUSIC_ENGINE_H_
+#define COM_UBUNTU_MUSIC_ENGINE_H_
+
+#include <com/ubuntu/music/property.h>
+#include <com/ubuntu/music/track.h>
+
+#include <chrono>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class Engine
+{
+public:
+
+    enum class State
+    {
+        ready,
+        busy,
+        playing,
+        paused,
+        stopped
+    };
+
+    struct Xesam
+    {
+        static const std::string& album();
+        static const std::string& album_artist();
+        static const std::string& artist();
+        static const std::string& as_text();
+        static const std::string& audio_bpm();
+        static const std::string& auto_rating();
+        static const std::string& comment();
+        static const std::string& composer();
+        static const std::string& content_created();
+        static const std::string& disc_number();
+        static const std::string& first_used();
+        static const std::string& genre();
+        static const std::string& last_used();
+        static const std::string& lyricist();
+        static const std::string& title();
+        static const std::string& track_number();
+        static const std::string& url();
+        static const std::string& use_count();
+        static const std::string& user_rating();
+    };
+
+    struct Volume
+    {
+        static double min();
+        static double max();
+
+        explicit Volume(double v = max());
+
+        bool operator!=(const Volume& rhs) const;
+        bool operator==(const Volume& rhs) const;
+
+        double value;
+    };
+
+    class MetaDataExtractor
+    {
+    public:
+        virtual Track::MetaData meta_data_for_track_with_uri(const Track::UriType& uri) = 0;
+
+    protected:
+        MetaDataExtractor() = default;
+        MetaDataExtractor(const MetaDataExtractor&) = delete;
+        virtual ~MetaDataExtractor() = default;
+
+        MetaDataExtractor& operator=(const MetaDataExtractor&) = delete;
+    };
+
+    virtual const std::shared_ptr<MetaDataExtractor>& meta_data_extractor() const = 0;
+
+    virtual const Property<State>& state() const = 0;
+
+    virtual bool open_resource_for_uri(const Track::UriType& uri) = 0;
+
+    virtual bool play() = 0;
+    virtual bool stop()  = 0;
+    virtual bool pause() = 0;
+    virtual bool seek_to(const std::chrono::microseconds& ts) = 0;
+
+    virtual const Property<Volume>& volume() const = 0;
+    virtual Property<Volume>& volume() = 0;
+
+    virtual const Property<std::tuple<Track::UriType, Track::MetaData>>& track_meta_data() const = 0;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_ENGINE_H_

=== added directory 'src/com/ubuntu/music/gstreamer'
=== added file 'src/com/ubuntu/music/gstreamer/bus.h'
--- src/com/ubuntu/music/gstreamer/bus.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/gstreamer/bus.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,345 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef GSTREAMER_BUS_H_
+#define GSTREAMER_BUS_H_
+
+#include <com/ubuntu/music/signal.h>
+
+#include <gst/gst.h>
+
+#include <boost/flyweight.hpp>
+
+#include <exception>
+#include <functional>
+#include <memory>
+#include <tuple>
+
+namespace gstreamer
+{
+class Bus
+{
+public:
+    struct Message
+    {
+        ~Message()
+        {
+            if (cleanup)
+                cleanup();
+
+            gst_message_unref(message);
+        }
+
+        Message(GstMessage* msg)
+            : message(msg),
+              type(GST_MESSAGE_TYPE(msg)),
+              source(GST_MESSAGE_SRC_NAME(msg)),
+              sequence_number(gst_message_get_seqnum(msg))
+        {
+            switch(type)
+            {
+            case GST_MESSAGE_UNKNOWN:
+                throw std::runtime_error("Cannot construct message for type unknown");
+                break;
+            case GST_MESSAGE_EOS:
+                break;
+            case GST_MESSAGE_ERROR:
+            {
+                gst_message_parse_error(
+                            msg,
+                            &detail.error_warning_info.error,
+                            &detail.error_warning_info.debug);
+                cleanup = [this]()
+                {
+                    g_error_free(detail.error_warning_info.error);
+                    g_free(detail.error_warning_info.debug);
+                };
+                break;
+            }
+            case GST_MESSAGE_WARNING:
+                gst_message_parse_warning(
+                            msg,
+                            &detail.error_warning_info.error,
+                            &detail.error_warning_info.debug);
+                cleanup = [this]()
+                {
+                    g_error_free(detail.error_warning_info.error);
+                    g_free(detail.error_warning_info.debug);
+                };
+                break;
+                break;
+            case GST_MESSAGE_INFO:
+                gst_message_parse_info(
+                            msg,
+                            &detail.error_warning_info.error,
+                            &detail.error_warning_info.debug);
+                cleanup = [this]()
+                {
+                    g_error_free(detail.error_warning_info.error);
+                    g_free(detail.error_warning_info.debug);
+                };
+                break;
+                break;
+            case GST_MESSAGE_TAG:
+                gst_message_parse_tag(
+                            msg,
+                            &detail.tag.tag_list);
+                cleanup = [this]()
+                {
+                    gst_tag_list_free(detail.tag.tag_list);
+                };
+                break;
+            case GST_MESSAGE_BUFFERING:
+                gst_message_parse_buffering(
+                            msg,
+                            &detail.buffering.percent);
+                break;
+            case GST_MESSAGE_STATE_CHANGED:
+                gst_message_parse_state_changed(
+                            msg,
+                            &detail.state_changed.old_state,
+                            &detail.state_changed.new_state,
+                            &detail.state_changed.pending_state);
+                break;
+            case GST_MESSAGE_STATE_DIRTY:
+                break;
+            case GST_MESSAGE_STEP_DONE:
+                gst_message_parse_step_done(
+                            msg,
+                            &detail.step_done.format,
+                            &detail.step_done.amount,
+                            &detail.step_done.rate,
+                            &detail.step_done.flush,
+                            &detail.step_done.intermediate,
+                            &detail.step_done.duration,
+                            &detail.step_done.eos
+                            );
+                break;
+            case GST_MESSAGE_CLOCK_PROVIDE:
+                gst_message_parse_clock_provide(
+                            msg,
+                            &detail.clock_provide.clock,
+                            &detail.clock_provide.ready);
+                break;
+            case GST_MESSAGE_CLOCK_LOST:
+                gst_message_parse_clock_lost(
+                            msg,
+                            &detail.clock_lost.clock);
+                break;
+            case GST_MESSAGE_NEW_CLOCK:
+                gst_message_parse_new_clock(
+                            msg,
+                            &detail.clock_new.clock);
+                break;
+            case GST_MESSAGE_STRUCTURE_CHANGE:
+                break;
+            case GST_MESSAGE_STREAM_STATUS:
+                break;
+            case GST_MESSAGE_APPLICATION:
+                break;
+            case GST_MESSAGE_ELEMENT:
+                break;
+            case GST_MESSAGE_SEGMENT_START:
+                gst_message_parse_segment_start(
+                            msg,
+                            &detail.segment_start.format,
+                            &detail.segment_start.position);
+                break;
+            case GST_MESSAGE_SEGMENT_DONE:
+                gst_message_parse_segment_done(
+                            msg,
+                            &detail.segment_done.format,
+                            &detail.segment_done.position);
+                break;
+            case GST_MESSAGE_DURATION_CHANGED:
+                break;
+            case GST_MESSAGE_LATENCY:
+                break;
+            case GST_MESSAGE_ASYNC_START:
+                break;
+            case GST_MESSAGE_ASYNC_DONE:
+                gst_message_parse_async_done(
+                            msg,
+                            &detail.async_done.running_time);
+                break;
+            case GST_MESSAGE_REQUEST_STATE:
+                break;
+            case GST_MESSAGE_STEP_START:
+                gst_message_parse_step_start(
+                            msg,
+                            &detail.step_start.active,
+                            &detail.step_start.format,
+                            &detail.step_start.amount,
+                            &detail.step_start.rate,
+                            &detail.step_start.flush,
+                            &detail.step_start.intermediate);
+                break;
+            case GST_MESSAGE_QOS:
+                gst_message_parse_qos(
+                            msg,
+                            &detail.qos.live,
+                            &detail.qos.running_time,
+                            &detail.qos.stream_time,
+                            &detail.qos.timestamp,
+                            &detail.qos.duration);
+                break;
+            case GST_MESSAGE_PROGRESS:
+                break;
+            case GST_MESSAGE_TOC:
+                break;
+            case GST_MESSAGE_RESET_TIME:
+                break;
+            case GST_MESSAGE_STREAM_START:
+                break;
+            case GST_MESSAGE_NEED_CONTEXT:
+                break;
+            case GST_MESSAGE_HAVE_CONTEXT:
+                break;
+            case GST_MESSAGE_ANY:
+                break;
+            }
+        }
+
+        GstMessage* message;
+        GstMessageType type;
+        boost::flyweight<std::string> source;
+        uint32_t sequence_number;
+
+        union Detail
+        {
+            struct ErrorWarningInfo
+            {
+                GError* error;
+                gchar* debug;
+            } error_warning_info;
+            struct Tag
+            {
+                GstTagList* tag_list;
+            } tag;
+            struct
+            {
+                gint percent;
+            } buffering;
+            struct
+            {
+                GstBufferingMode buffering_mode;
+                gint avg_in;
+                gint avg_out;
+                gint64 buffering_left;
+            } buffering_stats;
+            struct StateChanged
+            {
+                GstState old_state;
+                GstState new_state;
+                GstState pending_state;
+            } state_changed;
+            struct
+            {
+                gboolean active;
+                GstFormat format;
+                guint64 amount;
+                gdouble rate;
+                gboolean flush;
+                gboolean intermediate;
+            } step_start;
+            struct
+            {
+                GstFormat format;
+                guint64 amount;
+                gdouble rate;
+                gboolean flush;
+                gboolean intermediate;
+                guint64 duration;
+                gboolean eos;
+            } step_done;
+            struct
+            {
+                GstClock* clock;
+                gboolean ready;
+            } clock_provide;
+            struct
+            {
+                GstClock* clock;
+            } clock_lost;
+            struct
+            {
+                GstClock* clock;
+            } clock_new;
+            struct
+            {
+                GstFormat format;
+                gint64 position;
+            } segment_start;
+            struct
+            {
+                GstFormat format;
+                gint64 position;
+            } segment_done;
+            struct
+            {
+                GstClockTime running_time;
+            } async_done;
+            struct
+            {
+                gboolean live;
+                guint64 running_time;
+                guint64 stream_time;
+                guint64 timestamp;
+                guint64 duration;
+            } qos;
+        } detail;
+        std::function<void()> cleanup;
+    };
+
+    static GstBusSyncReply sync_handler(
+            GstBus* bus,
+            GstMessage* msg,
+            gpointer data)
+    {
+        (void) bus;
+
+        auto thiz = static_cast<Bus*>(data);
+        Message message(msg);
+        thiz->on_new_message(message);
+
+        return GST_BUS_DROP;
+    }
+
+    Bus(GstBus* bus) : bus(bus)
+    {
+        if (!bus)
+            throw std::runtime_error("Cannot create Bus instance if underlying instance is NULL.");
+
+        gst_bus_set_sync_handler(
+                    bus,
+                    Bus::sync_handler,
+                    this,
+                    nullptr);
+    }
+
+    ~Bus()
+    {
+        gst_object_unref(bus);
+    }
+
+    GstBus* bus;
+    com::ubuntu::music::Signal<Message> on_new_message;
+};
+}
+
+#endif // GSTREAMER_BUS_H_

=== added file 'src/com/ubuntu/music/gstreamer/engine.cpp'
--- src/com/ubuntu/music/gstreamer/engine.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/gstreamer/engine.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,283 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include "bus.h"
+#include "engine.h"
+#include "meta_data_extractor.h"
+#include "playbin.h"
+
+#include <cassert>
+
+namespace music = com::ubuntu::music;
+
+namespace gstreamer
+{
+struct Init
+{
+    Init()
+    {
+        gst_init(nullptr, nullptr);
+    }
+
+    ~Init()
+    {
+        gst_deinit();
+    }
+} init;
+}
+
+struct gstreamer::Engine::Private
+{
+    void about_to_finish()
+    {
+        state = Engine::State::ready;
+    }
+
+    void on_playbin_state_changed(
+            const gstreamer::Bus::Message::Detail::StateChanged&)
+    {
+    }
+
+    void on_tag_available(const gstreamer::Bus::Message::Detail::Tag& tag)
+    {
+        music::Track::MetaData md;
+
+        gst_tag_list_foreach(
+                    tag.tag_list,
+                    [](const GstTagList *list,
+                    const gchar* tag,
+                    gpointer user_data)
+        {
+            (void) list;
+
+            static const std::map<std::string, std::string> gstreamer_to_mpris_tag_lut =
+            {
+                {GST_TAG_ALBUM, music::Engine::Xesam::album()},
+                {GST_TAG_ALBUM_ARTIST, music::Engine::Xesam::album_artist()},
+                {GST_TAG_ARTIST, music::Engine::Xesam::artist()},
+                {GST_TAG_LYRICS, music::Engine::Xesam::as_text()},
+                {GST_TAG_COMMENT, music::Engine::Xesam::comment()},
+                {GST_TAG_COMPOSER, music::Engine::Xesam::composer()},
+                {GST_TAG_DATE, music::Engine::Xesam::content_created()},
+                {GST_TAG_ALBUM_VOLUME_NUMBER, music::Engine::Xesam::disc_number()},
+                {GST_TAG_GENRE, music::Engine::Xesam::genre()},
+                {GST_TAG_TITLE, music::Engine::Xesam::title()},
+                {GST_TAG_TRACK_NUMBER, music::Engine::Xesam::track_number()},
+                {GST_TAG_USER_RATING, music::Engine::Xesam::user_rating()}
+            };
+
+            auto md = static_cast<music::Track::MetaData*>(user_data);
+            std::stringstream ss;
+
+            switch(gst_tag_get_type(tag))
+            {
+            case G_TYPE_BOOLEAN:
+            {
+                gboolean value;
+                if (gst_tag_list_get_boolean(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_INT:
+            {
+                gint value;
+                if (gst_tag_list_get_int(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_UINT:
+            {
+                guint value;
+                if (gst_tag_list_get_uint(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_INT64:
+            {
+                gint64 value;
+                if (gst_tag_list_get_int64(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_UINT64:
+            {
+                guint64 value;
+                if (gst_tag_list_get_uint64(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_FLOAT:
+            {
+                gfloat value;
+                if (gst_tag_list_get_float(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_DOUBLE:
+            {
+                double value;
+                if (gst_tag_list_get_double(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_STRING:
+            {
+                gchar* value;
+                if (gst_tag_list_get_string(list, tag, &value))
+                {
+                    ss << value;
+                    g_free(value);
+                }
+                break;
+            }
+            default:
+                break;
+            }
+
+            (*md).set(
+                        (gstreamer_to_mpris_tag_lut.count(tag) > 0 ? gstreamer_to_mpris_tag_lut.at(tag) : tag),
+                        ss.str());
+        },
+        &md);
+
+        track_meta_data.set(std::make_tuple(playbin.uri(), md));
+    }
+
+    void on_volume_changed(const music::Engine::Volume& new_volume)
+    {
+        playbin.set_volume(new_volume.value);
+    }
+
+    Private()
+        : meta_data_extractor(new gstreamer::MetaDataExtractor()),
+          volume(music::Engine::Volume(1.)),
+          about_to_finish_connection(
+              playbin.signals.about_to_finish.connect(
+                  std::bind(
+                      &Private::about_to_finish,
+                      this))),
+          on_state_changed_connection(
+              playbin.signals.on_state_changed.connect(
+                  std::bind(
+                      &Private::on_playbin_state_changed,
+                      this,
+                      std::placeholders::_1))),
+          on_tag_available_connection(
+              playbin.signals.on_tag_available.connect(
+                  std::bind(
+                      &Private::on_tag_available,
+                      this,
+                      std::placeholders::_1))),
+          on_volume_changed_connection(
+              volume.changed().connect(
+                  std::bind(
+                      &Private::on_volume_changed,
+                      this,
+                      std::placeholders::_1)))
+    {
+    }
+
+    std::shared_ptr<Engine::MetaDataExtractor> meta_data_extractor;
+    music::Property<Engine::State> state;
+    music::Property<std::tuple<music::Track::UriType, music::Track::MetaData>> track_meta_data;
+    music::Property<music::Engine::Volume> volume;
+    gstreamer::Playbin playbin;
+    music::ScopedConnection about_to_finish_connection;
+    music::ScopedConnection on_state_changed_connection;
+    music::ScopedConnection on_tag_available_connection;
+    music::ScopedConnection on_volume_changed_connection;
+};
+
+gstreamer::Engine::Engine() : d(new Private{})
+{
+    d->state = music::Engine::State::ready;
+}
+
+gstreamer::Engine::~Engine()
+{
+    stop();
+}
+
+const std::shared_ptr<music::Engine::MetaDataExtractor>& gstreamer::Engine::meta_data_extractor() const
+{
+    return d->meta_data_extractor;
+}
+
+const music::Property<music::Engine::State>& gstreamer::Engine::state() const
+{
+    return d->state;
+}
+
+bool gstreamer::Engine::open_resource_for_uri(const music::Track::UriType& uri)
+{
+    d->playbin.set_uri(uri);
+    return true;
+}
+
+bool gstreamer::Engine::play()
+{
+    auto result = d->playbin.set_state_and_wait(GST_STATE_PLAYING);
+
+    if (result)
+    {
+        d->state = music::Engine::State::playing;
+    }
+
+    return result;
+}
+
+bool gstreamer::Engine::stop()
+{
+    auto result = d->playbin.set_state_and_wait(GST_STATE_NULL);
+
+    if (result)
+        d->state = music::Engine::State::stopped;
+
+    return result;
+}
+
+bool gstreamer::Engine::pause()
+{
+    auto result = d->playbin.set_state_and_wait(GST_STATE_PAUSED);
+
+    if (result)
+        d->state = music::Engine::State::paused;
+
+    return result;
+}
+
+bool gstreamer::Engine::seek_to(const std::chrono::microseconds& ts)
+{
+    return d->playbin.seek(ts);
+}
+
+const com::ubuntu::music::Property<com::ubuntu::music::Engine::Volume>& gstreamer::Engine::volume() const
+{
+    return d->volume;
+}
+
+com::ubuntu::music::Property<com::ubuntu::music::Engine::Volume>& gstreamer::Engine::volume()
+{
+    return d->volume;
+}
+
+const music::Property<std::tuple<music::Track::UriType, music::Track::MetaData>>&
+gstreamer::Engine::track_meta_data() const
+{
+    return d->track_meta_data;
+}

=== added file 'src/com/ubuntu/music/gstreamer/engine.h'
--- src/com/ubuntu/music/gstreamer/engine.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/gstreamer/engine.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_MUSIC_GSTREAMER_ENGINE_H_
+#define COM_UBUNTU_MUSIC_GSTREAMER_ENGINE_H_
+
+#include "../engine.h"
+
+namespace gstreamer
+{
+class Engine : public com::ubuntu::music::Engine
+{
+public:
+    Engine();
+    ~Engine();
+
+    const std::shared_ptr<MetaDataExtractor>& meta_data_extractor() const;
+
+    const com::ubuntu::music::Property<State>& state() const;
+
+    bool open_resource_for_uri(const com::ubuntu::music::Track::UriType& uri);
+
+    bool play();
+    bool stop();
+    bool pause();
+    bool seek_to(const std::chrono::microseconds& ts);
+
+    const com::ubuntu::music::Property<com::ubuntu::music::Engine::Volume>& volume() const;
+    com::ubuntu::music::Property<com::ubuntu::music::Engine::Volume>& volume();
+
+    const com::ubuntu::music::Property<std::tuple<com::ubuntu::music::Track::UriType, com::ubuntu::music::Track::MetaData>>& track_meta_data() const;
+
+private:
+    struct Private;
+    std::unique_ptr<Private> d;
+};
+}
+
+#endif // COM_UBUNTU_MUSIC_GSTREAMER_ENGINE_H_

=== added file 'src/com/ubuntu/music/gstreamer/meta_data_extractor.h'
--- src/com/ubuntu/music/gstreamer/meta_data_extractor.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/gstreamer/meta_data_extractor.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,221 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef GSTREAMER_META_DATA_EXTRACTOR_H_
+#define GSTREAMER_META_DATA_EXTRACTOR_H_
+
+#include "../engine.h"
+
+#include "bus.h"
+
+#include <gst/gst.h>
+
+#include <exception>
+#include <future>
+
+namespace gstreamer
+{
+class MetaDataExtractor : public com::ubuntu::music::Engine::MetaDataExtractor
+{
+public:
+    MetaDataExtractor()
+        : pipe(gst_pipeline_new("meta_data_extractor_pipeline")),
+          decoder(gst_element_factory_make ("uridecodebin", NULL)),
+          bus(GST_ELEMENT_BUS(pipe))
+    {
+        gst_bin_add(GST_BIN(pipe), decoder);
+
+        auto sink = gst_element_factory_make ("fakesink", NULL);
+        gst_bin_add (GST_BIN (pipe), sink);
+
+        g_signal_connect (decoder, "pad-added", G_CALLBACK (on_new_pad), sink);
+    }
+
+    ~MetaDataExtractor()
+    {
+        gst_element_set_state(pipe, GST_STATE_NULL);
+        // gst_object_unref(pipe);
+    }
+
+    com::ubuntu::music::Track::MetaData meta_data_for_track_with_uri(const com::ubuntu::music::Track::UriType& uri)
+    {
+        if (!gst_uri_is_valid(uri.c_str()))
+            throw std::runtime_error("Invalid uri");
+
+        com::ubuntu::music::Track::MetaData meta_data;
+        std::promise<com::ubuntu::music::Track::MetaData> promise;
+        std::future<com::ubuntu::music::Track::MetaData> future{promise.get_future()};
+
+        com::ubuntu::music::ScopedConnection on_new_message_connection
+        {
+            bus.on_new_message.connect(
+                    [&](const gstreamer::Bus::Message& msg)
+                    {
+                        std::cout << __PRETTY_FUNCTION__ << gst_message_type_get_name(msg.type) << std::endl;
+                        if (msg.type == GST_MESSAGE_TAG)
+                        {
+                            MetaDataExtractor::on_tag_available(msg.detail.tag, meta_data);
+                        } else if (msg.type == GST_MESSAGE_ASYNC_DONE)
+                        {
+                            promise.set_value(meta_data);
+                        }
+                    })
+        };
+
+        g_object_set(decoder, "uri", uri.c_str(), NULL);
+        gst_element_set_state(pipe, GST_STATE_PAUSED);
+
+        if (std::future_status::ready != future.wait_for(std::chrono::seconds(2)))
+        {
+            gst_element_set_state(pipe, GST_STATE_NULL);
+            throw std::runtime_error("Problem extracting meta data for track");
+        } else
+        {
+            gst_element_set_state(pipe, GST_STATE_NULL);
+        }
+
+        return future.get();
+    }
+
+private:
+    static void on_new_pad(GstElement*, GstPad* pad, GstElement* fakesink)
+    {
+        GstPad *sinkpad;
+
+        sinkpad = gst_element_get_static_pad (fakesink, "sink");
+
+        if (!gst_pad_is_linked (sinkpad)) {
+            if (gst_pad_link (pad, sinkpad) != GST_PAD_LINK_OK)
+                g_error ("Failed to link pads!");
+        }
+
+        gst_object_unref (sinkpad);
+    }
+
+    static void on_tag_available(
+            const gstreamer::Bus::Message::Detail::Tag& tag,
+            com::ubuntu::music::Track::MetaData& md)
+    {
+        namespace music = com::ubuntu::music;
+
+        gst_tag_list_foreach(
+                    tag.tag_list,
+                    [](const GstTagList *list,
+                    const gchar* tag,
+                    gpointer user_data)
+        {
+            (void) list;
+
+            static const std::map<std::string, std::string> gstreamer_to_mpris_tag_lut =
+            {
+                {GST_TAG_ALBUM, music::Engine::Xesam::album()},
+                {GST_TAG_ALBUM_ARTIST, music::Engine::Xesam::album_artist()},
+                {GST_TAG_ARTIST, music::Engine::Xesam::artist()},
+                {GST_TAG_LYRICS, music::Engine::Xesam::as_text()},
+                {GST_TAG_COMMENT, music::Engine::Xesam::comment()},
+                {GST_TAG_COMPOSER, music::Engine::Xesam::composer()},
+                {GST_TAG_DATE, music::Engine::Xesam::content_created()},
+                {GST_TAG_ALBUM_VOLUME_NUMBER, music::Engine::Xesam::disc_number()},
+                {GST_TAG_GENRE, music::Engine::Xesam::genre()},
+                {GST_TAG_TITLE, music::Engine::Xesam::title()},
+                {GST_TAG_TRACK_NUMBER, music::Engine::Xesam::track_number()},
+                {GST_TAG_USER_RATING, music::Engine::Xesam::user_rating()}
+            };
+
+            auto md = static_cast<music::Track::MetaData*>(user_data);
+            std::stringstream ss;
+
+            switch(gst_tag_get_type(tag))
+            {
+            case G_TYPE_BOOLEAN:
+            {
+                gboolean value;
+                if (gst_tag_list_get_boolean(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_INT:
+            {
+                gint value;
+                if (gst_tag_list_get_int(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_UINT:
+            {
+                guint value;
+                if (gst_tag_list_get_uint(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_INT64:
+            {
+                gint64 value;
+                if (gst_tag_list_get_int64(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_UINT64:
+            {
+                guint64 value;
+                if (gst_tag_list_get_uint64(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_FLOAT:
+            {
+                gfloat value;
+                if (gst_tag_list_get_float(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_DOUBLE:
+            {
+                double value;
+                if (gst_tag_list_get_double(list, tag, &value))
+                    ss << value;
+                break;
+            }
+            case G_TYPE_STRING:
+            {
+                gchar* value;
+                if (gst_tag_list_get_string(list, tag, &value))
+                {
+                    ss << value;
+                    g_free(value);
+                }
+                break;
+            }
+            default:
+                break;
+            }
+
+            (*md).set(
+                        (gstreamer_to_mpris_tag_lut.count(tag) > 0 ? gstreamer_to_mpris_tag_lut.at(tag) : tag),
+                        ss.str());
+        },
+        &md);
+    }
+
+    GstElement* pipe;
+    GstElement* decoder;
+    Bus bus;
+};
+}
+
+#endif // GSTREAMER_META_DATA_EXTRACTOR_H_

=== added file 'src/com/ubuntu/music/gstreamer/playbin.h'
--- src/com/ubuntu/music/gstreamer/playbin.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/gstreamer/playbin.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,219 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef GSTREAMER_PLAYBIN_H_
+#define GSTREAMER_PLAYBIN_H_
+
+#include "bus.h"
+
+#include <gst/gst.h>
+
+#include <chrono>
+#include <string>
+
+namespace gstreamer
+{
+struct Playbin
+{
+    enum PlayFlags
+    {
+        GST_PLAY_FLAG_VIDEO = (1 << 0),
+        GST_PLAY_FLAG_AUDIO = (1 << 1),
+        GST_PLAY_FLAG_TEXT = (1 << 2)
+    };
+
+    static const std::string& pipeline_name()
+    {
+        static const std::string s{"playbin"};
+        return s;
+    }
+
+    static void about_to_finish(GstElement*,
+                                gpointer user_data)
+    {        auto thiz = static_cast<Playbin*>(user_data);
+
+        thiz->signals.about_to_finish();
+    }
+
+    Playbin()
+        : pipeline(gst_element_factory_make("playbin", pipeline_name().c_str())),
+          bus{gst_element_get_bus(pipeline)},
+          on_new_message_connection(
+              bus.on_new_message.connect(
+                  std::bind(
+                      &Playbin::on_new_message,
+                      this,
+                      std::placeholders::_1)))
+    {
+        if (!pipeline)
+            throw std::runtime_error("Could not create pipeline for playbin.");
+
+        setup_pipeline_for_audio();
+
+        g_signal_connect(
+                    pipeline,
+                    "about-to-finish",
+                    G_CALLBACK(about_to_finish),
+                    this
+                    );
+
+    }
+
+    ~Playbin()
+    {
+        if (pipeline)
+            gst_object_unref(pipeline);
+    }
+
+    void on_new_message(const Bus::Message& message)
+    {
+        switch(message.type)
+        {
+        case GST_MESSAGE_ERROR:
+            signals.on_error(message.detail.error_warning_info);
+            break;
+        case GST_MESSAGE_WARNING:
+            signals.on_warning(message.detail.error_warning_info);
+            break;
+        case GST_MESSAGE_INFO:
+            signals.on_info(message.detail.error_warning_info);
+            break;
+        case GST_MESSAGE_TAG:
+            signals.on_tag_available(message.detail.tag);
+            break;
+        case GST_MESSAGE_STATE_CHANGED:
+            signals.on_state_changed(message.detail.state_changed);
+            break;
+        default:
+            break;
+        }
+    }
+
+    gstreamer::Bus& message_bus()
+    {
+        return bus;
+    }
+
+    void setup_pipeline_for_audio()
+    {
+        gint flags;
+        g_object_get(pipeline, "flags", &flags, nullptr);
+        flags |= GST_PLAY_FLAG_AUDIO;
+        flags &= ~GST_PLAY_FLAG_TEXT;
+        flags &= ~GST_PLAY_FLAG_VIDEO;
+        g_object_set (pipeline, "flags", flags, nullptr);
+
+        if (::getenv("COM_UBUNTU_MUSIC_SERVICE_AUDIO_SINK_NAME") != nullptr)
+        {
+            auto audio_sink = gst_element_factory_make (
+                        ::getenv("COM_UBUNTU_MUSIC_SERVICE_AUDIO_SINK_NAME"),
+                        "audio-sink");
+
+            g_object_set(
+                        pipeline,
+                        "audio-sink",
+                        audio_sink,
+                        NULL);
+        }
+    }
+
+    void set_volume(double new_volume)
+    {
+        g_object_set(
+                    pipeline,
+                    "volume",
+                    new_volume,
+                    NULL);
+    }
+
+    void set_uri(const std::string& uri)
+    {
+        g_object_set(
+                    pipeline,
+                    "uri",
+                    uri.c_str(),
+                    NULL);
+    }
+
+    std::string uri() const
+    {
+        gchar* data = nullptr;
+        g_object_get(pipeline, "current-uri", &data, nullptr);
+
+        std::string result((data == nullptr ? "" : data));
+        g_free(data);
+
+        return result;
+    }
+
+    bool set_state_and_wait(GstState new_state)
+    {
+        static const std::chrono::nanoseconds state_change_timeout
+        {
+            // We choose a quite high value here as tests are run under valgrind
+            // and gstreamer pipeline setup/state changes take longer in that scenario.
+            // The value does not negatively impact runtime performance.
+            std::chrono::milliseconds{5000}
+        };
+
+        auto ret = gst_element_set_state(pipeline, new_state);
+        bool result = false; GstState current, pending;
+        switch(ret)
+        {
+        case GST_STATE_CHANGE_FAILURE:
+            result = false; break;
+        case GST_STATE_CHANGE_NO_PREROLL:
+        case GST_STATE_CHANGE_SUCCESS:
+            result = true; break;
+        case GST_STATE_CHANGE_ASYNC:
+            result = GST_STATE_CHANGE_SUCCESS == gst_element_get_state(
+                        pipeline,
+                        &current,
+                        &pending,
+                        state_change_timeout.count());
+            break;
+        }
+
+        return result;
+    }
+
+    bool seek(const std::chrono::nanoseconds& ns)
+    {
+        return gst_element_seek_simple(
+                    pipeline,
+                    GST_FORMAT_TIME,
+                    (GstSeekFlags)(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT),
+                    ns.count());
+    }
+
+    GstElement* pipeline;
+    gstreamer::Bus bus;
+    com::ubuntu::music::Connection on_new_message_connection;
+    struct
+    {
+        com::ubuntu::music::Signal<void> about_to_finish;
+        com::ubuntu::music::Signal<Bus::Message::Detail::ErrorWarningInfo> on_error;
+        com::ubuntu::music::Signal<Bus::Message::Detail::ErrorWarningInfo> on_warning;
+        com::ubuntu::music::Signal<Bus::Message::Detail::ErrorWarningInfo> on_info;
+        com::ubuntu::music::Signal<Bus::Message::Detail::Tag> on_tag_available;
+        com::ubuntu::music::Signal<Bus::Message::Detail::StateChanged> on_state_changed;
+    } signals;
+};
+}
+
+#endif // GSTREAMER_PLAYBIN_H_

=== added directory 'src/com/ubuntu/music/mpris'
=== added file 'src/com/ubuntu/music/mpris/macros.h'
--- src/com/ubuntu/music/mpris/macros.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/mpris/macros.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,79 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef MPRIS_MACROS_H_
+#define MPRIS_MACROS_H_
+
+#include <org/freedesktop/dbus/types/object_path.h>
+
+#include <chrono>
+#include <string>
+
+#define SECONDS(seconds) std::chrono::seconds{seconds};
+
+#define METHOD(Name, Itf, Timeout) \
+    struct Name \
+    { \
+        typedef Itf Interface; \
+        inline static const std::string& name() \
+        { \
+            static const std::string s{#Name}; \
+            return s; \
+        } \
+        inline static const std::chrono::milliseconds default_timeout() { return std::chrono::milliseconds{2000}; } \
+    };\
+
+#define SIGNAL(Name, Itf, ArgType) \
+    struct Name \
+    { \
+        inline static std::string name() \
+        { \
+            return #Name; \
+        }; \
+        typedef Itf Interface; \
+        typedef ArgType ArgumentType; \
+    };\
+
+#define READABLE_PROPERTY(Name, Itf, Type) \
+    struct Name \
+    { \
+        inline static std::string name() \
+        { \
+            return #Name; \
+        }; \
+        typedef Itf Interface; \
+        typedef Type ValueType; \
+        static const bool readable = true; \
+        static const bool writable = false; \
+    }; \
+
+#define WRITABLE_PROPERTY(Name, Itf, Type) \
+    struct Name \
+    { \
+        inline static std::string name() \
+        { \
+            return #Name; \
+        }; \
+        typedef Itf Interface; \
+        typedef Type ValueType; \
+        static const bool readable = true; \
+        static const bool writable = true; \
+    }; \
+
+#endif // MPRIS_MACROS_H_
+

=== added file 'src/com/ubuntu/music/mpris/player.h'
--- src/com/ubuntu/music/mpris/player.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/mpris/player.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef MPRIS_PLAYER_H_
+#define MPRIS_PLAYER_H_
+
+#include <com/ubuntu/music/track.h>
+
+#include "macros.h"
+
+#include <org/freedesktop/dbus/types/any.h>
+#include <org/freedesktop/dbus/types/object_path.h>
+#include <org/freedesktop/dbus/types/variant.h>
+
+#include <boost/utility/identity_type.hpp>
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace dbus = org::freedesktop::dbus;
+
+namespace mpris
+{
+struct Player
+{
+    static const std::string& name()
+    {
+        static const std::string s{"com.ubuntu.music.Service.Player"};
+        return s;
+    }
+
+    METHOD(Next, Player, std::chrono::seconds(1))
+    METHOD(Previous, Player, std::chrono::seconds(1))
+    METHOD(Pause, Player, std::chrono::seconds(1))
+    METHOD(PlayPause, Player, std::chrono::seconds(1))
+    METHOD(Stop, Player, std::chrono::seconds(1))
+    METHOD(Play, Player, std::chrono::seconds(1))
+    METHOD(Seek, Player, std::chrono::seconds(1))
+    METHOD(SetPosition, Player, std::chrono::seconds(1))
+    METHOD(OpenUri, Player, std::chrono::seconds(1))
+
+    struct Signals
+    {
+        SIGNAL(Seeked, Player, uint64_t)
+    };
+
+    struct Properties
+    {
+        READABLE_PROPERTY(PlaybackStatus, Player, std::string)
+        WRITABLE_PROPERTY(LoopStatus, Player, std::string)
+        WRITABLE_PROPERTY(PlaybackRate, Player, double)
+        WRITABLE_PROPERTY(Rate, Player, double)
+        WRITABLE_PROPERTY(Shuffle, Player, bool)
+        READABLE_PROPERTY(MetaData, Player, BOOST_IDENTITY_TYPE((std::map<std::string, std::string>)))
+        WRITABLE_PROPERTY(Volume, Player, double)
+        READABLE_PROPERTY(Position, Player, uint64_t)
+        READABLE_PROPERTY(MinimumRate, Player, double)
+        READABLE_PROPERTY(MaximumRate, Player, double)
+        READABLE_PROPERTY(CanGoNext, Player, bool)
+        READABLE_PROPERTY(CanGoPrevious, Player, bool)
+        READABLE_PROPERTY(CanPlay, Player, bool)
+        READABLE_PROPERTY(CanPause, Player, bool)
+        READABLE_PROPERTY(CanSeek, Player, bool)
+        READABLE_PROPERTY(CanControl, Player, bool)
+    };
+};
+}
+
+#endif // MPRIS_PLAYER_H_

=== added file 'src/com/ubuntu/music/mpris/service.h'
--- src/com/ubuntu/music/mpris/service.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/mpris/service.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef MPRIS_SERVICE_H_
+#define MPRIS_SERVICE_H_
+
+#include "macros.h"
+
+#include <chrono>
+#include <string>
+
+namespace mpris
+{
+struct Service
+{
+    static const std::string& name()
+    {
+        static const std::string s{"com.ubuntu.music.Service"};
+        return s;
+    }
+
+    struct Errors
+    {
+        struct CreatingSession
+        {
+            static const std::string& name()
+            {
+                static const std::string s
+                {
+                    "com.ubuntu.music.Service.Error.CreatingSession"
+                };
+                return s;
+            }
+        };
+    };
+
+    METHOD(CreateSession, Service, std::chrono::seconds(1))
+};
+}
+
+#endif // MPRIS_SERVICE_H_

=== added file 'src/com/ubuntu/music/mpris/track_list.h'
--- src/com/ubuntu/music/mpris/track_list.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/mpris/track_list.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef MPRIS_TRACK_LIST_H_
+#define MPRIS_TRACK_LIST_H_
+
+#include "macros.h"
+
+#include <org/freedesktop/dbus/types/any.h>
+#include <org/freedesktop/dbus/types/object_path.h>
+#include <org/freedesktop/dbus/types/variant.h>
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace dbus = org::freedesktop::dbus;
+
+namespace mpris
+{
+struct TrackList
+{
+    static const std::string& name()
+    {
+        static const std::string s{"com.ubuntu.music.Service.Player.TrackList"};
+        return s;
+    }
+
+    METHOD(GetTracksMetadata, TrackList, SECONDS(1))
+    METHOD(AddTrack, TrackList, SECONDS(1))
+    METHOD(RemoveTrack, TrackList, SECONDS(1))
+    METHOD(GoTo, TrackList, SECONDS(1))
+
+    struct Signals
+    {
+        SIGNAL
+        (
+            TrackListReplaced,
+            TrackList,
+            BOOST_IDENTITY_TYPE((std::tuple<std::vector<dbus::types::ObjectPath>, dbus::types::ObjectPath>))
+        )
+
+        SIGNAL
+        (
+            TrackAdded,
+            TrackList,
+            BOOST_IDENTITY_TYPE((std::tuple<std::map<std::string, dbus::types::Variant<dbus::types::Any>>, dbus::types::ObjectPath>))
+        )
+
+        SIGNAL
+        (
+            TrackRemoved,
+            TrackList,
+            dbus::types::ObjectPath
+        )
+
+        SIGNAL
+        (
+            TrackMetadataChanged,
+            TrackList,
+            BOOST_IDENTITY_TYPE((std::tuple<std::map<std::string, dbus::types::Variant<dbus::types::Any>>, dbus::types::ObjectPath>))
+        )
+    };
+
+    struct Properties
+    {
+        READABLE_PROPERTY(Tracks, TrackList, std::vector<std::string>)
+        READABLE_PROPERTY(CanEditTracks, TrackList, bool)
+    };
+};
+}
+
+#endif // MPRIS_TRACK_LIST_H_

=== added file 'src/com/ubuntu/music/player.cpp'
--- src/com/ubuntu/music/player.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/music/player.h>
+#include <com/ubuntu/music/property.h>
+
+#include "player_configuration.h"
+
+namespace music = com::ubuntu::music;
+
+const music::Player::Configuration& music::Player::Client::default_configuration()
+{
+    static const music::Player::Configuration config;
+    return config;
+}
+
+music::Player::Player()
+{
+}
+
+music::Player::~Player()
+{
+}
+

=== removed file 'src/com/ubuntu/music/player.cpp'
--- src/com/ubuntu/music/player.cpp	2013-09-08 11:42:36 +0000
+++ src/com/ubuntu/music/player.cpp	1970-01-01 00:00:00 +0000
@@ -1,192 +0,0 @@
-/*
- * Copyright © 2013 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: Thomas Voß <[e-mail]>
- */
-
-#include "com/ubuntu/music/player.h"
-#include "com/ubuntu/music/service.h"
-#include "com/ubuntu/music/track_list.h"
-
-#include <limits>
-
-namespace music = com::ubuntu::music;
-
-struct music::Player::Private
-{
-    std::shared_ptr<Service> parent;
-    std::shared_ptr<TrackList> track_list;
-};
-
-music::Player::Player(const std::shared_ptr<Service>& parent) : d(new Private{parent, std::make_shared<TrackList>()})
-{
-}
-
-music::Player::~Player()
-{
-}
-
-const std::shared_ptr<music::TrackList>& music::Player::track_list() const
-{
-    return d->track_list;
-}
-
-bool music::Player::can_go_next()
-{
-    return true;
-}
-
-void music::Player::next()
-{    
-}
-
-bool music::Player::can_go_previous()
-{
-    return true;
-}
-
-void music::Player::previous()
-{
-}
-
-bool music::Player::can_play()
-{
-    return true;
-}
-
-void music::Player::play()
-{
-}
-
-bool music::Player::can_pause()
-{
-    return true;
-}
-
-void music::Player::pause()
-{
-}
-
-bool music::Player::can_seek()
-{
-    return true;
-}
-
-void music::Player::seek_to(const std::chrono::microseconds& offset)
-{
-    (void) offset;
-}
-
-void music::Player::stop()
-{
-}
-
-music::Player::PlaybackStatus music::Player::playback_status() const
-{
-    return Player::stopped;
-}
-
-music::Connection music::Player::on_playback_status_changed(const std::function<void(music::Player::PlaybackStatus)>& handler)
-{
-    (void) handler;
-    return Connection(nullptr);
-}
-
-music::Player::LoopStatus music::Player::loop_status() const
-{
-    return Player::none;
-}
-
-void music::Player::set_loop_status(music::Player::LoopStatus new_status)
-{
-    (void) new_status;
-}
-
-music::Connection music::Player::on_loop_status_changed(const std::function<void(music::Player::LoopStatus)>& handler)
-{
-    (void) handler;
-    return Connection(nullptr);
-}
-
-music::Player::PlaybackRate music::Player::playback_rate() const
-{
-    return 1.0;
-}
-
-void music::Player::set_playback_rate(music::Player::PlaybackRate rate)
-{
-    (void) rate;
-}
-
-music::Connection music::Player::on_playback_rate_changed(const std::function<void(music::Player::PlaybackRate)>& handler)
-{
-    (void) handler;
-
-    return Connection(nullptr);
-}
-
-bool music::Player::is_shuffle() const
-{
-    return false;
-}
-
-void music::Player::set_shuffle(bool b)
-{
-    (void) b;
-}
-
-music::Connection music::Player::on_shuffle_changed(const std::function<void(bool)>& handler)
-{
-    (void) handler;
-    return Connection(nullptr);
-}
-
-music::Track::MetaData music::Player::meta_data_for_current_track() const
-{
-    return Track::MetaData();
-}
-
-music::Connection music::Player::on_meta_data_for_current_track_changed(const std::function<void(const music::Track::MetaData&)>& handler)
-{
-    (void) handler;
-    return Connection(nullptr);
-}
-
-music::Player::Volume music::Player::volume() const
-{
-    return 0.f;
-}
-
-void music::Player::set_volume(music::Player::Volume new_volume)
-{
-    (void) new_volume;
-}
-
-music::Connection music::Player::on_volume_changed(const std::function<void(music::Player::Volume)>& handler) 
-{
-    (void) handler;
-    return Connection(nullptr);
-}
-
-music::Player::PlaybackRate music::Player::minimum_playback_rate() const
-{    
-    return std::numeric_limits<double>::min();
-}
-
-music::Player::PlaybackRate music::Player::maximum_playback_rate() const
-{
-    return std::numeric_limits<double>::max();
-}
-

=== added file 'src/com/ubuntu/music/player_configuration.h'
--- src/com/ubuntu/music/player_configuration.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_configuration.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_MUSIC_PLAYER_CLIENT_CONFIGURATION_H_
+#define COM_UBUNTU_MUSIC_PLAYER_CLIENT_CONFIGURATION_H_
+
+#include <com/ubuntu/music/player.h>
+
+#include <org/freedesktop/dbus/types/object_path.h>
+
+struct com::ubuntu::music::Player::Configuration
+{
+    org::freedesktop::dbus::types::ObjectPath object_path;
+};
+
+#endif // COM_UBUNTU_MUSIC_PLAYER_CLIENT_CONFIGURATION_H_

=== added file 'src/com/ubuntu/music/player_implementation.cpp'
--- src/com/ubuntu/music/player_implementation.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_implementation.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,133 @@
+/*
+ *
+ * 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: Thomas Voß <[e-mail]>
+ */
+
+#include "player_implementation.h"
+
+#include "engine.h"
+#include "track_list_implementation.h"
+
+#include <com/ubuntu/music/property.h>
+
+namespace music = com::ubuntu::music;
+
+struct music::PlayerImplementation::Private
+{
+    Private(PlayerImplementation* parent,
+            const dbus::types::ObjectPath& session_path,
+            const std::shared_ptr<music::Service>& service,
+            const std::shared_ptr<music::Engine>& engine)
+        : parent(parent),
+          service(service),
+          engine(engine),
+          session_path(session_path),
+          track_list(
+              new music::TrackListImplementation(
+                  session_path.as_string() + "/TrackList",
+                  engine->meta_data_extractor()))
+    {
+        engine->state().changed().connect(
+                    [parent](const Engine::State& state)
+                    {
+            switch(state)
+            {
+            case Engine::State::ready: parent->playback_status().set(music::Player::ready); break;
+            case Engine::State::playing: parent->playback_status().set(music::Player::playing); break;
+            case Engine::State::stopped: parent->playback_status().set(music::Player::stopped); break;
+            case Engine::State::paused: parent->playback_status().set(music::Player::paused); break;
+            default:
+                break;
+            };
+                    });
+    }
+
+    PlayerImplementation* parent;
+    std::shared_ptr<Service> service;
+    std::shared_ptr<Engine> engine;
+    dbus::types::ObjectPath session_path;
+    std::shared_ptr<TrackListImplementation> track_list;
+};
+
+music::PlayerImplementation::PlayerImplementation(
+        const dbus::types::ObjectPath& session_path,
+        const std::shared_ptr<Service>& service,
+        const std::shared_ptr<Engine>& engine)
+    : music::PlayerSkeleton(session_path),
+      d(new Private(
+            this,
+            session_path,
+            service,
+            engine))
+{
+    // Initializing default values for properties
+    can_play().set(true);
+    can_pause().set(true);
+    can_seek().set(true);
+    can_go_previous().set(true);
+    can_go_next().set(true);
+    is_shuffle().set(true);
+    playback_rate().set(1.f);
+    playback_status().set(Player::PlaybackStatus::null);
+    loop_status().set(Player::LoopStatus::none);
+}
+
+music::PlayerImplementation::~PlayerImplementation()
+{
+}
+
+std::shared_ptr<music::TrackList> music::PlayerImplementation::track_list()
+{
+    return d->track_list;
+}
+
+bool music::PlayerImplementation::open_uri(const Track::UriType& uri)
+{
+    std::cout << __PRETTY_FUNCTION__ << ": " << uri << std::endl;
+    return d->engine->open_resource_for_uri(uri);
+}
+
+void music::PlayerImplementation::next()
+{
+}
+
+void music::PlayerImplementation::previous()
+{
+}
+
+void music::PlayerImplementation::play()
+{
+    /*if (playback_status() == music::Player::null)
+    {
+        if (d->track_list->has_next())
+            if (open_uri(d->track_list->next()->))
+    }*/
+    d->engine->play();
+}
+
+void music::PlayerImplementation::pause()
+{
+    d->engine->pause();
+}
+
+void music::PlayerImplementation::stop()
+{
+    d->engine->stop();
+}
+
+void music::PlayerImplementation::seek_to(const std::chrono::microseconds& ms)
+{
+    d->engine->seek_to(ms);
+}

=== added file 'src/com/ubuntu/music/player_implementation.h'
--- src/com/ubuntu/music/player_implementation.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_implementation.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,61 @@
+/*
+ *
+ * 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_PLAYER_IMPLEMENTATION_H_
+#define COM_UBUNTU_MUSIC_PLAYER_IMPLEMENTATION_H_
+
+#include "player_skeleton.h"
+
+#include <memory>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class Engine;
+class Service;
+
+class PlayerImplementation : public PlayerSkeleton
+{
+public:
+    PlayerImplementation(
+            const org::freedesktop::dbus::types::ObjectPath& session_path,
+            const std::shared_ptr<Service>& service,
+            const std::shared_ptr<Engine>& engine);
+    ~PlayerImplementation();
+
+    virtual std::shared_ptr<TrackList> track_list();
+
+    virtual bool open_uri(const Track::UriType& uri);
+    virtual void next();
+    virtual void previous();
+    virtual void play();
+    virtual void pause();
+    virtual void stop();
+    virtual void seek_to(const std::chrono::microseconds& offset);
+
+private:
+    struct Private;
+    std::unique_ptr<Private> d;
+};
+}
+}
+}
+#endif // COM_UBUNTU_MUSIC_PLAYER_IMPLEMENTATION_H_
+

=== added file 'src/com/ubuntu/music/player_skeleton.cpp'
--- src/com/ubuntu/music/player_skeleton.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_skeleton.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,325 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/music/property.h>
+
+#include "player_skeleton.h"
+#include "player_traits.h"
+#include "property_stub.h"
+#include "the_session_bus.h"
+
+#include "mpris/player.h"
+
+#include <org/freedesktop/dbus/stub.h>
+
+namespace dbus = org::freedesktop::dbus;
+namespace music = com::ubuntu::music;
+
+struct music::PlayerSkeleton::Private
+{
+    Private(music::PlayerSkeleton* player, const dbus::types::ObjectPath& session)
+        : impl(player),
+          object(impl->access_service()->add_object_for_path(session)),
+          properties
+          {
+              object->get_property<mpris::Player::Properties::CanPlay>(),
+              object->get_property<mpris::Player::Properties::CanPause>(),
+              object->get_property<mpris::Player::Properties::CanSeek>(),
+              object->get_property<mpris::Player::Properties::CanControl>(),
+              object->get_property<mpris::Player::Properties::CanGoNext>(),
+              object->get_property<mpris::Player::Properties::CanGoPrevious>(),
+              object->get_property<mpris::Player::Properties::PlaybackStatus>(),
+              object->get_property<mpris::Player::Properties::LoopStatus>(),
+              object->get_property<mpris::Player::Properties::PlaybackRate>(),
+              object->get_property<mpris::Player::Properties::Shuffle>(),
+              object->get_property<mpris::Player::Properties::MetaData>(),
+              object->get_property<mpris::Player::Properties::Volume>(),
+              object->get_property<mpris::Player::Properties::MinimumRate>(),
+              object->get_property<mpris::Player::Properties::MaximumRate>()
+          }
+    {
+    }
+
+    void handle_next(DBusMessage* msg)
+    {
+        impl->next();
+        auto reply = dbus::Message::make_method_return(msg);
+        impl->access_bus()->send(reply->get());
+    }
+
+    void handle_previous(DBusMessage* msg)
+    {
+        impl->previous();
+        auto reply = dbus::Message::make_method_return(msg);
+        impl->access_bus()->send(reply->get());
+    }
+
+    void handle_pause(DBusMessage* msg)
+    {
+        impl->pause();
+        auto reply = dbus::Message::make_method_return(msg);
+        impl->access_bus()->send(reply->get());
+    }
+
+    void handle_playpause(DBusMessage*)
+    {
+    }
+
+    void handle_stop(DBusMessage* msg)
+    {
+        impl->stop();
+        auto reply = dbus::Message::make_method_return(msg);
+        impl->access_bus()->send(reply->get());
+    }
+
+    void handle_play(DBusMessage* msg)
+    {
+        impl->play();
+        auto reply = dbus::Message::make_method_return(msg);
+        impl->access_bus()->send(reply->get());
+    }
+
+    void handle_seek(DBusMessage* msg)
+    {
+        auto in = dbus::Message::from_raw_message(msg);
+        uint64_t ticks;
+        in->reader() >> ticks; 
+        impl->seek_to(std::chrono::microseconds(ticks));
+    }
+
+    void handle_set_position(DBusMessage*)
+    {
+    }
+
+    void handle_open_uri(DBusMessage* msg)
+    {
+        auto in = dbus::Message::from_raw_message(msg);
+        Track::UriType uri;
+        in->reader() >> uri;
+
+        auto reply = dbus::Message::make_method_return(msg);
+        reply->writer() << impl->open_uri(uri);
+        impl->access_bus()->send(reply->get());
+    }
+
+    music::PlayerSkeleton* impl;
+    dbus::Object::Ptr object;
+    struct
+    {
+        PropertyStub<bool, mpris::Player::Properties::CanPlay> can_play;
+        PropertyStub<bool, mpris::Player::Properties::CanPause> can_pause;
+        PropertyStub<bool, mpris::Player::Properties::CanSeek> can_seek;
+        PropertyStub<bool, mpris::Player::Properties::CanControl> can_control;
+        PropertyStub<bool, mpris::Player::Properties::CanGoNext> can_go_next;
+        PropertyStub<bool, mpris::Player::Properties::CanGoPrevious> can_go_previous;
+        
+        PropertyStub<Player::PlaybackStatus, mpris::Player::Properties::PlaybackStatus> playback_status;
+        PropertyStub<Player::LoopStatus, mpris::Player::Properties::LoopStatus> loop_status;
+        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::PlaybackRate> playback_rate;
+        PropertyStub<bool, mpris::Player::Properties::Shuffle> is_shuffle;
+        PropertyStub<Track::MetaData, mpris::Player::Properties::MetaData> meta_data_for_current_track;
+        PropertyStub<Player::Volume, mpris::Player::Properties::Volume> volume;
+        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MinimumRate> minimum_playback_rate;
+        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MaximumRate> maximum_playback_rate;        
+    } properties;
+
+    /*struct
+    {
+        std::shared_ptr<dbus::Signal<mpris::Player::Signals::Seeked, uint64_t>> seeked;
+        } signals;*/
+
+};
+
+music::PlayerSkeleton::PlayerSkeleton(
+    const org::freedesktop::dbus::types::ObjectPath& session_path)
+        : dbus::Skeleton<music::Player>(the_session_bus()),
+          d(new Private{this, session_path})
+{
+    d->object->install_method_handler<mpris::Player::Next>(
+        std::bind(&Private::handle_next,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::Previous>(
+        std::bind(&Private::handle_previous,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::Pause>(
+        std::bind(&Private::handle_pause,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::Stop>(
+        std::bind(&Private::handle_stop,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::Play>(
+        std::bind(&Private::handle_play,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::Seek>(
+        std::bind(&Private::handle_seek,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::SetPosition>(
+        std::bind(&Private::handle_set_position,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::OpenUri>(
+        std::bind(&Private::handle_open_uri,
+                  std::ref(d),
+                  std::placeholders::_1));
+}
+
+music::PlayerSkeleton::~PlayerSkeleton()
+{
+}
+
+const music::Property<bool>& music::PlayerSkeleton::can_play() const 
+{
+    return d->properties.can_play;
+}
+
+const music::Property<bool>& music::PlayerSkeleton::can_pause() const
+{
+    return d->properties.can_pause;
+}
+
+const music::Property<bool>& music::PlayerSkeleton::can_seek() const
+{
+    return d->properties.can_seek;
+}
+
+const music::Property<bool>& music::PlayerSkeleton::can_go_previous() const
+{
+    return d->properties.can_go_previous;
+}
+
+const music::Property<bool>& music::PlayerSkeleton::can_go_next() const
+{
+    return d->properties.can_go_next;
+}
+
+const music::Property<music::Player::PlaybackStatus>& music::PlayerSkeleton::playback_status() const
+{
+    return d->properties.playback_status;
+}
+
+const music::Property<music::Player::LoopStatus>& music::PlayerSkeleton::loop_status() const
+{
+    return d->properties.loop_status;
+}
+
+const music::Property<music::Player::PlaybackRate>& music::PlayerSkeleton::playback_rate() const
+{
+    return d->properties.playback_rate;
+}
+
+const music::Property<bool>& music::PlayerSkeleton::is_shuffle() const
+{
+    return d->properties.is_shuffle;
+}
+
+const music::Property<music::Track::MetaData>& music::PlayerSkeleton::meta_data_for_current_track() const
+{
+    return d->properties.meta_data_for_current_track;
+}
+
+const music::Property<music::Player::Volume>& music::PlayerSkeleton::volume() const
+{
+    return d->properties.volume;
+}
+
+const music::Property<music::Player::PlaybackRate>& music::PlayerSkeleton::minimum_playback_rate() const
+{
+    return d->properties.minimum_playback_rate;
+}
+
+const music::Property<music::Player::PlaybackRate>& music::PlayerSkeleton::maximum_playback_rate() const
+{
+    return d->properties.maximum_playback_rate;
+}
+
+music::Property<music::Player::LoopStatus>& music::PlayerSkeleton::loop_status()
+{
+    return d->properties.loop_status;
+}
+
+music::Property<music::Player::PlaybackRate>& music::PlayerSkeleton::playback_rate()
+{
+    return d->properties.playback_rate;
+}
+
+music::Property<bool>& music::PlayerSkeleton::is_shuffle()
+{
+    return d->properties.is_shuffle;
+}
+
+music::Property<music::Player::Volume>& music::PlayerSkeleton::volume()
+{
+    return d->properties.volume;
+}
+
+music::Property<music::Player::PlaybackStatus>& music::PlayerSkeleton::playback_status()
+{
+    return d->properties.playback_status;
+}
+
+music::Property<bool>& music::PlayerSkeleton::can_play()
+{
+    return d->properties.can_play;
+}
+
+music::Property<bool>& music::PlayerSkeleton::can_pause()
+{
+    return d->properties.can_pause;
+}
+
+music::Property<bool>& music::PlayerSkeleton::can_seek()
+{
+    return d->properties.can_seek;
+}
+
+music::Property<bool>& music::PlayerSkeleton::can_go_previous()
+{
+    return d->properties.can_go_previous;
+}
+
+music::Property<bool>& music::PlayerSkeleton::can_go_next()
+{
+    return d->properties.can_go_next;
+}
+
+music::Property<music::Track::MetaData>& music::PlayerSkeleton::meta_data_for_current_track()
+{
+    return d->properties.meta_data_for_current_track;
+}
+
+music::Property<music::Player::PlaybackRate>& music::PlayerSkeleton::minimum_playback_rate()
+{
+    return d->properties.minimum_playback_rate;
+}
+
+music::Property<music::Player::PlaybackRate>& music::PlayerSkeleton::maximum_playback_rate()
+{
+    return d->properties.maximum_playback_rate;
+}
+
+const music::Signal<uint64_t>& music::PlayerSkeleton::seeked_to() const
+{
+    static const music::Signal<uint64_t> signal;
+    return signal;
+}

=== added file 'src/com/ubuntu/music/player_skeleton.h'
--- src/com/ubuntu/music/player_skeleton.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_skeleton.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,86 @@
+/**
+ * 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_PLAYER_SKELETON_H_
+#define COM_UBUNTU_MUSIC_PLAYER_SKELETON_H_
+
+#include <com/ubuntu/music/player.h>
+
+#include "player_traits.h"
+
+#include "mpris/player.h"
+
+#include <org/freedesktop/dbus/skeleton.h>
+#include <org/freedesktop/dbus/types/object_path.h>
+
+#include <memory>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class Service;
+
+class PlayerSkeleton : public org::freedesktop::dbus::Skeleton<com::ubuntu::music::Player>
+{
+  public:
+    ~PlayerSkeleton();
+
+    virtual const Property<bool>& can_play() const;
+    virtual const Property<bool>& can_pause() const;
+    virtual const Property<bool>& can_seek() const;
+    virtual const Property<bool>& can_go_previous() const;
+    virtual const Property<bool>& can_go_next() const;
+    virtual const Property<PlaybackStatus>& playback_status() const;    
+    virtual const Property<LoopStatus>& loop_status() const;
+    virtual const Property<PlaybackRate>& playback_rate() const;
+    virtual const Property<bool>& is_shuffle() const;
+    virtual const Property<Track::MetaData>& meta_data_for_current_track() const;
+    virtual const Property<Volume>& volume() const;
+    virtual const Property<PlaybackRate>& minimum_playback_rate() const;
+    virtual const Property<PlaybackRate>& maximum_playback_rate() const;
+        
+    virtual Property<LoopStatus>& loop_status();
+    virtual Property<PlaybackRate>& playback_rate();
+    virtual Property<bool>& is_shuffle();
+    virtual Property<Volume>& volume();
+    
+    virtual const Signal<uint64_t>& seeked_to() const;
+
+  protected:
+    PlayerSkeleton(const org::freedesktop::dbus::types::ObjectPath& session_path);
+
+    virtual Property<PlaybackStatus>& playback_status();
+    virtual Property<bool>& can_play();
+    virtual Property<bool>& can_pause();
+    virtual Property<bool>& can_seek();
+    virtual Property<bool>& can_go_previous();
+    virtual Property<bool>& can_go_next();
+    virtual Property<Track::MetaData>& meta_data_for_current_track();
+    virtual Property<PlaybackRate>& minimum_playback_rate();
+    virtual Property<PlaybackRate>& maximum_playback_rate();
+
+  private:
+    struct Private;
+    std::unique_ptr<Private> d;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_PLAYER_SKELETON_H_

=== added file 'src/com/ubuntu/music/player_stub.cpp'
--- src/com/ubuntu/music/player_stub.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_stub.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,260 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/music/property.h>
+#include <com/ubuntu/music/service.h>
+#include <com/ubuntu/music/track_list.h>
+
+#include "player_stub.h"
+#include "player_traits.h"
+#include "property_stub.h"
+#include "the_session_bus.h"
+#include "track_list_stub.h"
+
+#include "mpris/player.h"
+
+#include <org/freedesktop/dbus/types/object_path.h>
+
+#include <limits>
+
+namespace dbus = org::freedesktop::dbus;
+namespace music = com::ubuntu::music;
+
+struct music::PlayerStub::Private
+{
+    Private(const std::shared_ptr<Service>& parent,
+            const std::shared_ptr<dbus::Service>& remote,
+            const dbus::types::ObjectPath& path
+            ) : parent(parent),
+                path(path),
+                object(remote->object_for_path(path)),                
+                properties
+                {
+                    object->get_property<mpris::Player::Properties::CanPlay>(),
+                    object->get_property<mpris::Player::Properties::CanPause>(),
+                    object->get_property<mpris::Player::Properties::CanSeek>(),
+                    object->get_property<mpris::Player::Properties::CanControl>(),
+                    object->get_property<mpris::Player::Properties::CanGoNext>(),
+                    object->get_property<mpris::Player::Properties::CanGoPrevious>(),
+                    object->get_property<mpris::Player::Properties::PlaybackStatus>(),
+                    object->get_property<mpris::Player::Properties::LoopStatus>(),
+                    object->get_property<mpris::Player::Properties::PlaybackRate>(),
+                    object->get_property<mpris::Player::Properties::Shuffle>(),
+                    object->get_property<mpris::Player::Properties::MetaData>(),
+                    object->get_property<mpris::Player::Properties::Volume>(),
+                    object->get_property<mpris::Player::Properties::MinimumRate>(),
+                    object->get_property<mpris::Player::Properties::MaximumRate>()
+                }
+    {
+    }
+
+    std::shared_ptr<Service> parent;
+    std::shared_ptr<TrackList> track_list;
+
+    dbus::Bus::Ptr bus;
+    dbus::types::ObjectPath path;
+    dbus::Object::Ptr object;
+    
+    struct
+    {
+        PropertyStub<bool, mpris::Player::Properties::CanPlay> can_play;
+        PropertyStub<bool, mpris::Player::Properties::CanPause> can_pause;
+        PropertyStub<bool, mpris::Player::Properties::CanSeek> can_seek;
+        PropertyStub<bool, mpris::Player::Properties::CanControl> can_control;
+        PropertyStub<bool, mpris::Player::Properties::CanGoNext> can_go_next;
+        PropertyStub<bool, mpris::Player::Properties::CanGoPrevious> can_go_previous;
+        
+        PropertyStub<Player::PlaybackStatus, mpris::Player::Properties::PlaybackStatus> playback_status;
+        PropertyStub<Player::LoopStatus, mpris::Player::Properties::LoopStatus> loop_status;
+        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::PlaybackRate> playback_rate;
+        PropertyStub<bool, mpris::Player::Properties::Shuffle> is_shuffle;
+        PropertyStub<Track::MetaData, mpris::Player::Properties::MetaData> meta_data_for_current_track;
+        PropertyStub<Player::Volume, mpris::Player::Properties::Volume> volume;
+        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MinimumRate> minimum_playback_rate;
+        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MaximumRate> maximum_playback_rate;
+    } properties;
+};
+
+music::PlayerStub::PlayerStub(
+    const std::shared_ptr<Service>& parent,
+    const dbus::types::ObjectPath& object_path)
+        : dbus::Stub<Player>(the_session_bus()),
+          d(new Private{parent, access_service(), object_path})
+{
+}
+
+music::PlayerStub::~PlayerStub()
+{
+}
+
+std::shared_ptr<music::TrackList> music::PlayerStub::track_list()
+{
+    if (!d->track_list)
+    {
+        d->track_list = std::make_shared<music::TrackListStub>(
+                    shared_from_this(),
+                    dbus::types::ObjectPath(d->path.as_string() + "/TrackList"));
+    }
+    return d->track_list;
+}
+
+bool music::PlayerStub::open_uri(const music::Track::UriType& uri)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::OpenUri, music::Track::UriType>(uri);
+
+    return op.is_error();
+}
+
+void music::PlayerStub::next()
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Next, void>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem switching to next track on remote object");
+}
+
+void music::PlayerStub::previous()
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Previous, void>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem switching to previous track on remote object");
+}
+
+void music::PlayerStub::play()
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Play, void>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem starting playback on remote object");
+}
+
+void music::PlayerStub::pause()
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Pause, void>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem pausing playback on remote object");
+}
+
+void music::PlayerStub::seek_to(const std::chrono::microseconds& offset)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Seek, void, uint64_t>(offset.count());
+
+    if (op.is_error())
+        throw std::runtime_error("Problem seeking on remote object");
+}
+
+void music::PlayerStub::stop()
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Stop, void>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem stopping playback on remote object");
+}
+
+const music::Property<bool>& music::PlayerStub::can_play() const 
+{
+    return d->properties.can_play;
+}
+
+const music::Property<bool>& music::PlayerStub::can_pause() const
+{
+    return d->properties.can_pause;
+}
+
+const music::Property<bool>& music::PlayerStub::can_seek() const
+{
+    return d->properties.can_seek;
+}
+
+const music::Property<bool>& music::PlayerStub::can_go_previous() const
+{
+    return d->properties.can_go_previous;
+}
+
+const music::Property<bool>& music::PlayerStub::can_go_next() const
+{
+    return d->properties.can_go_next;
+}
+
+const music::Property<music::Player::PlaybackStatus>& music::PlayerStub::playback_status() const
+{
+    return d->properties.playback_status;
+}
+
+const music::Property<music::Player::LoopStatus>& music::PlayerStub::loop_status() const
+{
+    return d->properties.loop_status;
+}
+
+const music::Property<music::Player::PlaybackRate>& music::PlayerStub::playback_rate() const
+{
+    return d->properties.playback_rate;
+}
+
+const music::Property<bool>& music::PlayerStub::is_shuffle() const
+{
+    return d->properties.is_shuffle;
+}
+
+const music::Property<music::Track::MetaData>& music::PlayerStub::meta_data_for_current_track() const
+{
+    return d->properties.meta_data_for_current_track;
+}
+
+const music::Property<music::Player::Volume>& music::PlayerStub::volume() const
+{
+    return d->properties.volume;
+}
+
+const music::Property<music::Player::PlaybackRate>& music::PlayerStub::minimum_playback_rate() const
+{
+    return d->properties.minimum_playback_rate;
+}
+
+const music::Property<music::Player::PlaybackRate>& music::PlayerStub::maximum_playback_rate() const
+{
+    return d->properties.maximum_playback_rate;
+}
+
+music::Property<music::Player::LoopStatus>& music::PlayerStub::loop_status()
+{
+    return d->properties.loop_status;
+}
+
+music::Property<music::Player::PlaybackRate>& music::PlayerStub::playback_rate()
+{
+    return d->properties.playback_rate;
+}
+
+music::Property<bool>& music::PlayerStub::is_shuffle()
+{
+    return d->properties.is_shuffle;
+}
+
+music::Property<music::Player::Volume>& music::PlayerStub::volume()
+{
+    return d->properties.volume;
+}
+
+const music::Signal<uint64_t>& music::PlayerStub::seeked_to() const
+{
+    static music::Signal<uint64_t> signal;
+    return signal;
+}

=== added file 'src/com/ubuntu/music/player_stub.h'
--- src/com/ubuntu/music/player_stub.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_stub.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_PLAYER_STUB_H_
+#define COM_UBUNTU_MUSIC_PLAYER_STUB_H_
+
+#include <com/ubuntu/music/player.h>
+
+#include <org/freedesktop/dbus/stub.h>
+
+#include <memory>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class Service;
+
+class PlayerStub : public org::freedesktop::dbus::Stub<Player>
+{
+  public:
+    explicit PlayerStub(
+        const std::shared_ptr<Service>& parent,
+        const org::freedesktop::dbus::types::ObjectPath& object);
+
+    ~PlayerStub();
+
+    virtual std::shared_ptr<TrackList> track_list();
+
+    virtual bool open_uri(const Track::UriType& uri);
+    virtual void next();
+    virtual void previous();
+    virtual void play();
+    virtual void pause();
+    virtual void seek_to(const std::chrono::microseconds& offset);
+    virtual void stop();
+
+    virtual const Property<bool>& can_play() const;
+    virtual const Property<bool>& can_pause() const;
+    virtual const Property<bool>& can_seek() const;
+    virtual const Property<bool>& can_go_previous() const;
+    virtual const Property<bool>& can_go_next() const;
+    virtual const Property<PlaybackStatus>& playback_status() const;    
+    virtual const Property<LoopStatus>& loop_status() const;
+    virtual const Property<PlaybackRate>& playback_rate() const;
+    virtual const Property<bool>& is_shuffle() const;
+    virtual const Property<Track::MetaData>& meta_data_for_current_track() const;
+    virtual const Property<Volume>& volume() const;
+    virtual const Property<PlaybackRate>& minimum_playback_rate() const;
+    virtual const Property<PlaybackRate>& maximum_playback_rate() const;
+        
+    virtual Property<LoopStatus>& loop_status();
+    virtual Property<PlaybackRate>& playback_rate();
+    virtual Property<bool>& is_shuffle();
+    virtual Property<Volume>& volume();
+    
+    virtual const Signal<uint64_t>& seeked_to() const;
+    
+  private:
+    struct Private;
+    std::unique_ptr<Private> d;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_PLAYER_STUB_H_

=== added file 'src/com/ubuntu/music/player_traits.h'
--- src/com/ubuntu/music/player_traits.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/player_traits.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef PLAYER_TRAITS_H_
+#define PLAYER_TRAITS_H_
+
+#include <org/freedesktop/dbus/traits/service.h>
+
+namespace org
+{
+namespace freedesktop
+{
+namespace dbus
+{
+namespace traits
+{
+template<>
+struct Service<com::ubuntu::music::Player>
+{
+    static const std::string& interface_name()
+    {
+        static const std::string s
+        {
+            "com.ubuntu.music.Service.Player"
+        };
+        return s;
+    }
+};
+}
+}
+}
+}
+
+
+#endif // PLAYER_TRAITS_H_

=== added file 'src/com/ubuntu/music/property_stub.h'
--- src/com/ubuntu/music/property_stub.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/property_stub.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,244 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_PROPERTY_STUB_H_
+#define COM_UBUNTU_MUSIC_PROPERTY_STUB_H_
+
+#include <com/ubuntu/music/player.h>
+#include <com/ubuntu/music/property.h>
+#include <com/ubuntu/music/track_list.h>
+
+#include <org/freedesktop/dbus/service.h>
+#include <org/freedesktop/dbus/types/stl/vector.h>
+
+#include "mpris/player.h"
+#include "mpris/track_list.h"
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+
+template<typename T, typename DBusProperty>
+struct PropertyStub : public Property<T>
+{
+    typedef music::Property<T> super;
+
+    PropertyStub(const std::shared_ptr<org::freedesktop::dbus::Property<DBusProperty>>& dbus_property)
+            : super(),
+              dbus_property(dbus_property)
+    {
+    }
+
+    const T& get() const
+    {
+        super::mutable_get() = dbus_property->value();
+        return super::get();
+    }
+
+    void set(const T& value)
+    {
+        dbus_property->value(value);
+        super::set(value);
+    }
+
+    std::shared_ptr<org::freedesktop::dbus::Property<DBusProperty>> dbus_property;
+};
+
+template<>
+struct PropertyStub<music::Player::PlaybackStatus, mpris::Player::Properties::PlaybackStatus> : public music::Property<music::Player::PlaybackStatus>
+{
+    typedef music::Property<Player::PlaybackStatus> super;
+
+    static const std::map<Player::PlaybackStatus, std::string>& playback_status_lut()
+    {
+        static const std::map<Player::PlaybackStatus, std::string> lut =
+        {
+            {Player::PlaybackStatus::null, "null"},
+            {Player::PlaybackStatus::ready, "ready"},
+            {Player::PlaybackStatus::playing, "playing"},
+            {Player::PlaybackStatus::paused, "paused"},
+            {Player::PlaybackStatus::stopped, "stopped"}
+        };
+
+        return lut;
+    }
+
+    static const std::map<std::string, Player::PlaybackStatus>& reverse_playback_status_lut()
+    {
+        static const std::map<std::string, Player::PlaybackStatus> lut =
+        {
+            {"null", Player::PlaybackStatus::null},
+            {"ready", Player::PlaybackStatus::ready},
+            {"playing", Player::PlaybackStatus::playing},
+            {"paused", Player::PlaybackStatus::paused},
+            {"stopped", Player::PlaybackStatus::stopped}
+        };
+
+        return lut;
+    }
+
+    PropertyStub(const std::shared_ptr<org::freedesktop::dbus::Property<mpris::Player::Properties::PlaybackStatus>>& dbus_property)
+            : super(),
+              dbus_property(dbus_property)
+    {
+    }
+
+    const Player::PlaybackStatus& get() const
+    {
+        auto value = dbus_property->value();
+        super::mutable_get() = reverse_playback_status_lut().at(value);
+        return super::get();
+    }
+
+    void set(const Player::PlaybackStatus& value)
+    {
+        dbus_property->value(playback_status_lut().at(value));
+        super::set(value);
+    }
+
+    std::shared_ptr<org::freedesktop::dbus::Property<mpris::Player::Properties::PlaybackStatus>> dbus_property;
+};
+
+template<>
+struct PropertyStub<Player::LoopStatus, mpris::Player::Properties::LoopStatus>
+        : public Property<Player::LoopStatus>
+{
+    typedef Property<Player::LoopStatus> super;
+
+    static const std::map<Player::LoopStatus, std::string>& loop_status_lut()
+    {
+        static const std::map<Player::LoopStatus, std::string> lut =
+        {
+            {Player::LoopStatus::none, "none"},
+            {Player::LoopStatus::track, "track"},
+            {Player::LoopStatus::playlist, "playlist"}
+        };
+
+        return lut;
+    }
+
+    static const std::map<std::string, Player::LoopStatus>& reverse_loop_status_lut()
+    {
+        static const std::map<std::string, Player::LoopStatus> lut =
+        {
+            {"none", Player::LoopStatus::none},
+            {"track", Player::LoopStatus::track},
+            {"playlist", Player::LoopStatus::playlist}
+        };
+
+        return lut;
+    }
+
+    PropertyStub(
+            const std::shared_ptr<org::freedesktop::dbus::Property<mpris::Player::Properties::LoopStatus>>& dbus_property)
+            : super(),
+              dbus_property(dbus_property)
+    {
+    }
+
+    const Player::LoopStatus& get() const
+    {
+        auto value = dbus_property->value();
+        super::mutable_get() = reverse_loop_status_lut().at(value);
+        return super::get();
+    }
+
+    void set(const Player::LoopStatus& value)
+    {
+        dbus_property->value(loop_status_lut().at(value));
+        super::set(value);
+    }
+
+    std::shared_ptr<org::freedesktop::dbus::Property<mpris::Player::Properties::LoopStatus>> dbus_property;
+};
+
+template<>
+struct PropertyStub<TrackList::Container, mpris::TrackList::Properties::Tracks>
+        : public Property<TrackList::Container>
+{
+    typedef Property<TrackList::Container> super;
+
+    PropertyStub(
+            const std::shared_ptr<org::freedesktop::dbus::Property<mpris::TrackList::Properties::Tracks>>& dbus_property)
+            : super(),
+              dbus_property(dbus_property)
+    {
+    }
+
+    const TrackList::Container& get() const
+    {
+        auto remote_value = dbus_property->value();
+
+        super::mutable_get().clear();
+        for (auto path : remote_value)
+        {
+            super::mutable_get().push_back(
+                        music::Track::Id{path});
+        }
+        return super::get();
+    }
+
+    void set(const TrackList::Container& value)
+    {
+        mpris::TrackList::Properties::Tracks::ValueType dbus_tracks;
+
+        for (auto track : value)
+        {
+            dbus_tracks.push_back(track);
+        }
+
+        dbus_property->value(dbus_tracks);
+
+        super::set(value);
+    }
+
+    std::shared_ptr<org::freedesktop::dbus::Property<mpris::TrackList::Properties::Tracks>> dbus_property;
+};
+
+template<>
+struct PropertyStub<Track::MetaData, mpris::Player::Properties::MetaData>
+        : public Property<Track::MetaData>
+{
+    typedef Property<Track::MetaData> super;
+
+    PropertyStub(
+            const std::shared_ptr<org::freedesktop::dbus::Property<mpris::Player::Properties::MetaData>>& dbus_property)
+            : super(),
+              dbus_property(dbus_property)
+    {
+    }
+
+    const Track::MetaData& get() const
+    {
+        return super::get();
+    }
+
+    void set(const Track::MetaData& value)
+    {
+        super::set(value);
+    }
+
+    std::shared_ptr<org::freedesktop::dbus::Property<mpris::Player::Properties::MetaData>> dbus_property;
+};
+}
+}
+}
+#endif // COM_UBUNTU_MUSIC_PROPERTY_STUB_H_

=== modified file 'src/com/ubuntu/music/service.cpp'
--- src/com/ubuntu/music/service.cpp	2013-09-03 18:44:05 +0000
+++ src/com/ubuntu/music/service.cpp	2013-11-11 13:09:24 +0000
@@ -16,27 +16,14 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
-#include "com/ubuntu/music/player.h"
-#include "com/ubuntu/music/service.h"
+#include <com/ubuntu/music/service.h>
+
+#include "service_stub.h"
 
 namespace music = com::ubuntu::music;
 
 const std::shared_ptr<music::Service> music::Service::Client::instance()
 {
-    static std::shared_ptr<music::Service> instance{new music::Service()};
+    static std::shared_ptr<music::Service> instance{new music::ServiceStub()};
     return instance;
 }
-
-music::Service::Service()
-{
-}
-
-music::Service::~Service()
-{
-}
-
-std::shared_ptr<music::Player> music::Service::create_session()
-{
-    static std::shared_ptr<music::Player> session{new music::Player(shared_from_this())};
-    return session;
-}

=== added file 'src/com/ubuntu/music/service_implementation.cpp'
--- src/com/ubuntu/music/service_implementation.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_implementation.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include "service_implementation.h"
+
+#include "player_configuration.h"
+#include "player_implementation.h"
+
+#include "gstreamer/engine.h"
+
+namespace music = com::ubuntu::music;
+
+struct music::ServiceImplementation::Private
+{
+    Private() : engine(std::make_shared<gstreamer::Engine>())
+    {
+    }
+    std::shared_ptr<music::Engine> engine;
+};
+
+music::ServiceImplementation::ServiceImplementation() : d(new Private())
+{
+
+}
+
+music::ServiceImplementation::~ServiceImplementation()
+{
+}
+
+std::shared_ptr<music::Player> music::ServiceImplementation::create_session(
+        const music::Player::Configuration& conf)
+{
+    return std::make_shared<music::PlayerImplementation>(
+                conf.object_path,
+                shared_from_this(),
+                d->engine);
+}

=== added file 'src/com/ubuntu/music/service_implementation.h'
--- src/com/ubuntu/music/service_implementation.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_implementation.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_SERVICE_IMPLEMENTATION_H_
+#define COM_UBUNTU_MUSIC_SERVICE_IMPLEMENTATION_H_
+
+#include "service_skeleton.h"
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class ServiceImplementation : public ServiceSkeleton
+{
+  public:
+    ServiceImplementation ();
+    ~ServiceImplementation ();
+
+    std::shared_ptr<Player> create_session(const Player::Configuration&);
+
+  private:
+    struct Private;
+    std::shared_ptr<Private> d;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_SERVICE_IMPLEMENTATION_H_

=== added file 'src/com/ubuntu/music/service_skeleton.cpp'
--- src/com/ubuntu/music/service_skeleton.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_skeleton.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include "service_skeleton.h"
+
+#include "mpris/service.h"
+#include "player_configuration.h"
+#include "the_session_bus.h"
+
+#include <org/freedesktop/dbus/message.h>
+#include <org/freedesktop/dbus/types/object_path.h>
+
+#include <map>
+#include <sstream>
+
+namespace dbus = org::freedesktop::dbus;
+namespace music = com::ubuntu::music;
+
+namespace
+{
+std::map<dbus::types::ObjectPath, std::shared_ptr<music::Player>> session_store;
+}
+
+struct music::ServiceSkeleton::Private
+{
+    Private(music::ServiceSkeleton* impl)
+        : impl(impl),
+          object(impl->access_service()->add_object_for_path(
+                     dbus::traits::Service<music::Service>::object_path()))
+    {
+        object->install_method_handler<mpris::Service::CreateSession>(
+                    std::bind(
+                        &Private::handle_create_session,
+                        this,
+                        std::placeholders::_1));
+    }
+
+    void handle_create_session(DBusMessage* msg)
+    {
+        static unsigned int session_counter = 0;
+
+        std::stringstream ss;
+        ss << "/com/ubuntu/music/Service/sessions/" << session_counter++;
+
+        dbus::types::ObjectPath op{ss.str()};
+        music::Player::Configuration config{op};
+
+        try
+        {
+            auto session = impl->create_session(config);
+
+            bool inserted = false;
+            std::tie(std::ignore, inserted)
+                    = session_store.insert(std::make_pair(op, session));
+
+            if (!inserted)
+                throw std::runtime_error("Problem persisting session in session store.");
+
+            auto reply = dbus::Message::make_method_return(msg);
+            reply->writer() << op;
+
+            impl->access_bus()->send(reply->get());
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::CreatingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply->get());
+        }
+    }
+
+    music::ServiceSkeleton* impl;
+    dbus::Object::Ptr object;
+
+};
+
+music::ServiceSkeleton::ServiceSkeleton()
+    : dbus::Skeleton<music::Service>(the_session_bus()),
+      d(new Private(this))
+{
+}
+
+music::ServiceSkeleton::~ServiceSkeleton()
+{
+}
+
+void music::ServiceSkeleton::run()
+{
+    access_bus()->run();
+}
+
+void music::ServiceSkeleton::stop()
+{
+    access_bus()->stop();
+}

=== added file 'src/com/ubuntu/music/service_skeleton.h'
--- src/com/ubuntu/music/service_skeleton.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_skeleton.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_SERVICE_SKELETON_H_
+#define COM_UBUNTU_MUSIC_SERVICE_SKELETON_H_
+
+#include <com/ubuntu/music/service.h>
+
+#include "service_traits.h"
+
+#include <org/freedesktop/dbus/skeleton.h>
+
+#include <memory>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class ServiceSkeleton : public org::freedesktop::dbus::Skeleton<com::ubuntu::music::Service>
+{
+  public:
+    ServiceSkeleton();
+    ~ServiceSkeleton();
+
+    void run();
+    void stop();
+
+  private:
+    struct Private;
+    std::shared_ptr<Private> d;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_SERVICE_SKELETON_H_

=== added file 'src/com/ubuntu/music/service_stub.cpp'
--- src/com/ubuntu/music/service_stub.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_stub.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include "service_stub.h"
+#include "service_traits.h"
+
+#include "player_stub.h"
+#include "the_session_bus.h"
+
+#include "mpris/service.h"
+
+namespace dbus = org::freedesktop::dbus;
+namespace music = com::ubuntu::music;
+
+struct music::ServiceStub::Private
+{    
+    dbus::Object::Ptr object;
+};
+
+music::ServiceStub::ServiceStub()
+    : org::freedesktop::dbus::Stub<music::Service>(the_session_bus()),
+      d(new Private{
+        access_service()->object_for_path(
+            dbus::types::ObjectPath(
+                dbus::traits::Service<music::Service>::object_path()))})
+{
+}
+
+music::ServiceStub::~ServiceStub()
+{
+}
+    
+std::shared_ptr<music::Player> music::ServiceStub::create_session(const music::Player::Configuration&)
+{
+    auto op
+            = d->object->invoke_method_synchronously<
+                mpris::Service::CreateSession,
+                dbus::types::ObjectPath>();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem creating session: " + op.error());
+
+    return std::shared_ptr<music::Player>(new music::PlayerStub(shared_from_this(), op.value()));
+}

=== added file 'src/com/ubuntu/music/service_stub.h'
--- src/com/ubuntu/music/service_stub.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_stub.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_SERVICE_STUB_H_
+#define COM_UBUNTU_MUSIC_SERVICE_STUB_H_
+
+#include <com/ubuntu/music/service.h>
+
+#include "service_traits.h"
+
+#include <org/freedesktop/dbus/stub.h>
+
+#include <memory>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace music
+{
+class ServiceStub : public org::freedesktop::dbus::Stub<com::ubuntu::music::Service>
+{
+  public:
+    ServiceStub();
+    ~ServiceStub();
+    
+    std::shared_ptr<Player> create_session(const Player::Configuration&);
+
+  private:
+    struct Private;
+    std::unique_ptr<Private> d;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_SERVICE_STUB_H_

=== added file 'src/com/ubuntu/music/service_traits.h'
--- src/com/ubuntu/music/service_traits.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/service_traits.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef COM_UBUNTU_MUSIC_SERVICE_TRAITS_H_
+#define COM_UBUNTU_MUSIC_SERVICE_TRAITS_H_
+
+#include <com/ubuntu/music/service.h>
+
+#include <org/freedesktop/dbus/traits/service.h>
+
+namespace org
+{
+namespace freedesktop
+{
+namespace dbus
+{
+namespace traits
+{
+template<>
+struct Service<com::ubuntu::music::Service>
+{
+    inline static const std::string& interface_name()
+    {
+        static const std::string s
+        {
+            "com.ubuntu.music.Service"
+        };
+        return s;
+    }
+
+    inline static const std::string& object_path()
+    {
+        static const std::string s
+        {
+            "/com/ubuntu/music/Service"
+        };
+        return s;
+    }
+};
+}
+}
+}
+}
+
+#endif // COM_UBUNTU_MUSIC_SERVICE_TRAITS_H_

=== added file 'src/com/ubuntu/music/the_session_bus.cpp'
--- src/com/ubuntu/music/the_session_bus.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/the_session_bus.cpp	2013-11-11 13:09:24 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#include "the_session_bus.h"
+
+#include <org/freedesktop/dbus/asio/executor.h>
+
+namespace
+{
+std::once_flag once;
+}
+
+org::freedesktop::dbus::Bus::Ptr the_session_bus()
+{
+    static org::freedesktop::dbus::Bus::Ptr bus
+            = std::make_shared<org::freedesktop::dbus::Bus>(
+                org::freedesktop::dbus::WellKnownBus::session);
+    static org::freedesktop::dbus::Executor::Ptr executor
+            = std::make_shared<org::freedesktop::dbus::asio::Executor>(bus);
+
+    std::call_once(once, [](){bus->install_executor(executor);});
+
+    return bus;
+}

=== added file 'src/com/ubuntu/music/the_session_bus.h'
--- src/com/ubuntu/music/the_session_bus.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/music/the_session_bus.h	2013-11-11 13:09:24 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2013 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: Thomas Voß <[e-mail]>
+ */
+
+#ifndef THE_SESSION_BUS_H_
+#define THE_SESSION_BUS_H_
+
+#include <org/freedesktop/dbus/bus.h>
+
+org::freedesktop::dbus::Bus::Ptr the_session_bus();
+
+#endif // THE_SESSION_BUS_H_

=== modified file 'src/com/ubuntu/music/track.cpp'
--- src/com/ubuntu/music/track.cpp	2013-08-13 14:07:37 +0000
+++ src/com/ubuntu/music/track.cpp	2013-11-11 13:09:24 +0000
@@ -16,91 +16,19 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
-#include "com/ubuntu/music/track.h"
+#include <com/ubuntu/music/track.h>
+#include <com/ubuntu/music/property.h>
 
 #include <map>
 
 namespace music = com::ubuntu::music;
 
-const music::Track::MetaData::KeyType& music::Track::MetaData::track_id_key()
-{
-    static const KeyType key = "test";
-    return key;
-}
-
-struct music::Track::MetaData::Private
-{
-    std::map<music::Track::MetaData::KeyType, music::Track::MetaData::ValueType> lut; 
-