Merge lp:~thomas-voss/media-hub/enable-integration-testing into lp:media-hub

[Thomas Voß]

Refactor implementation to allow for testing PlayerImplementation in isolation.

Refactor implementation to allow for testing PlayerImplementation in isolation.

[lp:~thomas-voss/media-hub/enable-integration-testing]

104. By Thomas Voß on 2014-11-18

Add a first set of test cases around media::PlayerImplementation.

105. By Thomas Voß on 2014-11-18

Add the first test cases for PlayerSkeleton.

106. By Thomas Voß on 2014-11-18

Add further testing for PlayerSkeleton.

107. By Thomas Voß on 2014-11-18

Add tests for HashedKeyedPlayerStore.
Add tests for ServiceImplementation.

108. By Thomas Voß on 2014-11-19

Add further tests around ServiceImplementation.

109. By Thomas Voß on 2014-11-19

Move mocks and tests around to make them reusable and correctly classified.

Unmerged revisions

109. By Thomas Voß on 2014-11-19

Move mocks and tests around to make them reusable and correctly classified.

108. By Thomas Voß on 2014-11-19

Add further tests around ServiceImplementation.

107. By Thomas Voß on 2014-11-18

Add tests for HashedKeyedPlayerStore.
Add tests for ServiceImplementation.

106. By Thomas Voß on 2014-11-18

Add further testing for PlayerSkeleton.

105. By Thomas Voß on 2014-11-18

Add the first test cases for PlayerSkeleton.

104. By Thomas Voß on 2014-11-18

Add a first set of test cases around media::PlayerImplementation.

103. By Thomas Voß on 2014-11-17

Refactor implementation to allow for testing PlayerImplementation in isolation.

102. By Thomas Voß on 2014-11-17

Make ClientDeathObserver instance a dependency passed down through ctors.

101. By Thomas Voß on 2014-11-17

Adjust setup of service instance in acceptance tests.

100. By Thomas Voß on 2014-11-17

Re-merge prerequisite branch.

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2014-11-19 10:23:50 +0000
+++ include/core/media/player.h	2014-11-19 10:23:50 +0000
@@ -152,7 +152,7 @@
     virtual core::Signal<PlaybackStatus>& playback_status_changed() = 0;
     virtual const core::Signal<video::Dimensions>& video_dimension_changed() const = 0;
   protected:
-    Player();
+    Player();   
 
 };
 }

=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2014-11-19 10:23:50 +0000
+++ src/core/media/CMakeLists.txt	2014-11-19 10:23:50 +0000
@@ -15,6 +15,10 @@
 add_library(
   media-hub-common SHARED
 
+  player.cpp
+  track.cpp
+  track_list.cpp
+
   the_session_bus.cpp
 )
 
@@ -40,10 +44,7 @@
 
   ${MEDIA_HUB_HEADERS}
 
-  player.cpp
   service.cpp
-  track.cpp
-  track_list.cpp
 
   player_stub.cpp
   service_stub.cpp
@@ -85,8 +86,11 @@
     ${MEDIA_HUB_HEADERS}
     ${MPRIS_HEADERS}
 
+    base_engine.cpp
+    base_player.cpp
     client_death_observer.cpp
-    hybris_client_death_observer.cpp
+    hashed_keyed_player_store.cpp
+    hybris_client_death_observer.cpp    
     cover_art_resolver.cpp
     engine.cpp
 
@@ -97,6 +101,7 @@
     hybris_recorder_observer.cpp
 
     gstreamer/engine.cpp
+    gstreamer/engine_factory.cpp
     gstreamer/playbin.cpp
 
     player_skeleton.cpp
@@ -134,6 +139,7 @@
 
   media-hub-service
   media-hub-client
+  media-hub-common
   call-monitor
 
   ${DBUS_LIBRARIES}

=== added file 'src/core/media/base_engine.cpp'
--- src/core/media/base_engine.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/base_engine.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,181 @@
+/**
+ * Copyright (C) 2014 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 <core/media/base_engine.h>
+
+namespace media = core::ubuntu::media;
+
+const core::Property<media::Engine::State>& media::BaseEngine::state() const
+{
+    return properties.state;
+}
+
+const core::Property<bool>& media::BaseEngine::is_video_source() const
+{
+    return properties.is_video_source;
+}
+
+const core::Property<bool>& media::BaseEngine::is_audio_source() const
+{
+    return properties.is_audio_source;
+}
+
+const core::Property<uint64_t>& media::BaseEngine::position() const
+{
+    return properties.position;
+}
+
+const core::Property<uint64_t>& media::BaseEngine::duration() const
+{
+    return properties.duration;
+}
+
+const core::Property<media::Engine::Volume>& media::BaseEngine::volume() const
+{
+    return properties.volume;
+}
+
+core::Property<media::Engine::Volume>& media::BaseEngine::volume()
+{
+    return properties.volume;
+}
+
+const core::Property<media::Player::AudioStreamRole>& media::BaseEngine::audio_stream_role() const
+{
+    return properties.audio_stream_role;
+}
+
+core::Property<media::Player::AudioStreamRole>& media::BaseEngine::audio_stream_role()
+{
+    return properties.audio_stream_role;
+}
+
+const core::Property<media::Player::Orientation>& media::BaseEngine::orientation() const
+{
+    return properties.orientation;
+}
+
+const core::Property<std::tuple<media::Track::UriType, media::Track::MetaData>>& media::BaseEngine::track_meta_data() const
+{
+    return properties.track_meta_data;
+}
+
+const core::Signal<void>& media::BaseEngine::about_to_finish_signal() const
+{
+    return signals.about_to_finish;
+}
+
+const core::Signal<uint64_t>& media::BaseEngine::seeked_to_signal() const
+{
+    return signals.seeked_to;
+}
+
+const core::Signal<void>& media::BaseEngine::client_disconnected_signal() const
+{
+    return signals.client_disconnected;
+}
+
+const core::Signal<void>& media::BaseEngine::end_of_stream_signal() const
+{
+    return signals.end_of_stream;
+}
+
+const core::Signal<media::Player::PlaybackStatus>& media::BaseEngine::playback_status_changed_signal() const
+{
+    return signals.playback_status_changed;
+}
+
+const core::Signal<media::video::Dimensions>& media::BaseEngine::video_dimension_changed_signal() const
+{
+    return signals.video_dimension_changed;
+}
+
+core::Property<media::Engine::State>& media::BaseEngine::mutable_state()
+{
+    return properties.state;
+}
+
+core::Property<bool>& media::BaseEngine::mutable_is_video_source()
+{
+    return properties.is_video_source;
+}
+
+core::Property<bool>& media::BaseEngine::mutable_is_audio_source()
+{
+    return properties.is_audio_source;
+}
+
+core::Property<uint64_t>& media::BaseEngine::mutable_position()
+{
+    return properties.position;
+}
+
+core::Property<uint64_t>& media::BaseEngine::mutable_duration()
+{
+    return properties.duration;
+}
+
+core::Property<media::Engine::Volume>& media::BaseEngine::mutable_volume()
+{
+    return properties.volume;
+}
+
+core::Property<media::Player::AudioStreamRole>& media::BaseEngine::mutable_audio_stream_role()
+{
+    return properties.audio_stream_role;
+}
+
+core::Property<media::Player::Orientation>& media::BaseEngine::mutable_orientation()
+{
+    return properties.orientation;
+}
+
+core::Property<std::tuple<media::Track::UriType, media::Track::MetaData>>& media::BaseEngine::mutable_track_meta_data()
+{
+    return properties.track_meta_data;
+}
+
+core::Signal<void>& media::BaseEngine::mutable_about_to_finish_signal()
+{
+    return signals.about_to_finish;
+}
+
+core::Signal<uint64_t>& media::BaseEngine::mutable_seeked_to_signal()
+{
+    return signals.seeked_to;
+}
+
+core::Signal<void>& media::BaseEngine::mutable_client_disconnected_signal()
+{
+    return signals.client_disconnected;
+}
+
+core::Signal<void>& media::BaseEngine::mutable_end_of_stream_signal()
+{
+    return signals.end_of_stream;
+}
+
+core::Signal<media::Player::PlaybackStatus>& media::BaseEngine::mutable_playback_status_changed_signal()
+{
+    return signals.playback_status_changed;
+}
+
+core::Signal<media::video::Dimensions>& media::BaseEngine::mutable_video_dimension_changed_signal()
+{
+    return signals.video_dimension_changed;
+}

=== added file 'src/core/media/base_engine.h'
--- src/core/media/base_engine.h	1970-01-01 00:00:00 +0000
+++ src/core/media/base_engine.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,100 @@
+/**
+ * Copyright (C) 2014 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 CORE_UBUNTU_MEDIA_BASE_ENGINE_H_
+#define CORE_UBUNTU_MEDIA_BASE_ENGINE_H_
+
+#include <core/media/engine.h>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// Helper class providing a default setup for
+// properties and signals.
+class BaseEngine : public Engine
+{
+public:
+    virtual const core::Property<State>& state() const override;
+    virtual const core::Property<bool>& is_video_source() const override;
+    virtual const core::Property<bool>& is_audio_source() const override;
+    virtual const core::Property<uint64_t>& position() const override;
+    virtual const core::Property<uint64_t>& duration() const override;
+    virtual const core::Property<Engine::Volume>& volume() const override;
+    virtual core::Property<Engine::Volume>& volume() override;
+    virtual const core::Property<Player::AudioStreamRole>& audio_stream_role() const override;
+    virtual core::Property<Player::AudioStreamRole>& audio_stream_role() override;
+    virtual const core::Property<Player::Orientation>& orientation() const override;
+    virtual const core::Property<std::tuple<Track::UriType, Track::MetaData>>& track_meta_data() const override;
+    virtual const core::Signal<void>& about_to_finish_signal() const override;
+    virtual const core::Signal<uint64_t>& seeked_to_signal() const override;
+    virtual const core::Signal<void>& client_disconnected_signal() const override;
+    virtual const core::Signal<void>& end_of_stream_signal() const override;
+    virtual const core::Signal<Player::PlaybackStatus>& playback_status_changed_signal() const override;
+    virtual const core::Signal<video::Dimensions>& video_dimension_changed_signal() const override;
+
+protected:
+    BaseEngine() = default;
+
+    virtual core::Property<State>& mutable_state();
+    virtual core::Property<bool>& mutable_is_video_source();
+    virtual core::Property<bool>& mutable_is_audio_source();
+    virtual core::Property<uint64_t>& mutable_position();
+    virtual core::Property<uint64_t>& mutable_duration();
+    virtual core::Property<Engine::Volume>& mutable_volume();
+    virtual core::Property<Player::AudioStreamRole>& mutable_audio_stream_role();
+    virtual core::Property<Player::Orientation>& mutable_orientation();
+    virtual core::Property<std::tuple<Track::UriType, Track::MetaData>>& mutable_track_meta_data();
+    virtual core::Signal<void>& mutable_about_to_finish_signal();
+    virtual core::Signal<uint64_t>& mutable_seeked_to_signal();
+    virtual core::Signal<void>& mutable_client_disconnected_signal();
+    virtual core::Signal<void>& mutable_end_of_stream_signal();
+    virtual core::Signal<Player::PlaybackStatus>& mutable_playback_status_changed_signal();
+    virtual core::Signal<video::Dimensions>& mutable_video_dimension_changed_signal();
+
+private:
+    struct
+    {
+        core::Property<State> state;
+        core::Property<bool> is_video_source;
+        core::Property<bool> is_audio_source;
+        core::Property<uint64_t> position;
+        core::Property<uint64_t> duration;
+        core::Property<Engine::Volume> volume;
+        core::Property<Player::AudioStreamRole> audio_stream_role;
+        core::Property<Player::Orientation> orientation;
+        core::Property<std::tuple<Track::UriType, Track::MetaData>> track_meta_data;
+    } properties;
+
+    struct
+    {
+        core::Signal<void> about_to_finish;
+        core::Signal<uint64_t> seeked_to;
+        core::Signal<void> client_disconnected;
+        core::Signal<void> end_of_stream;
+        core::Signal<Player::PlaybackStatus> playback_status_changed;
+        core::Signal<video::Dimensions> video_dimension_changed;
+    } signals;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_BASE_ENGINE_H_

=== added file 'src/core/media/base_player.cpp'
--- src/core/media/base_player.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/base_player.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,250 @@
+/**
+ * Copyright (C) 2014 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 <core/media/base_player.h>
+
+namespace media = core::ubuntu::media;
+
+media::BasePlayer::BasePlayer()
+{
+}
+
+const core::Property<bool>& media::BasePlayer::can_play() const
+{
+    return properties.can_play;
+}
+
+const core::Property<bool>& media::BasePlayer::can_pause() const
+{
+    return properties.can_pause;
+}
+
+const core::Property<bool>& media::BasePlayer::can_seek() const
+{
+    return properties.can_seek;
+}
+
+const core::Property<bool>& media::BasePlayer::can_go_previous() const
+{
+    return properties.can_go_previous;
+}
+
+const core::Property<bool>& media::BasePlayer::can_go_next() const
+{
+    return properties.can_go_next;
+}
+
+const core::Property<bool>& media::BasePlayer::is_video_source() const
+{
+    return properties.is_video_source;
+}
+
+const core::Property<bool>& media::BasePlayer::is_audio_source() const
+{
+    return properties.is_audio_source;
+}
+
+const core::Property<media::Player::PlaybackStatus>& media::BasePlayer::playback_status() const
+{
+    return properties.playback_status;
+}
+
+const core::Property<media::Player::LoopStatus>& media::BasePlayer::loop_status() const
+{
+    return properties.loop_status;
+}
+
+const core::Property<media::Player::PlaybackRate>& media::BasePlayer::playback_rate() const
+{
+    return properties.playback_rate;
+}
+
+const core::Property<bool>& media::BasePlayer::is_shuffle() const
+{
+    return properties.is_shuffle;
+}
+
+const core::Property<media::Track::MetaData>& media::BasePlayer::meta_data_for_current_track() const
+{
+    return properties.meta_data_for_current_track;
+}
+
+const core::Property<media::Player::Volume>& media::BasePlayer::volume() const
+{
+    return properties.volume;
+}
+
+const core::Property<media::Player::PlaybackRate>& media::BasePlayer::minimum_playback_rate() const
+{
+    return properties.minimum_playback_rate;
+}
+
+const core::Property<media::Player::PlaybackRate>& media::BasePlayer::maximum_playback_rate() const
+{
+    return properties.maximum_playback_rate;
+}
+
+const core::Property<int64_t>& media::BasePlayer::position() const
+{
+    return properties.position;
+}
+
+const core::Property<int64_t>& media::BasePlayer::duration() const
+{
+    return properties.duration;
+}
+
+const core::Property<media::Player::AudioStreamRole>& media::BasePlayer::audio_stream_role() const
+{
+    return properties.audio_stream_role;
+}
+
+const core::Property<media::Player::Orientation>& media::BasePlayer::orientation() const
+{
+    return properties.orientation;
+}
+
+core::Property<media::Player::LoopStatus>& media::BasePlayer::loop_status()
+{
+    return properties.loop_status;
+}
+
+core::Property<media::Player::PlaybackRate>& media::BasePlayer::playback_rate()
+{
+    return properties.playback_rate;
+}
+
+core::Property<bool>& media::BasePlayer::is_shuffle()
+{
+    return properties.is_shuffle;
+}
+
+core::Property<media::Player::Volume>& media::BasePlayer::volume()
+{
+    return properties.volume;
+}
+
+core::Property<media::Player::AudioStreamRole>& media::BasePlayer::audio_stream_role()
+{
+    return properties.audio_stream_role;
+}
+
+const core::Signal<int64_t>& media::BasePlayer::seeked_to() const
+{
+    return signals.seeked_to;
+}
+
+const core::Signal<void>& media::BasePlayer::end_of_stream() const
+{
+    return signals.end_of_stream;
+}
+
+core::Signal<media::Player::PlaybackStatus>& media::BasePlayer::playback_status_changed()
+{
+    return signals.playback_status_changed;
+}
+
+const core::Signal<media::video::Dimensions>& media::BasePlayer::video_dimension_changed() const
+{
+    return signals.video_dimension_changed;
+}
+
+core::Property<media::Player::PlaybackStatus>& media::BasePlayer::playback_status()
+{
+    return properties.playback_status;
+}
+
+core::Property<bool>& media::BasePlayer::can_play()
+{
+    return properties.can_play;
+}
+
+core::Property<bool>& media::BasePlayer::can_pause()
+{
+    return properties.can_pause;
+}
+
+core::Property<bool>& media::BasePlayer::can_seek()
+{
+    return properties.can_seek;
+}
+
+core::Property<bool>& media::BasePlayer::can_go_previous()
+{
+    return properties.can_go_previous;
+}
+
+core::Property<bool>& media::BasePlayer::can_go_next()
+{
+    return properties.can_go_next;
+}
+
+core::Property<bool>& media::BasePlayer::is_video_source()
+{
+    return properties.is_video_source;
+}
+
+core::Property<bool>& media::BasePlayer::is_audio_source()
+{
+    return properties.is_audio_source;
+}
+
+core::Property<media::Track::MetaData>& media::BasePlayer::meta_data_for_current_track()
+{
+    return properties.meta_data_for_current_track;
+}
+
+core::Property<media::Player::PlaybackRate>& media::BasePlayer::minimum_playback_rate()
+{
+    return properties.minimum_playback_rate;
+}
+
+core::Property<media::Player::PlaybackRate>& media::BasePlayer::maximum_playback_rate()
+{
+    return properties.maximum_playback_rate;
+}
+
+core::Property<int64_t>& media::BasePlayer::position()
+{
+    return properties.position;
+}
+
+core::Property<int64_t>& media::BasePlayer::duration()
+{
+    return properties.duration;
+}
+
+core::Property<media::Player::Orientation>& media::BasePlayer::orientation()
+{
+    return properties.orientation;
+}
+
+core::Signal<int64_t>& media::BasePlayer::seeked_to()
+{
+    return signals.seeked_to;
+}
+
+core::Signal<void>& media::BasePlayer::end_of_stream()
+{
+    return signals.end_of_stream;
+}
+
+core::Signal<media::video::Dimensions>& media::BasePlayer::video_dimension_changed()
+{
+    return signals.video_dimension_changed;
+}

=== added file 'src/core/media/base_player.h'
--- src/core/media/base_player.h	1970-01-01 00:00:00 +0000
+++ src/core/media/base_player.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,127 @@
+/**
+ * Copyright (C) 2014 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 CORE_UBUNTU_MEDIA_BASE_PLAYER_H_
+#define CORE_UBUNTU_MEDIA_BASE_PLAYER_H_
+
+#include <core/media/mutable_player.h>
+
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// A player implementation that provides a default implementation
+// for accessing properties and signals.
+class BasePlayer : public MutablePlayer
+{
+public:
+    virtual const core::Property<bool>& can_play() const override;
+    virtual const core::Property<bool>& can_pause() const override;
+    virtual const core::Property<bool>& can_seek() const override;
+    virtual const core::Property<bool>& can_go_previous() const override;
+    virtual const core::Property<bool>& can_go_next() const override;
+    virtual const core::Property<bool>& is_video_source() const override;
+    virtual const core::Property<bool>& is_audio_source() const override;
+    virtual const core::Property<PlaybackStatus>& playback_status() const override;
+    virtual const core::Property<LoopStatus>& loop_status() const override;
+    virtual const core::Property<PlaybackRate>& playback_rate() const override;
+    virtual const core::Property<bool>& is_shuffle() const override;
+    virtual const core::Property<Track::MetaData>& meta_data_for_current_track() const override;
+    virtual const core::Property<Volume>& volume() const override;
+    virtual const core::Property<PlaybackRate>& minimum_playback_rate() const override;
+    virtual const core::Property<PlaybackRate>& maximum_playback_rate() const override;
+    virtual const core::Property<int64_t>& position() const override;
+    virtual const core::Property<int64_t>& duration() const override;
+    virtual const core::Property<AudioStreamRole>& audio_stream_role() const override;
+    virtual const core::Property<Orientation>& orientation() const override;
+
+    virtual core::Property<LoopStatus>& loop_status() override;
+    virtual core::Property<PlaybackRate>& playback_rate() override;
+    virtual core::Property<bool>& is_shuffle() override;
+    virtual core::Property<Volume>& volume() override;
+    virtual core::Property<AudioStreamRole>& audio_stream_role() override;
+
+    virtual const core::Signal<int64_t>& seeked_to() const override;
+    virtual const core::Signal<void>& end_of_stream() const override;
+    virtual core::Signal<PlaybackStatus>& playback_status_changed() override;
+    virtual const core::Signal<video::Dimensions>& video_dimension_changed() const override;
+
+protected:
+    BasePlayer();
+    // These properties are not exposed to the client, but still need to be
+    // able to be settable from within the Player:
+    virtual core::Property<PlaybackStatus>& playback_status();
+    virtual core::Property<bool>& can_play();
+    virtual core::Property<bool>& can_pause();
+    virtual core::Property<bool>& can_seek();
+    virtual core::Property<bool>& can_go_previous();
+    virtual core::Property<bool>& can_go_next();
+    virtual core::Property<bool>& is_video_source();
+    virtual core::Property<bool>& is_audio_source();
+    virtual core::Property<Track::MetaData>& meta_data_for_current_track();
+    virtual core::Property<PlaybackRate>& minimum_playback_rate();
+    virtual core::Property<PlaybackRate>& maximum_playback_rate();
+    virtual core::Property<int64_t>& position();
+    virtual core::Property<int64_t>& duration();
+    virtual core::Property<Orientation>& orientation();
+
+    virtual core::Signal<int64_t>& seeked_to();
+    virtual core::Signal<void>& end_of_stream();
+    virtual core::Signal<video::Dimensions>& video_dimension_changed();
+
+private:
+    struct
+    {
+        core::Property<bool> can_play;
+        core::Property<bool> can_pause;
+        core::Property<bool> can_seek;
+        core::Property<bool> can_go_previous;
+        core::Property<bool> can_go_next;
+        core::Property<bool> is_video_source;
+        core::Property<bool> is_audio_source;
+        core::Property<PlaybackStatus> playback_status;
+        core::Property<LoopStatus> loop_status;
+        core::Property<PlaybackRate> playback_rate;
+        core::Property<bool> is_shuffle;
+        core::Property<Track::MetaData> meta_data_for_current_track;
+        core::Property<Volume> volume;
+        core::Property<PlaybackRate> minimum_playback_rate;
+        core::Property<PlaybackRate> maximum_playback_rate;
+        core::Property<int64_t> position;
+        core::Property<int64_t> duration;
+        core::Property<AudioStreamRole> audio_stream_role;
+        core::Property<Orientation> orientation;
+    } properties;
+
+    struct
+    {
+        core::Signal<int64_t> seeked_to;
+        core::Signal<void> end_of_stream;
+        core::Signal<PlaybackStatus> playback_status_changed;
+        core::Signal<video::Dimensions> video_dimension_changed;
+    } signals;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_COMPOSITED_PLAYER_H_

=== modified file 'src/core/media/engine.cpp'
--- src/core/media/engine.cpp	2014-09-08 10:16:38 +0000
+++ src/core/media/engine.cpp	2014-11-19 10:23:50 +0000
@@ -49,3 +49,23 @@
 {
     return value == rhs.value;
 }
+
+// Pretty prints the engine state to the given output stream;
+std::ostream& media::operator<<(std::ostream& out, media::Engine::State state)
+{
+    switch (state)
+    {
+    case media::Engine::State::ready:
+        return out << "Engine::State::ready";
+    case media::Engine::State::busy:
+        return out << "Engine::State::busy";
+    case media::Engine::State::playing:
+        return out << "Engine::State::playing";
+    case media::Engine::State::paused:
+        return out << "Engine::State::paused";
+    case media::Engine::State::stopped:
+        return out << "Engine::State::stopped";
+    }
+
+    return out;
+}

=== modified file 'src/core/media/engine.h'
--- src/core/media/engine.h	2014-11-19 10:23:50 +0000
+++ src/core/media/engine.h	2014-11-19 10:23:50 +0000
@@ -35,6 +35,7 @@
 class Engine
 {
 public:
+    typedef std::shared_ptr<Engine> Ptr;
 
     enum class State
     {
@@ -110,6 +111,9 @@
 
     virtual void reset() = 0;
 };
+
+// Pretty prints the engine state to the given output stream;
+std::ostream& operator<<(std::ostream&, Engine::State);
 }
 }
 }

=== added file 'src/core/media/engine_factory.h'
--- src/core/media/engine_factory.h	1970-01-01 00:00:00 +0000
+++ src/core/media/engine_factory.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2014 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 CORE_UBUNTU_MEDIA_ENGINE_FACTORY_H_
+#define CORE_UBUNTU_MEDIA_ENGINE_FACTORY_H_
+
+#include <functional>
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// Forward declared to avoid include.
+class Engine;
+// A functor for creating Engine instances.
+typedef std::function<std::shared_ptr<Engine>()> EngineFactory;
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_ENGINE_FACTORY_H_

=== added file 'src/core/media/gstreamer/engine_factory.cpp'
--- src/core/media/gstreamer/engine_factory.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/gstreamer/engine_factory.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2014 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 <core/media/gstreamer/engine_factory.h>
+
+#include <core/media/gstreamer/engine.h>
+
+namespace media = core::ubuntu::media;
+
+media::EngineFactory media::gstreamer::engine_factory()
+{
+    return []()
+    {
+        return std::make_shared<::gstreamer::Engine>();
+    };
+}

=== added file 'src/core/media/gstreamer/engine_factory.h'
--- src/core/media/gstreamer/engine_factory.h	1970-01-01 00:00:00 +0000
+++ src/core/media/gstreamer/engine_factory.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2014 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 CORE_UBUNTU_MEDIA_GSTREAMER_ENGINE_FACTORY_H_
+#define CORE_UBUNTU_MEDIA_GSTREAMER_ENGINE_FACTORY_H_
+
+#include <core/media/engine_factory.h>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace gstreamer
+{
+// Returns a functor that in turn allows for
+// creating gstreamer::Engine instances.
+EngineFactory engine_factory();
+}
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_GSTREAMER_ENGINE_FACTORY_H_

=== modified file 'src/core/media/gstreamer/playbin.cpp'
--- src/core/media/gstreamer/playbin.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/gstreamer/playbin.cpp	2014-11-19 10:23:50 +0000
@@ -124,7 +124,7 @@
 
 void gstreamer::Playbin::reset_pipeline()
 {
-    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    std::cout << __PRETTY_FUNCTION__ << std::endl;   
     auto ret = gst_element_set_state(pipeline, GST_STATE_NULL);
     switch(ret)
     {

=== added file 'src/core/media/hashed_keyed_player_store.cpp'
--- src/core/media/hashed_keyed_player_store.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/hashed_keyed_player_store.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright © 2014 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 <core/media/hashed_keyed_player_store.h>
+
+namespace media = core::ubuntu::media;
+
+media::HashedKeyedPlayerStore::HashedKeyedPlayerStore()
+{
+}
+
+const core::Property<std::shared_ptr<media::Player>>& media::HashedKeyedPlayerStore::current_player() const
+{
+    return prop_current_player;
+}
+
+bool media::HashedKeyedPlayerStore::has_player_for_key(const media::Player::PlayerKey& key) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    return map.count(key) > 0;
+}
+
+std::shared_ptr<media::Player> media::HashedKeyedPlayerStore::player_for_key(const media::Player::PlayerKey& key) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    auto it = map.find(key);
+
+    if (it == map.end()) throw std::out_of_range
+    {
+        "HashedKeyedPlayerStore::player_for_key: No player known for " + std::to_string(key)
+    };
+
+    return it->second;
+}
+
+void media::HashedKeyedPlayerStore::enumerate_players(const media::KeyedPlayerStore::PlayerEnumerator& enumerator) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    for (const auto& pair : map)
+        enumerator(pair.first, pair.second);
+}
+
+void media::HashedKeyedPlayerStore::add_player_for_key(const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
+{
+    std::lock_guard<std::mutex> lg{guard};
+    map[key] = player;
+}
+
+void media::HashedKeyedPlayerStore::remove_player_for_key(const media::Player::PlayerKey& key)
+{
+    std::lock_guard<std::mutex> lg{guard};
+    auto it = map.find(key);
+    if (it != map.end())
+    {
+        if (prop_current_player == it->second)
+            prop_current_player = nullptr;
+
+        map.erase(it);
+    }
+}
+
+void media::HashedKeyedPlayerStore::set_current_player_for_key(const media::Player::PlayerKey& key)
+{
+    prop_current_player = player_for_key(key);
+}

=== added file 'src/core/media/hashed_keyed_player_store.h'
--- src/core/media/hashed_keyed_player_store.h	1970-01-01 00:00:00 +0000
+++ src/core/media/hashed_keyed_player_store.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2014 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 CORE_UBUNTU_MEDIA_HASHED_KEYED_PLAYER_STORE_H_
+#define CORE_UBUNTU_MEDIA_HASHED_KEYED_PLAYER_STORE_H_
+
+#include <core/media/keyed_player_store.h>
+
+#include <mutex>
+#include <unordered_map>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// Implements KeyedPlayerStore using a std::unordered_map.
+class HashedKeyedPlayerStore : public KeyedPlayerStore
+{
+public:
+    HashedKeyedPlayerStore();
+    // We keep track of the "current" player, that is, the one
+    // that has been created most recently and provide a getable/observable
+    // access to that designated instance.
+    const core::Property<std::shared_ptr<media::Player>>& current_player() const override;
+
+    // We keep track of all known player sessions here and render them accessible via
+    // the key. All of these functions are thread-safe but not reentrant.
+    // Returns true iff a player is known for the given key.
+    bool has_player_for_key(const Player::PlayerKey& key) const override;
+
+    // Returns the player for the given key or throws std::out_of_range if no player is known
+    // for the given key.
+    // Throws std::out_of_range if no player is known for the key.
+    std::shared_ptr<Player> player_for_key(const Player::PlayerKey& key) const override;
+
+    // Enumerates all known players and invokes the given enumerator for each
+    // (key, player) pair.
+    void enumerate_players(const PlayerEnumerator& enumerator) const override;
+
+    // Adds the given player with the given key.
+    void add_player_for_key(const Player::PlayerKey& key, const std::shared_ptr<Player>& player) override;
+
+    // Removes the player for the given key, and unsets it if it is the current one.
+    void remove_player_for_key(const Player::PlayerKey& key) override;
+
+    // Makes the player known under the given key current.
+    // Throws std::out_of_range if no player is known for the key.
+    void set_current_player_for_key(const Player::PlayerKey& key) override;
+
+private:
+    core::Property<std::shared_ptr<Player>> prop_current_player;
+    mutable std::mutex guard;
+    std::unordered_map<Player::PlayerKey, std::shared_ptr<Player>> map;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_

=== added file 'src/core/media/keyed_player_store.cpp'
=== added file 'src/core/media/keyed_player_store.h'
--- src/core/media/keyed_player_store.h	1970-01-01 00:00:00 +0000
+++ src/core/media/keyed_player_store.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2014 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 CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_
+#define CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_
+
+#include <core/media/player.h>
+
+#include <core/property.h>
+
+#include <functional>
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// An interface abstracting keyed lookups of known Player instances.
+class KeyedPlayerStore
+{
+public:
+    // Save us some typing.
+    typedef std::shared_ptr<KeyedPlayerStore> Ptr;
+    // Functor for enumerating all known (key, player) pairs.
+    typedef std::function
+    <
+        void(
+            // The key of the player.
+            const Player::PlayerKey&,
+            // The actual player instance.
+            const std::shared_ptr<Player>&
+        )
+    > PlayerEnumerator;
+    // We keep track of the "current" player, that is, the one
+    // that has been created most recently and provide a getable/observable
+    // access to that designated instance.
+    virtual const core::Property<std::shared_ptr<Player>>& current_player() const = 0;
+
+    // We keep track of all known player sessions here and render them accessible via
+    // the key. All of these functions are thread-safe but not reentrant.
+    // Returns true iff a player is known for the given key.
+    virtual bool has_player_for_key(const Player::PlayerKey& key) const = 0;
+    // Returns the player for the given key or throws std::out_of_range if no player is known
+    // for the given key.
+    virtual std::shared_ptr<Player> player_for_key(const Player::PlayerKey& key) const = 0;
+    // Enumerates all known players and invokes the given enumerator for each
+    // (key, player) pair.
+    virtual void enumerate_players(const PlayerEnumerator& enumerator) const = 0;
+    // Adds the given player with the given key.
+    virtual void add_player_for_key(const Player::PlayerKey& key, const std::shared_ptr<Player>& player) = 0;
+    // Removes the player for the given key, and unsets it if it is the current one.
+    virtual void remove_player_for_key(const Player::PlayerKey& key) = 0;
+    // Makes the player known under the given key current.
+    virtual void set_current_player_for_key(const Player::PlayerKey& key) = 0;
+
+protected:
+    KeyedPlayerStore() = default;
+    KeyedPlayerStore(const KeyedPlayerStore&) = delete;
+    virtual ~KeyedPlayerStore() = default;
+    KeyedPlayerStore& operator=(const KeyedPlayerStore&) = delete;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_

=== added file 'src/core/media/mpris/exported.h'
--- src/core/media/mpris/exported.h	1970-01-01 00:00:00 +0000
+++ src/core/media/mpris/exported.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,305 @@
+/*
+ * Copyright © 2014 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_EXPORTED_H_
+#define MPRIS_EXPORTED_H_
+
+#include <core/media/cover_art_resolver.h>
+#include <core/media/xesam.h>
+
+#include <core/media/mpris/media_player2.h>
+#include <core/media/mpris/metadata.h>
+#include <core/media/mpris/player.h>
+#include <core/media/mpris/playlists.h>
+#include <core/media/mpris/service.h>
+
+#include <core/posix/this_process.h>
+
+namespace mpris
+{
+struct Exported
+{
+    static mpris::MediaPlayer2::Skeleton::Configuration::Defaults media_player_defaults()
+    {
+        mpris::MediaPlayer2::Skeleton::Configuration::Defaults defaults;
+        // TODO(tvoss): These three elements really should be configurable.
+        defaults.identity = "core::media::Hub";
+        defaults.desktop_entry = "mediaplayer-app";
+        defaults.supported_mime_types = {"audio/mpeg3"};
+
+        return defaults;
+    }
+
+    static mpris::Player::Skeleton::Configuration::Defaults player_defaults()
+    {
+        mpris::Player::Skeleton::Configuration::Defaults defaults;
+
+        // Disabled as track list is not fully implemented yet.
+        defaults.can_go_next = false;
+        // Disabled as track list is not fully implemented yet.
+        defaults.can_go_previous = false;
+
+        return defaults;
+    }
+
+    static std::string service_name()
+    {
+        static const bool export_to_indicator_sound_via_mpris
+        {
+            core::posix::this_process::env::get("UBUNTU_MEDIA_HUB_EXPORT_TO_INDICATOR_VIA_MPRIS", "0") == "1"
+        };
+
+        return export_to_indicator_sound_via_mpris ? "org.mpris.MediaPlayer2.MediaHub" :
+                                                     "hidden.org.mpris.MediaPlayer2.MediaHub";
+    }
+
+    static const core::Signal<void>& the_empty_signal()
+    {
+        static const core::Signal<void> instance;
+        return instance;
+    }
+
+    explicit Exported(const dbus::Bus::Ptr& bus, const core::ubuntu::media::CoverArtResolver& cover_art_resolver)
+        : bus{bus},
+          service{dbus::Service::add_service(bus, service_name())},
+          object{service->add_object_for_path(dbus::types::ObjectPath{"/org/mpris/MediaPlayer2"})},
+          media_player{mpris::MediaPlayer2::Skeleton::Configuration{bus, object, media_player_defaults()}},
+          player{mpris::Player::Skeleton::Configuration{bus, object, player_defaults()}},
+          playlists{mpris::Playlists::Skeleton::Configuration{bus, object, mpris::Playlists::Skeleton::Configuration::Defaults{}}},
+          cover_art_resolver{cover_art_resolver}
+    {
+        object->install_method_handler<core::dbus::interfaces::Properties::GetAll>([this](const core::dbus::Message::Ptr& msg)
+        {
+            // Extract the interface
+            std::string itf; msg->reader() >> itf;
+            core::dbus::Message::Ptr reply = core::dbus::Message::make_method_return(msg);
+
+            if (itf == mpris::Player::name())
+                reply->writer() << player.get_all_properties();
+            else if (itf == mpris::MediaPlayer2::name())
+                reply->writer() << media_player.get_all_properties();
+            else if (itf == mpris::Playlists::name())
+                reply->writer() << playlists.get_all_properties();
+
+            Exported::bus->send(reply);
+        });
+
+        // Setup method handlers for mpris::Player methods.
+        auto next = [this](const core::dbus::Message::Ptr& msg)
+        {
+            auto sp = current_player.lock();
+
+            if (sp)
+                sp->next();
+
+            Exported::bus->send(core::dbus::Message::make_method_return(msg));
+        };
+        object->install_method_handler<mpris::Player::Next>(next);
+
+        auto previous = [this](const core::dbus::Message::Ptr& msg)
+        {
+            auto sp = current_player.lock();
+
+            if (sp)
+                sp->previous();
+
+            Exported::bus->send(core::dbus::Message::make_method_return(msg));
+        };
+        object->install_method_handler<mpris::Player::Previous>(previous);
+
+        auto pause = [this](const core::dbus::Message::Ptr& msg)
+        {
+            auto sp = current_player.lock();
+
+            if (sp)
+                sp->pause();
+
+            Exported::bus->send(core::dbus::Message::make_method_return(msg));
+        };
+        object->install_method_handler<mpris::Player::Pause>(pause);
+
+        auto stop = [this](const core::dbus::Message::Ptr& msg)
+        {
+            auto sp = current_player.lock();
+
+            if (sp)
+                sp->stop();
+
+            Exported::bus->send(core::dbus::Message::make_method_return(msg));
+        };
+        object->install_method_handler<mpris::Player::Stop>(stop);
+
+        auto play = [this](const core::dbus::Message::Ptr& msg)
+        {
+            auto sp = current_player.lock();
+
+            if (sp)
+                sp->play();
+
+            Exported::bus->send(core::dbus::Message::make_method_return(msg));
+        };
+        object->install_method_handler<mpris::Player::Play>(play);
+
+        auto play_pause = [this](const core::dbus::Message::Ptr& msg)
+        {
+            auto sp = current_player.lock();
+
+            if (sp)
+            {
+                if (sp->playback_status() == core::ubuntu::media::Player::PlaybackStatus::playing)
+                    sp->pause();
+                else if (sp->playback_status() != core::ubuntu::media::Player::PlaybackStatus::null)
+                    sp->play();
+            }
+
+            Exported::bus->send(core::dbus::Message::make_method_return(msg));
+        };
+        object->install_method_handler<mpris::Player::PlayPause>(play_pause);
+    }
+
+    void set_current_player(const std::shared_ptr<core::ubuntu::media::Player>& cp)
+    {
+        unset_current_player();
+
+        if (not cp)
+            return;
+
+        // We will not keep the object alive.
+        current_player = cp;
+
+        // And announce that we can be controlled again.
+        player.properties.can_control->set(false);
+
+        // We wire up player state changes
+        connections.seeked_to = cp->seeked_to().connect([this](std::uint64_t position)
+        {
+            player.signals.seeked_to->emit(position);
+        });
+
+        connections.duration_changed = cp->duration().changed().connect([this](std::uint64_t duration)
+        {
+            player.properties.duration->set(duration);
+        });
+
+        connections.position_changed = cp->position().changed().connect([this](std::uint64_t position)
+        {
+            player.properties.position->set(position);
+        });
+
+        connections.playback_status_changed = cp->playback_status().changed().connect([this](core::ubuntu::media::Player::PlaybackStatus status)
+        {
+            player.properties.playback_status->set(mpris::Player::PlaybackStatus::from(status));
+        });
+
+        connections.loop_status_changed = cp->loop_status().changed().connect([this](core::ubuntu::media::Player::LoopStatus status)
+        {
+            player.properties.loop_status->set(mpris::Player::LoopStatus::from(status));
+        });
+
+        connections.meta_data_changed = cp->meta_data_for_current_track().changed().connect([this](const core::ubuntu::media::Track::MetaData& md)
+        {
+            mpris::Player::Dictionary dict;
+
+            bool has_title = md.count(xesam::Title::name) > 0;
+            bool has_album_name = md.count(xesam::Album::name) > 0;
+            bool has_artist_name = md.count(xesam::Artist::name) > 0;
+
+            if (has_title)
+                dict[xesam::Title::name] = dbus::types::Variant::encode(md.get(xesam::Title::name));
+            if (has_album_name)
+                dict[xesam::Album::name] = dbus::types::Variant::encode(md.get(xesam::Album::name));
+            if (has_artist_name)
+                dict[xesam::Artist::name] = dbus::types::Variant::encode(md.get(xesam::Artist::name));
+
+            dict[mpris::metadata::ArtUrl::name] = dbus::types::Variant::encode(
+                        cover_art_resolver(
+                            has_title ? md.get(xesam::Title::name) : "",
+                            has_album_name ? md.get(xesam::Album::name) : "",
+                            has_artist_name ? md.get(xesam::Artist::name) : ""));
+
+            mpris::Player::Dictionary wrap;
+            wrap[mpris::Player::Properties::Metadata::name()] = dbus::types::Variant::encode(dict);
+
+            player.signals.properties_changed->emit(
+                        std::make_tuple(
+                            dbus::traits::Service<mpris::Player::Properties::Metadata::Interface>::interface_name(),
+                            wrap,
+                            std::vector<std::string>()));
+        });
+    }
+
+    void unset_current_player()
+    {
+        current_player.reset();
+
+        // We disconnect all previous event connections.
+        connections.seeked_to.disconnect();
+        connections.duration_changed.disconnect();
+        connections.position_changed.disconnect();
+        connections.playback_status_changed.disconnect();
+        connections.loop_status_changed.disconnect();
+        connections.meta_data_changed.disconnect();
+
+        // And announce that we cannot be controlled anymore.
+        player.properties.can_control->set(false);
+    }
+
+    dbus::Bus::Ptr bus;
+    dbus::Service::Ptr service;
+    dbus::Object::Ptr object;
+
+    mpris::MediaPlayer2::Skeleton media_player;
+    mpris::Player::Skeleton player;
+    mpris::Playlists::Skeleton playlists;
+
+    // Helper to resolve (title, artist, album) tuples to cover art.
+    core::ubuntu::media::CoverArtResolver cover_art_resolver;
+    // The actual player instance.
+    std::weak_ptr<core::ubuntu::media::Player> current_player;
+    // We track event connections.
+    struct
+    {
+        core::Connection seeked_to
+        {
+            the_empty_signal().connect([](){})
+        };
+        core::Connection duration_changed
+        {
+            the_empty_signal().connect([](){})
+        };
+        core::Connection position_changed
+        {
+            the_empty_signal().connect([](){})
+        };
+        core::Connection playback_status_changed
+        {
+            the_empty_signal().connect([](){})
+        };
+        core::Connection loop_status_changed
+        {
+            the_empty_signal().connect([](){})
+        };
+        core::Connection meta_data_changed
+        {
+            the_empty_signal().connect([](){})
+        };
+    } connections;
+};
+}
+
+#endif // MPRIS_EXPORTED_H_

=== added file 'src/core/media/mutable_player.h'
--- src/core/media/mutable_player.h	1970-01-01 00:00:00 +0000
+++ src/core/media/mutable_player.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,60 @@
+/**
+ * Copyright (C) 2014 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 CORE_UBUNTU_MEDIA_MUTABLE_PLAYER_H_
+#define CORE_UBUNTU_MEDIA_MUTABLE_PLAYER_H_
+
+#include <core/media/player.h>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// A player implementation that provides mutable
+// access to properties and signals to its subclasses.
+class MutablePlayer : public Player
+{
+public:
+    MutablePlayer() = default;
+
+    virtual core::Property<PlaybackStatus>& playback_status() = 0;
+    virtual core::Property<bool>& can_play() = 0;
+    virtual core::Property<bool>& can_pause() = 0;
+    virtual core::Property<bool>& can_seek() = 0;
+    virtual core::Property<bool>& can_go_previous() = 0;
+    virtual core::Property<bool>& can_go_next() = 0;
+    virtual core::Property<bool>& is_video_source() = 0;
+    virtual core::Property<bool>& is_audio_source() = 0;
+    virtual core::Property<Track::MetaData>& meta_data_for_current_track() = 0;
+    virtual core::Property<PlaybackRate>& minimum_playback_rate() = 0;
+    virtual core::Property<PlaybackRate>& maximum_playback_rate() = 0;
+    virtual core::Property<int64_t>& position() = 0;
+    virtual core::Property<int64_t>& duration() = 0;
+    virtual core::Property<Orientation>& orientation() = 0;
+
+    virtual core::Signal<int64_t>& seeked_to() = 0;
+    virtual core::Signal<void>& end_of_stream() = 0;
+    virtual core::Signal<video::Dimensions>& video_dimension_changed() = 0;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_MUTABLE_PLAYER_H_

=== modified file 'src/core/media/player.cpp'
--- src/core/media/player.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/player.cpp	2014-11-19 10:23:50 +0000
@@ -29,13 +29,7 @@
 
 const media::Player::Configuration& media::Player::Client::default_configuration()
 {
-    static const media::Player::Configuration config
-    {
-        std::string{""},
-        0,
-        nullptr,
-        nullptr
-    };
+    static const media::Player::Configuration config{core::dbus::types::ObjectPath{"/"}, 0};
     return config;
 }
 

=== modified file 'src/core/media/player_configuration.h'
--- src/core/media/player_configuration.h	2014-09-09 10:28:32 +0000
+++ src/core/media/player_configuration.h	2014-11-19 10:23:50 +0000
@@ -20,22 +20,16 @@
 
 #include <core/media/player.h>
 
-#include <core/dbus/bus.h>
-#include <core/dbus/object.h>
+#include <core/dbus/types/object_path.h>
 
 // Our internal structure for handing down parameters from the skeleton
 // to the implementation in a way that is opaque to the client.
 struct core::ubuntu::media::Player::Configuration
 {
-    // An identifier that is helpful in referencing the player instance
-    // across multiple services.
-    std::string identity;
+    // Object path for the new player instance.
+    core::dbus::types::ObjectPath path;
     // Unique key for identifying the session.
     core::ubuntu::media::Player::PlayerKey key;
-    // The bus connection to expose objects on.
-    std::shared_ptr<core::dbus::Bus> bus;
-    // The actual session object representing a player instance.
-    std::shared_ptr<core::dbus::Object> session;
 };
 
 #endif // CORE_UBUNTU_MEDIA_PLAYER_CLIENT_CONFIGURATION_H_

=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/player_implementation.cpp	2014-11-19 10:23:50 +0000
@@ -25,8 +25,6 @@
 #include "engine.h"
 #include "track_list_implementation.h"
 
-#include "gstreamer/engine.h"
-
 #include <memory>
 #include <exception>
 #include <iostream>
@@ -55,11 +53,11 @@
           config(config),
           display_state_lock(config.power_state_controller->display_state_lock()),
           system_state_lock(config.power_state_controller->system_state_lock()),
-          engine(std::make_shared<gstreamer::Engine>()),
-          track_list(
+          engine(config.engine),
+          /*track_list(
               new media::TrackListImplementation(
                   config.session->path().as_string() + "/TrackList",
-                  engine->meta_data_extractor())),
+                  engine->meta_data_extractor())),*/
           system_wakelock_count(0),
           display_wakelock_count(0),
           previous_state(Engine::State::stopped),
@@ -103,7 +101,7 @@
                 parent->playback_status().set(media::Player::ready);
                 if (previous_state == Engine::State::playing)
                 {
-                    timeout(4000, true, make_clear_wakelock_functor());
+                    timeout(config.default_timeout_for_holding_to_power_state_locks.count(), config.timeouts_are_async, make_clear_wakelock_functor());
                 }
                 break;
             }
@@ -122,7 +120,7 @@
                 parent->playback_status().set(media::Player::stopped);
                 if (previous_state ==  Engine::State::playing)
                 {
-                    timeout(4000, true, make_clear_wakelock_functor());
+                    timeout(config.default_timeout_for_holding_to_power_state_locks.count(), config.timeouts_are_async, make_clear_wakelock_functor());
                 }
                 break;
             }
@@ -131,7 +129,7 @@
                 parent->playback_status().set(media::Player::paused);
                 if (previous_state == Engine::State::playing)
                 {
-                    timeout(4000, true, make_clear_wakelock_functor());
+                    timeout(config.default_timeout_for_holding_to_power_state_locks.count(), config.timeouts_are_async, make_clear_wakelock_functor());
                 }
                 break;
             }
@@ -244,7 +242,7 @@
     media::power::StateController::Lock<media::power::DisplayState>::Ptr display_state_lock;
     media::power::StateController::Lock<media::power::SystemState>::Ptr system_state_lock;
 
-    std::shared_ptr<Engine> engine;
+    media::Engine::Ptr engine;
     std::shared_ptr<TrackListImplementation> track_list;
     std::atomic<int> system_wakelock_count;
     std::atomic<int> display_wakelock_count;
@@ -254,16 +252,7 @@
 };
 
 media::PlayerImplementation::PlayerImplementation(const media::PlayerImplementation::Configuration& config)
-    : media::PlayerSkeleton
-      {
-          media::PlayerSkeleton::Configuration
-          {
-              config.bus,
-              config.session,
-              config.identity
-          }
-      },
-      d{std::make_shared<Private>(this, config)}
+    : d{std::make_shared<Private>(this, config)}
 {
     // Initialize default values for Player interface properties
     can_play().set(true);

=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2014-11-19 10:23:50 +0000
+++ src/core/media/player_implementation.h	2014-11-19 10:23:50 +0000
@@ -19,9 +19,10 @@
 #ifndef CORE_UBUNTU_MEDIA_PLAYER_IMPLEMENTATION_H_
 #define CORE_UBUNTU_MEDIA_PLAYER_IMPLEMENTATION_H_
 
-#include "player_skeleton.h"
+#include "base_player.h"
 
 #include "client_death_observer.h"
+#include "engine.h"
 #include "power/state_controller.h"
 
 #include <memory>
@@ -35,19 +36,20 @@
 class Engine;
 class Service;
 
-class PlayerImplementation : public PlayerSkeleton
+class PlayerImplementation : public BasePlayer
 {
 public:
     // All creation time arguments go here
     struct Configuration
     {
-        std::string identity;
-        std::shared_ptr<core::dbus::Bus> bus;
-        std::shared_ptr<core::dbus::Object> session;
-        std::shared_ptr<Service> service;
+        // A unique player key.
         PlayerKey key;
-
-        // Functional dependencies
+        // Whether timeouts should be executed asynchronously.
+        bool timeouts_are_async;
+        // The default timeout we use for holding to power state locks.
+        std::chrono::milliseconds default_timeout_for_holding_to_power_state_locks;
+        // Functional dependencies.
+        Engine::Ptr engine;
         ClientDeathObserver::Ptr client_death_observer;
         power::StateController::Ptr power_state_controller;
     };

=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/player_skeleton.cpp	2014-11-19 10:23:50 +0000
@@ -41,91 +41,164 @@
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
 
+namespace
+{
+mpris::Player::Skeleton::Configuration::Defaults make_configuration_defaults(const std::shared_ptr<media::Player>& impl)
+{
+    mpris::Player::Skeleton::Configuration::Defaults defaults;
+    defaults.can_play = impl->can_play();
+    defaults.can_pause = impl->can_pause();
+    defaults.can_seek = impl->can_seek();
+    defaults.can_go_next = impl->can_go_next();
+    defaults.can_go_previous = impl->can_go_previous();
+    defaults.is_video_source = impl->is_video_source();
+    defaults.is_audio_source = impl->is_audio_source();
+    defaults.playback_status = mpris::Player::PlaybackStatus::from(impl->playback_status());
+    defaults.typed_playback_status = impl->playback_status();
+    defaults.loop_status = mpris::Player::LoopStatus::from(impl->loop_status());
+    defaults.typed_loop_status = impl->loop_status();
+    defaults.playback_rate = impl->playback_rate();
+    defaults.shuffle = impl->is_shuffle();
+    defaults.playback_rate = impl->playback_rate();
+    defaults.typed_meta_data = impl->meta_data_for_current_track();
+    defaults.volume = impl->volume();
+    defaults.position = impl->position();
+    defaults.duration = impl->duration();
+    defaults.minimum_rate = impl->minimum_playback_rate();
+    defaults.maximum_rate = impl->maximum_playback_rate();
+    defaults.orientation = impl->orientation();
+
+    return defaults;
+}
+}
 struct media::PlayerSkeleton::Private
 {
-    Private(media::PlayerSkeleton* player,
-            const std::string& identity,
-            const std::shared_ptr<core::dbus::Bus>& bus,
-            const std::shared_ptr<core::dbus::Object>& session)
-        : impl(player),
-          identity(identity),
-          bus(bus),
-          object(session),
-          apparmor_session(nullptr),
-          dbus_stub{bus},
-          skeleton{mpris::Player::Skeleton::Configuration{bus, session, mpris::Player::Skeleton::Configuration::Defaults{}}},
-          signals
-          {
-              skeleton.signals.seeked_to,
-              skeleton.signals.end_of_stream,
-              skeleton.signals.playback_status_changed,
-              skeleton.signals.video_dimension_changed
+    Private(media::PlayerSkeleton* parent,
+            const media::PlayerSkeleton::Configuration& config)
+        : parent(parent),
+          configuration(config),
+          dbus_stub{configuration.bus},
+          skeleton
+          {
+              mpris::Player::Skeleton::Configuration
+              {
+                  configuration.bus,
+                  configuration.session,
+                  make_configuration_defaults(configuration.impl)
+              }
+          },
+          connections
+          {
+              configuration.impl->seeked_to().connect([this](std::uint64_t value)
+              {
+                  skeleton.signals.seeked_to->emit(value);
+              }),
+              configuration.impl->end_of_stream().connect([this]()
+              {
+                  skeleton.signals.end_of_stream->emit();
+              }),
+              configuration.impl->playback_status_changed().connect([this](const media::Player::PlaybackStatus& status)
+              {
+                  skeleton.signals.playback_status_changed->emit(status);
+              }),
+              configuration.impl->video_dimension_changed().connect([this](const media::video::Dimensions& mask)
+              {
+                  skeleton.signals.video_dimension_changed->emit(mask);
+              })
           }
     {
+        // We wire properties together at this point. Whenever something changes
+        // on the implementation, we forward the new value to the skeleton.
+        configuration.impl->can_play() | *skeleton.properties.can_play;
+        configuration.impl->can_pause() | *skeleton.properties.can_pause;
+        configuration.impl->can_seek() | *skeleton.properties.can_seek;
+        configuration.impl->can_go_previous() | *skeleton.properties.can_go_previous;
+        configuration.impl->can_go_next() | *skeleton.properties.can_go_next;
+        configuration.impl->is_video_source() | *skeleton.properties.is_video_source;
+        configuration.impl->is_audio_source() | *skeleton.properties.is_audio_source;
+        configuration.impl->playback_status() | *skeleton.properties.typed_playback_status;
+        configuration.impl->loop_status() | *skeleton.properties.typed_loop_status;
+        configuration.impl->playback_rate() | *skeleton.properties.playback_rate;
+        configuration.impl->is_shuffle() | *skeleton.properties.is_shuffle;
+        configuration.impl->meta_data_for_current_track() | *skeleton.properties.typed_meta_data_for_current_track;
+        configuration.impl->volume() | *skeleton.properties.volume;
+        configuration.impl->minimum_playback_rate() | *skeleton.properties.minimum_playback_rate;
+        configuration.impl->maximum_playback_rate() | *skeleton.properties.maximum_playback_rate;
+        configuration.impl->position() | *skeleton.properties.position;
+        configuration.impl->duration() | *skeleton.properties.duration;
+        configuration.impl->audio_stream_role() | *skeleton.properties.audio_stream_role;
+        configuration.impl->orientation() | *skeleton.properties.orientation;
+        // And vice versa. Please note that we will not enter an infinite loop as Property<>
+        // only invokes changed handlers if the new value is actually different from the old value.
+        *skeleton.properties.typed_loop_status | configuration.impl->loop_status();
+        *skeleton.properties.playback_rate | configuration.impl->playback_rate();
+        *skeleton.properties.is_shuffle | configuration.impl->is_shuffle();
+        *skeleton.properties.volume | configuration.impl->volume();
+        *skeleton.properties.audio_stream_role | configuration.impl->audio_stream_role();
     }
 
     void handle_next(const core::dbus::Message::Ptr& msg)
     {
-        impl->next();
+        parent->next();
         auto reply = dbus::Message::make_method_return(msg);
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     void handle_previous(const core::dbus::Message::Ptr& msg)
     {
-        impl->previous();
+        parent->previous();
         auto reply = dbus::Message::make_method_return(msg);
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     void handle_pause(const core::dbus::Message::Ptr& msg)
     {
-        impl->pause();
+        parent->pause();
         auto reply = dbus::Message::make_method_return(msg);
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     void handle_stop(const core::dbus::Message::Ptr& msg)
     {
-        impl->stop();
+        parent->stop();
         auto reply = dbus::Message::make_method_return(msg);
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     void handle_play(const core::dbus::Message::Ptr& msg)
     {
-        impl->play();
+        parent->play();
         auto reply = dbus::Message::make_method_return(msg);
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     void handle_play_pause(const core::dbus::Message::Ptr& msg)
     {
-        switch(impl->playback_status().get())
+        switch(parent->playback_status().get())
         {
         case core::ubuntu::media::Player::PlaybackStatus::ready:
         case core::ubuntu::media::Player::PlaybackStatus::paused:
         case core::ubuntu::media::Player::PlaybackStatus::stopped:
-            impl->play();
+            parent->play();
             break;
         case core::ubuntu::media::Player::PlaybackStatus::playing:
-            impl->pause();
+            parent->pause();
             break;
         default:
             break;
         }
 
-        bus->send(dbus::Message::make_method_return(msg));
+        configuration.bus->send(dbus::Message::make_method_return(msg));
     }
 
     void handle_seek(const core::dbus::Message::Ptr& in)
     {
         uint64_t ticks;
         in->reader() >> ticks;
-        impl->seek_to(std::chrono::microseconds(ticks));
+        parent->seek_to(std::chrono::microseconds(ticks));
 
         auto reply = dbus::Message::make_method_return(in);
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     void handle_set_position(const core::dbus::Message::Ptr&)
@@ -141,7 +214,7 @@
 
         try
         {
-            impl->create_gl_texture_video_sink(texture_id);
+            parent->create_gl_texture_video_sink(texture_id);
             reply = dbus::Message::make_method_return(in);
         }
         catch (const media::Player::Error::OutOfProcessBufferStreamingNotSupported& e)
@@ -159,7 +232,7 @@
                         std::string{});
         }
 
-        bus->send(reply);
+        configuration.bus->send(reply);
     }
 
     bool does_client_have_access(const std::string& context, const std::string& uri)
@@ -241,8 +314,8 @@
     void handle_key(const core::dbus::Message::Ptr& in)
     {
         auto reply = dbus::Message::make_method_return(in);
-        reply->writer() << impl->key();
-        bus->send(reply);
+        reply->writer() << parent->key();
+        configuration.bus->send(reply);
     }
 
     void handle_open_uri(const core::dbus::Message::Ptr& in)
@@ -255,122 +328,65 @@
             bool have_access = does_client_have_access(profile, uri);
 
             auto reply = dbus::Message::make_method_return(in);
-            reply->writer() << (have_access ? impl->open_uri(uri) : false);
+            reply->writer() << (have_access ? parent->open_uri(uri) : false);
 
-            bus->send(reply);
+            configuration.bus->send(reply);
         });
     }
 
-    template<typename Property>
-    void on_property_value_changed(
-            const typename Property::ValueType& value,
-            const dbus::Signal
-            <
-                core::dbus::interfaces::Properties::Signals::PropertiesChanged,
-                core::dbus::interfaces::Properties::Signals::PropertiesChanged::ArgumentType
-            >::Ptr& signal)
-    {
-        typedef std::map<std::string, dbus::types::Variant> Dictionary;
-
-        static const std::vector<std::string> the_empty_list_of_invalidated_properties;
-
-        Dictionary dict; dict[Property::name()] = dbus::types::Variant::encode(value);
-
-        signal->emit(std::make_tuple(
-                        dbus::traits::Service<typename Property::Interface>::interface_name(),
-                        dict,
-                        the_empty_list_of_invalidated_properties));
-    }
-
-    media::PlayerSkeleton* impl;
-    std::string identity;
-    dbus::Bus::Ptr bus;
-    dbus::Object::Ptr object;
-    dbus::Object::Ptr apparmor_session;
-
+    media::PlayerSkeleton* parent;
+    media::PlayerSkeleton::Configuration configuration;
     org::freedesktop::dbus::DBus::Stub dbus_stub;
 
     mpris::Player::Skeleton skeleton;
-
-    struct Signals
+    // Event connections go here.
+    struct
     {
-        typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
-        typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
-        typedef core::dbus::Signal<mpris::Player::Signals::PlaybackStatusChanged, mpris::Player::Signals::PlaybackStatusChanged::ArgumentType> DBusPlaybackStatusChangedSignal;
-        typedef core::dbus::Signal<mpris::Player::Signals::VideoDimensionChanged, mpris::Player::Signals::VideoDimensionChanged::ArgumentType> DBusVideoDimensionChangedSignal;
-
-        Signals(const std::shared_ptr<DBusSeekedToSignal>& remote_seeked,
-                const std::shared_ptr<DBusEndOfStreamSignal>& remote_eos,
-                const std::shared_ptr<DBusPlaybackStatusChangedSignal>& remote_playback_status_changed,
-                const std::shared_ptr<DBusVideoDimensionChangedSignal>& remote_video_dimension_changed)
-        {
-            seeked_to.connect([remote_seeked](std::uint64_t value)
-            {
-                remote_seeked->emit(value);
-            });
-
-            end_of_stream.connect([remote_eos]()
-            {
-                remote_eos->emit();
-            });
-
-            playback_status_changed.connect([remote_playback_status_changed](const media::Player::PlaybackStatus& status)
-            {
-                remote_playback_status_changed->emit(status);
-            });
-
-            video_dimension_changed.connect([remote_video_dimension_changed](const media::video::Dimensions& mask)
-            {
-                remote_video_dimension_changed->emit(mask);
-            });
-        }
-
-        core::Signal<int64_t> seeked_to;
-        core::Signal<void> end_of_stream;
-        core::Signal<media::Player::PlaybackStatus> playback_status_changed;
-        core::Signal<media::video::Dimensions> video_dimension_changed;
-    } signals;
-
+        core::ScopedConnection seeked_to;
+        core::ScopedConnection end_of_stream;
+        core::ScopedConnection playback_status_changed;
+        core::ScopedConnection video_dimension_changed;
+    } connections;
 };
 
 media::PlayerSkeleton::PlayerSkeleton(const media::PlayerSkeleton::Configuration& config)
-        : d(new Private{this, config.identity, config.bus, config.session})
+        : d(new Private{this, config})
 {
     // Setup method handlers for mpris::Player methods.
     auto next = std::bind(&Private::handle_next, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::Next>(next);
+    d->configuration.session->install_method_handler<mpris::Player::Next>(next);
 
     auto previous = std::bind(&Private::handle_previous, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::Previous>(previous);
+    d->configuration.session->install_method_handler<mpris::Player::Previous>(previous);
 
     auto pause = std::bind(&Private::handle_pause, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::Pause>(pause);
+    d->configuration.session->install_method_handler<mpris::Player::Pause>(pause);
 
     auto stop = std::bind(&Private::handle_stop, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::Stop>(stop);
+    d->configuration.session->install_method_handler<mpris::Player::Stop>(stop);
 
     auto play = std::bind(&Private::handle_play, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::Play>(play);
+    d->configuration.session->install_method_handler<mpris::Player::Play>(play);
 
     auto play_pause = std::bind(&Private::handle_play_pause, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::PlayPause>(play_pause);
+    d->configuration.session->install_method_handler<mpris::Player::PlayPause>(play_pause);
 
     auto seek = std::bind(&Private::handle_seek, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::Seek>(seek);
+    d->configuration.session->install_method_handler<mpris::Player::Seek>(seek);
 
     auto set_position = std::bind(&Private::handle_set_position, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::SetPosition>(set_position);
+    d->configuration.session->install_method_handler<mpris::Player::SetPosition>(set_position);
 
     auto open_uri = std::bind(&Private::handle_open_uri, d, std::placeholders::_1);
-    d->object->install_method_handler<mpris::Player::OpenUri>(open_uri);
+    d->configuration.session->install_method_handler<mpris::Player::OpenUri>(open_uri);
 
     // All the method handlers that exceed the mpris spec go here.
-    d->object->install_method_handler<mpris::Player::CreateVideoSink>(
+    d->configuration.session->install_method_handler<mpris::Player::CreateVideoSink>(
         std::bind(&Private::handle_create_video_sink,
                   d,
                   std::placeholders::_1));
 
-    d->object->install_method_handler<mpris::Player::Key>(
+    d->configuration.session->install_method_handler<mpris::Player::Key>(
         std::bind(&Private::handle_key,
                   d,
                   std::placeholders::_1));
@@ -380,17 +396,67 @@
 {
    // The session object may outlive the private instance
    // so uninstall all method handlers.
-   d->object->uninstall_method_handler<mpris::Player::Next>();
-   d->object->uninstall_method_handler<mpris::Player::Previous>();
-   d->object->uninstall_method_handler<mpris::Player::Pause>();
-   d->object->uninstall_method_handler<mpris::Player::Stop>();
-   d->object->uninstall_method_handler<mpris::Player::Play>();
-   d->object->uninstall_method_handler<mpris::Player::PlayPause>();
-   d->object->uninstall_method_handler<mpris::Player::Seek>();
-   d->object->uninstall_method_handler<mpris::Player::SetPosition>();
-   d->object->uninstall_method_handler<mpris::Player::OpenUri>();
-   d->object->uninstall_method_handler<mpris::Player::CreateVideoSink>();
-   d->object->uninstall_method_handler<mpris::Player::Key>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Next>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Previous>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Pause>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Stop>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Play>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::PlayPause>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Seek>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::SetPosition>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::OpenUri>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::CreateVideoSink>();
+   d->configuration.session->uninstall_method_handler<mpris::Player::Key>();
+}
+
+std::shared_ptr<media::TrackList> media::PlayerSkeleton::track_list()
+{
+    return d->configuration.impl->track_list();
+}
+
+media::Player::PlayerKey media::PlayerSkeleton::key() const
+{
+    return d->configuration.impl->key();
+}
+
+media::video::Sink::Ptr media::PlayerSkeleton::create_gl_texture_video_sink(std::uint32_t texture_id)
+{
+    return d->configuration.impl->create_gl_texture_video_sink(texture_id);
+}
+
+bool media::PlayerSkeleton::open_uri(const Track::UriType& uri)
+{
+    return d->configuration.impl->open_uri(uri);
+}
+
+void media::PlayerSkeleton::next()
+{
+    return d->configuration.impl->next();
+}
+
+void media::PlayerSkeleton::previous()
+{
+    return d->configuration.impl->previous();
+}
+
+void media::PlayerSkeleton::play()
+{
+    return d->configuration.impl->play();
+}
+
+void media::PlayerSkeleton::pause()
+{
+    return d->configuration.impl->pause();
+}
+
+void media::PlayerSkeleton::stop()
+{
+    return d->configuration.impl->stop();
+}
+
+void media::PlayerSkeleton::seek_to(const std::chrono::microseconds& offset)
+{
+    return d->configuration.impl->seek_to(offset);
 }
 
 const core::Property<bool>& media::PlayerSkeleton::can_play() const
@@ -488,6 +554,26 @@
     return *d->skeleton.properties.maximum_playback_rate;
 }
 
+const core::Signal<int64_t>& media::PlayerSkeleton::seeked_to() const
+{
+    return d->configuration.impl->seeked_to();
+}
+
+const core::Signal<void>& media::PlayerSkeleton::end_of_stream() const
+{
+    return d->configuration.impl->end_of_stream();
+}
+
+core::Signal<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status_changed()
+{
+    return d->configuration.impl->playback_status_changed();
+}
+
+const core::Signal<media::video::Dimensions>& media::PlayerSkeleton::video_dimension_changed() const
+{
+    return d->configuration.impl->video_dimension_changed();
+}
+
 core::Property<media::Player::LoopStatus>& media::PlayerSkeleton::loop_status()
 {
     return *d->skeleton.properties.typed_loop_status;
@@ -508,112 +594,7 @@
     return *d->skeleton.properties.volume;
 }
 
-core::Property<int64_t>& media::PlayerSkeleton::position()
-{
-    return *d->skeleton.properties.position;
-}
-
-core::Property<int64_t>& media::PlayerSkeleton::duration()
-{
-    return *d->skeleton.properties.duration;
-}
-
 core::Property<media::Player::AudioStreamRole>& media::PlayerSkeleton::audio_stream_role()
 {
     return *d->skeleton.properties.audio_stream_role;
 }
-
-core::Property<media::Player::Orientation>& media::PlayerSkeleton::orientation()
-{
-    return *d->skeleton.properties.orientation;
-}
-
-core::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status()
-{
-    return *d->skeleton.properties.typed_playback_status;
-}
-
-core::Property<bool>& media::PlayerSkeleton::can_play()
-{
-    return *d->skeleton.properties.can_play;
-}
-
-core::Property<bool>& media::PlayerSkeleton::can_pause()
-{
-    return *d->skeleton.properties.can_pause;
-}
-
-core::Property<bool>& media::PlayerSkeleton::can_seek()
-{
-    return *d->skeleton.properties.can_seek;
-}
-
-core::Property<bool>& media::PlayerSkeleton::can_go_previous()
-{
-    return *d->skeleton.properties.can_go_previous;
-}
-
-core::Property<bool>& media::PlayerSkeleton::can_go_next()
-{
-    return *d->skeleton.properties.can_go_next;
-}
-
-core::Property<bool>& media::PlayerSkeleton::is_video_source()
-{
-    return *d->skeleton.properties.is_video_source;
-}
-
-core::Property<bool>& media::PlayerSkeleton::is_audio_source()
-{
-    return *d->skeleton.properties.is_audio_source;
-}
-
-core::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track()
-{
-    return *d->skeleton.properties.typed_meta_data_for_current_track;
-}
-
-core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::minimum_playback_rate()
-{
-    return *d->skeleton.properties.minimum_playback_rate;
-}
-
-core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::maximum_playback_rate()
-{
-    return *d->skeleton.properties.maximum_playback_rate;
-}
-
-const core::Signal<int64_t>& media::PlayerSkeleton::seeked_to() const
-{
-    return d->signals.seeked_to;
-}
-
-core::Signal<int64_t>& media::PlayerSkeleton::seeked_to()
-{
-    return d->signals.seeked_to;
-}
-
-const core::Signal<void>& media::PlayerSkeleton::end_of_stream() const
-{
-    return d->signals.end_of_stream;
-}
-
-core::Signal<void>& media::PlayerSkeleton::end_of_stream()
-{
-    return d->signals.end_of_stream;
-}
-
-core::Signal<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status_changed()
-{
-    return d->signals.playback_status_changed;
-}
-
-const core::Signal<media::video::Dimensions>& media::PlayerSkeleton::video_dimension_changed() const
-{
-    return d->signals.video_dimension_changed;
-}
-
-core::Signal<media::video::Dimensions>& media::PlayerSkeleton::video_dimension_changed()
-{
-    return d->signals.video_dimension_changed;
-}

=== modified file 'src/core/media/player_skeleton.h'
--- src/core/media/player_skeleton.h	2014-11-19 10:23:50 +0000
+++ src/core/media/player_skeleton.h	2014-11-19 10:23:50 +0000
@@ -22,6 +22,7 @@
 
 #include <core/media/player.h>
 
+#include "mutable_player.h"
 #include "player_traits.h"
 
 #include "mpris/player.h"
@@ -42,8 +43,33 @@
 class PlayerSkeleton : public core::ubuntu::media::Player
 {
   public:
+    // All creation time arguments go here.
+    struct Configuration
+    {
+        // The actual Player implementation.
+        std::shared_ptr<Player> impl;
+        // The bus connection we are associated with.
+        std::shared_ptr<core::dbus::Bus> bus;
+        // The session object that we want to expose the skeleton upon.
+        std::shared_ptr<core::dbus::Object> session;
+    };
+
+    PlayerSkeleton(const Configuration& configuration);
     ~PlayerSkeleton();
 
+    virtual std::shared_ptr<TrackList> track_list() override;
+    virtual PlayerKey key() const override;
+
+    virtual video::Sink::Ptr create_gl_texture_video_sink(std::uint32_t texture_id) override;
+
+    virtual bool open_uri(const Track::UriType& uri) override;
+    virtual void next() override;
+    virtual void previous() override;
+    virtual void play() override;
+    virtual void pause() override;
+    virtual void stop() override;
+    virtual void seek_to(const std::chrono::microseconds& offset) override;
+
     virtual const core::Property<bool>& can_play() const;
     virtual const core::Property<bool>& can_pause() const;
     virtual const core::Property<bool>& can_seek() const;
@@ -75,42 +101,6 @@
     virtual core::Signal<PlaybackStatus>& playback_status_changed();
     virtual const core::Signal<video::Dimensions>& video_dimension_changed() const;
 
-protected:
-    // All creation time arguments go here.
-    struct Configuration
-    {
-        // The bus connection we are associated with.
-        std::shared_ptr<core::dbus::Bus> bus;
-        // The session object that we want to expose the skeleton upon.
-        std::shared_ptr<core::dbus::Object> session;
-        // Our identity, an identifier we pass out to other parts of the system.
-        // Defaults to the short app id (${PKG_NAME}_${APP}).
-        std::string identity;
-    };
-
-    PlayerSkeleton(const Configuration& configuration);
-
-    // These properties are not exposed to the client, but still need to be
-    // able to be settable from within the Player:
-    virtual core::Property<PlaybackStatus>& playback_status();
-    virtual core::Property<bool>& can_play();
-    virtual core::Property<bool>& can_pause();
-    virtual core::Property<bool>& can_seek();
-    virtual core::Property<bool>& can_go_previous();
-    virtual core::Property<bool>& can_go_next();
-    virtual core::Property<bool>& is_video_source();
-    virtual core::Property<bool>& is_audio_source();
-    virtual core::Property<Track::MetaData>& meta_data_for_current_track();
-    virtual core::Property<PlaybackRate>& minimum_playback_rate();
-    virtual core::Property<PlaybackRate>& maximum_playback_rate();
-    virtual core::Property<int64_t>& position();
-    virtual core::Property<int64_t>& duration();
-    virtual core::Property<Orientation>& orientation();
-
-    virtual core::Signal<int64_t>& seeked_to();
-    virtual core::Signal<void>& end_of_stream();
-    virtual core::Signal<video::Dimensions>& video_dimension_changed();
-
   private:
     struct Private;
     std::shared_ptr<Private> d;

=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2014-11-19 10:23:50 +0000
+++ src/core/media/player_stub.h	2014-11-19 10:23:50 +0000
@@ -87,7 +87,7 @@
     virtual core::Signal<PlaybackStatus>& playback_status_changed();
     virtual const core::Signal<video::Dimensions>& video_dimension_changed() const;
 
-  private:
+private:
     struct Private;
     std::unique_ptr<Private> d;
 };

=== modified file 'src/core/media/power/state_controller.cpp'
--- src/core/media/power/state_controller.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/power/state_controller.cpp	2014-11-19 10:23:50 +0000
@@ -300,3 +300,33 @@
 {
     return std::make_shared<impl::StateController>(external_services);
 }
+
+// Pretty prints the given state to the given output stream.
+std::ostream& media::power::operator<<(std::ostream& out, media::power::DisplayState state)
+{
+    switch (state)
+    {
+    case media::power::DisplayState::off:
+        return out << "DisplayState::off";
+    case media::power::DisplayState::on:
+        return out << "DisplayState::on";
+    }
+
+    return out;
+}
+
+// Pretty prints the given state to the given output stream.
+std::ostream& media::power::operator<<(std::ostream& out, media::power::SystemState state)
+{
+    switch (state)
+    {
+    case media::power::SystemState::suspend:
+        return out << "SystemState::suspend";
+    case media::power::SystemState::active:
+        return out << "SystemState::active";
+    case media::power::SystemState::blank_on_proximity:
+        return out << "SystemState::blank_on_proximity";
+    }
+
+    return out;
+}

=== modified file 'src/core/media/power/state_controller.h'
--- src/core/media/power/state_controller.h	2014-11-19 10:23:50 +0000
+++ src/core/media/power/state_controller.h	2014-11-19 10:23:50 +0000
@@ -95,6 +95,11 @@
 // Creates a StateController instance that connects to the platform default
 // services to control system and display power states.
 StateController::Ptr make_platform_default_state_controller(core::ubuntu::media::helper::ExternalServices&);
+
+// Pretty prints the given state to the given output stream.
+std::ostream& operator<<(std::ostream&, DisplayState);
+// Pretty prints the given state to the given output stream.
+std::ostream& operator<<(std::ostream&, SystemState);
 }
 }
 }

=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/server/server.cpp	2014-11-19 10:23:50 +0000
@@ -22,7 +22,12 @@
 
 #include <core/posix/signal.h>
 
+#include "core/media/hashed_keyed_player_store.h"
 #include "core/media/service_implementation.h"
+#include "core/media/service_skeleton.h"
+#include "core/media/service_traits.h"
+
+#include "core/media/gstreamer/engine_factory.h"
 
 #include <iostream>
 
@@ -98,31 +103,52 @@
         }
     };
 
-    // We assemble the configuration for executing the service now.
-    media::ServiceImplementation::Configuration service_config
+    // We use a simple, hashed store for our player intances.
+    auto player_store = std::make_shared<media::HashedKeyedPlayerStore>();
+    // We assemble the configuration for executing the service now.    
+    media::ServiceImplementation::Configuration impl_config
     {
         [&external_services](core::ubuntu::media::Task task)
         {
             external_services.io_service.post(task);
         },
+        player_store,
         media::platform_default_client_death_observer(),
+        media::gstreamer::engine_factory(),
         media::make_platform_default_recorder_observer(),
         media::power::make_platform_default_state_controller(external_services),
         media::power::make_platform_default_battery_observer(external_services),
         media::telephony::make_platform_default_call_monitor()
     };
-
-    auto service = std::make_shared<media::ServiceImplementation>(service_config);
+    auto impl = media::ServiceImplementation::create(impl_config);
+
+    // And we assemble the skeleton.
+    auto bus = std::make_shared<core::dbus::Bus>(core::dbus::WellKnownBus::session);
+    bus->install_executor(core::dbus::asio::make_executor(bus));
+
+    auto service = core::dbus::Service::add_service<media::Service>(bus);
+    auto object = service->add_object_for_path(
+                core::dbus::types::ObjectPath{core::dbus::traits::Service<media::Service>::object_path()});
+    media::ServiceSkeleton::Configuration skeleton_config
+    {
+        impl,
+        bus,
+        service,
+        object,
+        player_store,
+        media::always_missing_cover_art_resolver()
+    };
+    auto skeleton = std::make_shared<media::ServiceSkeleton>(skeleton_config);
 
     std::thread service_worker
     {
-        [&shutdown_requested, service]()
+        [&shutdown_requested, bus]()
         {
             while (not shutdown_requested)
             {
                 try
                 {
-                    service->run();
+                    bus->run();
                 }
                 catch (const std::exception& e)
                 {
@@ -144,7 +170,7 @@
 
     // And stop execution of helper and actual service.
     external_services.stop();
-    service->stop();
+    bus->stop();
 
     if (external_services_worker.joinable())
         external_services_worker.join();

=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2014-11-19 10:23:50 +0000
+++ src/core/media/service_implementation.cpp	2014-11-19 10:23:50 +0000
@@ -38,10 +38,11 @@
 struct media::ServiceImplementation::Private
 {
     Private(ServiceImplementation& parent, const media::ServiceImplementation::Configuration& config)
-        : resume_key{std::numeric_limits<std::uint32_t>::max()},
-          parent{parent},
+        : parent{parent},
           dispatcher{config.dispatcher},
+          player_store{config.player_store},
           display_state_lock{config.power_state_controller->display_state_lock()},
+          engine_factory{config.engine_factory},
           power_state_controller{config.power_state_controller},
           power_state_observer{config.power_state_observer},
           call_monitor(config.call_monitor),
@@ -64,19 +65,29 @@
                   }
               }),
               power_state_observer->is_warning_active().changed().connect([this](bool notifying)
-              {
-                  // If the low battery level notification is no longer being displayed,
-                  // resume what the user was previously playing
-                  if (!notifying)
-                      this->parent.resume_multimedia_session();
+              {                  
+                  if (notifying)
+                  {
+                      // We likely will have received a change in battery power level
+                      // prior to this notification. However, let's be safe and just
+                      // pause all multimedia sessions here. It's a no-op if they are
+                      // already paused.
+                      this->parent.pause_all_multimedia_sessions();
+                  }
+                  else
+                  {
+                      // If the low battery level notification is no longer being displayed,
+                      // resume what the user was previously playing
+                      this->parent.resume_paused_multimedia_sessions();
+                  }
               }),
               call_monitor->on_call_state_changed().connect([this](media::telephony::CallMonitor::State state) {
                   switch (state) {
                   case media::telephony::CallMonitor::OffHook:
-                      this->parent.pause_all_multimedia_sessions();
+                      this->parent.resume_paused_multimedia_sessions();
                       break;
                   case media::telephony::CallMonitor::OnHook:
-                      this->parent.resume_paused_multimedia_sessions();
+                      this->parent.pause_all_multimedia_sessions();
                       break;
                   }
               }),
@@ -103,17 +114,15 @@
             display_state_lock->request_release(media::power::DisplayState::on);
             break;
         }
-    }
-
-    // This holds the key of the multimedia role Player instance that was paused
-    // when the battery level reached 10% or 5%
-    media::Player::PlayerKey resume_key;
+    }    
 
     media::ServiceImplementation& parent;
 
     media::Dispatcher dispatcher;
+    media::KeyedPlayerStore::Ptr player_store;
 
     media::power::StateController::Lock<media::power::DisplayState>::Ptr display_state_lock;
+    media::EngineFactory engine_factory;
     media::power::StateController::Ptr power_state_controller;
     media::power::BatteryObserver::Ptr power_state_observer;
     media::telephony::CallMonitor::Ptr call_monitor;
@@ -131,6 +140,12 @@
     std::list<media::Player::PlayerKey> paused_sessions;
 };
 
+// Create an instance with the given configuration.
+media::ServiceImplementation::Ptr media::ServiceImplementation::create(const media::ServiceImplementation::Configuration& config)
+{
+    return media::ServiceImplementation::Ptr{new media::ServiceImplementation{config}};
+}
+
 media::ServiceImplementation::ServiceImplementation(const media::ServiceImplementation::Configuration& config)
     : d(new Private(*this, config))
 {
@@ -143,13 +158,15 @@
 std::shared_ptr<media::Player> media::ServiceImplementation::create_session(
         const media::Player::Configuration& conf)
 {
+    static const bool timeouts_are_async_in_production{true};
+    static const std::chrono::milliseconds default_timeout_for_power_state_locks{4000};
+
     media::PlayerImplementation::Configuration player_config
     {
-        conf.identity,
-        conf.bus,
-        conf.session,
-        ServiceImplementation::shared_from_this(),
         conf.key,
+        timeouts_are_async_in_production,
+        default_timeout_for_power_state_locks,
+        d->engine_factory(),
         d->client_death_observer,
         d->power_state_controller
     };
@@ -170,7 +187,7 @@
         // until all dispatches are done
         sp->d->dispatcher([sp, key]()
         {
-            sp->remove_player_for_key(key);
+            sp->d->player_store->remove_player_for_key(key);
         });
     });
 
@@ -179,19 +196,19 @@
 
 void media::ServiceImplementation::pause_other_sessions(media::Player::PlayerKey key)
 {
-    if (not has_player_for_key(key))
+    if (not d->player_store->has_player_for_key(key))
     {
         cerr << "Could not find Player by key: " << key << endl;
         return;
     }
 
-    auto current_player = player_for_key(key);
+    auto current_player = d->player_store->player_for_key(key);
 
     // We immediately make the player known as new current player.
     if (current_player->audio_stream_role() == media::Player::multimedia)
-        set_current_player_for_key(key);
+        d->player_store->set_current_player_for_key(key);
 
-    enumerate_players([current_player, key](const media::Player::PlayerKey& other_key, const std::shared_ptr<media::Player>& other_player)
+    d->player_store->enumerate_players([current_player, key](const media::Player::PlayerKey& other_key, const std::shared_ptr<media::Player>& other_player)
     {
         // Only pause a Player if all of the following criteria are met:
         // 1) currently playing
@@ -211,37 +228,23 @@
 
 void media::ServiceImplementation::pause_all_multimedia_sessions()
 {
-    enumerate_players([this](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
-                      {
-                          if (player->playback_status() == Player::playing
-                              && player->audio_stream_role() == media::Player::multimedia)
-                          {
-                              d->paused_sessions.push_back(key);
-                              player->pause();
-                          }
-                      });
+    d->player_store->enumerate_players([this](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
+    {
+        if (player->playback_status() == Player::playing
+                && player->audio_stream_role() == media::Player::multimedia)
+        {
+            d->paused_sessions.push_back(key);
+            player->pause();
+        }
+    });
 }
 
 void media::ServiceImplementation::resume_paused_multimedia_sessions()
 {
-    std::for_each(d->paused_sessions.begin(), d->paused_sessions.end(), [this](const media::Player::PlayerKey& key) {
-            player_for_key(key)->play();
-        });
+    std::for_each(d->paused_sessions.begin(), d->paused_sessions.end(), [this](const media::Player::PlayerKey& key)
+    {
+        d->player_store->player_for_key(key)->play();
+    });
 
     d->paused_sessions.clear();
 }
-
-void media::ServiceImplementation::resume_multimedia_session()
-{
-    if (not has_player_for_key(d->resume_key))
-        return;
-
-    auto player = player_for_key(d->resume_key);
-
-    if (player->playback_status() == Player::paused)
-    {
-        cout << "Resuming playback of Player with key: " << d->resume_key << endl;
-        player->play();
-        d->resume_key = std::numeric_limits<std::uint32_t>::max();
-    }
-}

=== modified file 'src/core/media/service_implementation.h'
--- src/core/media/service_implementation.h	2014-11-19 10:23:50 +0000
+++ src/core/media/service_implementation.h	2014-11-19 10:23:50 +0000
@@ -19,52 +19,61 @@
 #ifndef CORE_UBUNTU_MEDIA_SERVICE_IMPLEMENTATION_H_
 #define CORE_UBUNTU_MEDIA_SERVICE_IMPLEMENTATION_H_
 
+#include <core/media/service.h>
+
 #include "dispatcher.h"
 
 #include "client_death_observer.h"
+#include "engine_factory.h"
+#include "keyed_player_store.h"
 #include "recorder_observer.h"
 #include "power/battery_observer.h"
 #include "power/state_controller.h"
 #include "telephony/call_monitor.h"
 
-#include "service_skeleton.h"
-
 namespace core
 {
 namespace ubuntu
 {
 namespace media
 {
-
 class Player;
 
 class ServiceImplementation
-        : public ServiceSkeleton,
+        : public Service,
           public std::enable_shared_from_this<ServiceImplementation>
 {
 public:
+    // To save us some typing
+    typedef std::shared_ptr<ServiceImplementation> Ptr;
+
     // All creation time arguments go here.
     struct Configuration
     {
         Dispatcher dispatcher;
+        media::KeyedPlayerStore::Ptr player_store;
         media::ClientDeathObserver::Ptr client_death_observer;
+        media::EngineFactory engine_factory;
         media::RecorderObserver::Ptr recorder_observer;
         power::StateController::Ptr power_state_controller;
         power::BatteryObserver::Ptr power_state_observer;
         telephony::CallMonitor::Ptr call_monitor;
     };
 
-    ServiceImplementation (const Configuration& configuration);
+    // Create an instance with the given configuration.
+    static Ptr create(const Configuration&);
+
     ~ServiceImplementation ();
 
-    std::shared_ptr<Player> create_session(const Player::Configuration&);
-
-    void pause_other_sessions(Player::PlayerKey key);
+    // From media::Service
+    std::shared_ptr<Player> create_session(const Player::Configuration&) override;
+    void pause_other_sessions(Player::PlayerKey key) override;
 
 private:
+    ServiceImplementation (const Configuration& configuration);
+
     void pause_all_multimedia_sessions();
     void resume_paused_multimedia_sessions();
-    void resume_multimedia_session();
 
     struct Private;
     std::unique_ptr<Private> d;

=== modified file 'src/core/media/service_skeleton.cpp'
--- src/core/media/service_skeleton.cpp	2014-10-14 16:21:47 +0000
+++ src/core/media/service_skeleton.cpp	2014-11-19 10:23:50 +0000
@@ -20,22 +20,15 @@
 
 #include "apparmor.h"
 
-#include "mpris/media_player2.h"
-#include "mpris/metadata.h"
-#include "mpris/player.h"
-#include "mpris/playlists.h"
-#include "mpris/service.h"
+#include "mpris/exported.h"
 
 #include "player_configuration.h"
-#include "the_session_bus.h"
-#include "xesam.h"
+#include "player_skeleton.h"
 
 #include <core/dbus/message.h>
 #include <core/dbus/object.h>
 #include <core/dbus/types/object_path.h>
 
-#include <core/posix/this_process.h>
-
 #include <map>
 #include <regex>
 #include <sstream>
@@ -43,367 +36,82 @@
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
 
-namespace
-{
-core::Signal<void> the_empty_signal;
-}
-
 struct media::ServiceSkeleton::Private
 {
-    Private(media::ServiceSkeleton* impl, const media::CoverArtResolver& resolver)
+    Private(media::ServiceSkeleton* impl, const media::ServiceSkeleton::Configuration& configuration)
         : impl(impl),
-          object(impl->access_service()->add_object_for_path(
-                     dbus::traits::Service<media::Service>::object_path())),
-          dbus_stub(impl->access_bus()),
-          exported(impl->access_bus(), resolver)
+          configuration(configuration),
+          exported(configuration.bus, configuration.cover_art_resolver),
+          connections
+          {
+              configuration.player_store->current_player().changed().connect([this](const std::shared_ptr<media::Player>& player)
+              {
+                  exported.set_current_player(player);
+              })
+          }
     {
-        object->install_method_handler<mpris::Service::CreateSession>(
+        configuration.object->install_method_handler<mpris::Service::CreateSession>(
                     std::bind(
                         &Private::handle_create_session,
                         this,
                         std::placeholders::_1));
-        object->install_method_handler<mpris::Service::PauseOtherSessions>(
+        configuration.object->install_method_handler<mpris::Service::PauseOtherSessions>(
                     std::bind(
                         &Private::handle_pause_other_sessions,
                         this,
                         std::placeholders::_1));
     }
 
+    ~Private()
+    {
+        configuration.object->uninstall_method_handler<mpris::Service::CreateSession>();
+        configuration.object->uninstall_method_handler<mpris::Service::PauseOtherSessions>();
+    }
+
     void handle_create_session(const core::dbus::Message::Ptr& msg)
     {
-        static unsigned int session_counter = 0;
-
-        std::stringstream ss;
-        ss << "/core/ubuntu/media/Service/sessions/" << session_counter++;
-
-        dbus::types::ObjectPath op{ss.str()};
-        media::Player::PlayerKey key{session_counter};
-
-        dbus_stub.get_connection_app_armor_security_async(msg->sender(), [this, msg, op, key](const std::string& profile)
-        {
-            media::Player::Configuration config
-            {
-                profile,
-                key,
-                impl->access_bus(),
-                impl->access_service()->add_object_for_path(op)
-            };
-
-            try
-            {
-                auto session = impl->create_session(config);
-
-                bool inserted = false;
-                std::tie(std::ignore, inserted)
-                        = session_store.insert(std::make_pair(key, 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);
-            } 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);
-            }
-        });
+        static std::atomic<unsigned int> session_counter{0};
+        media::Player::PlayerKey key{session_counter++};
+        std::stringstream ss; ss << "/core/ubuntu/media/Service/sessions/" << key;
+        media::Player::Configuration config{dbus::types::ObjectPath{ss.str()}, key};
+
+        dbus::Message::Ptr reply;
+        try
+        {
+            configuration.player_store->add_player_for_key(config.key, impl->create_session(config));
+            reply = dbus::Message::make_method_return(msg);
+            reply->writer() << config.path;
+        }
+        catch (...)
+        {
+            reply = dbus::Message::make_error(msg, mpris::Service::Errors::CreatingSession::name(), std::string{});
+        }
+
+        configuration.bus->send(reply);
     }
 
     void handle_pause_other_sessions(const core::dbus::Message::Ptr& msg)
     {
-        std::cout << __PRETTY_FUNCTION__ << std::endl;
-        Player::PlayerKey key;
-        msg->reader() >> key;
+        Player::PlayerKey key; msg->reader() >> key;
         impl->pause_other_sessions(key);
 
-        auto reply = dbus::Message::make_method_return(msg);
-        impl->access_bus()->send(reply);
+        configuration.bus->send(dbus::Message::make_method_return(msg));
     }
 
     media::ServiceSkeleton* impl;
-    dbus::Object::Ptr object;
-
-    // We query the apparmor profile to obtain an identity for players.
-    org::freedesktop::dbus::DBus::Stub dbus_stub;
-    // We track all running player instances.
-    std::map<media::Player::PlayerKey, std::shared_ptr<media::Player>> session_store;
+    // We store the creation time arguments
+    ServiceSkeleton::Configuration configuration;
     // We expose the entire service as an MPRIS player.
-    struct Exported
+    mpris::Exported exported;
+    // All event connections go here.
+    struct
     {
-        static mpris::MediaPlayer2::Skeleton::Configuration::Defaults media_player_defaults()
-        {
-            mpris::MediaPlayer2::Skeleton::Configuration::Defaults defaults;
-            // TODO(tvoss): These three elements really should be configurable.
-            defaults.identity = "core::media::Hub";
-            defaults.desktop_entry = "mediaplayer-app";
-            defaults.supported_mime_types = {"audio/mpeg3"};
-
-            return defaults;
-        }
-
-        static mpris::Player::Skeleton::Configuration::Defaults player_defaults()
-        {
-            mpris::Player::Skeleton::Configuration::Defaults defaults;
-
-            // Disabled as track list is not fully implemented yet.
-            defaults.can_go_next = false;
-            // Disabled as track list is not fully implemented yet.
-            defaults.can_go_previous = false;
-
-            return defaults;
-        }
-
-        static std::string service_name()
-        {
-            static const bool export_to_indicator_sound_via_mpris
-            {
-                core::posix::this_process::env::get("UBUNTU_MEDIA_HUB_EXPORT_TO_INDICATOR_VIA_MPRIS", "0") == "1"
-            };
-
-            return export_to_indicator_sound_via_mpris ? "org.mpris.MediaPlayer2.MediaHub" :
-                                                         "hidden.org.mpris.MediaPlayer2.MediaHub";
-        }
-
-        explicit Exported(const dbus::Bus::Ptr& bus, const media::CoverArtResolver& cover_art_resolver)
-            : bus{bus},
-              service{dbus::Service::add_service(bus, service_name())},
-              object{service->add_object_for_path(dbus::types::ObjectPath{"/org/mpris/MediaPlayer2"})},
-              media_player{mpris::MediaPlayer2::Skeleton::Configuration{bus, object, media_player_defaults()}},
-              player{mpris::Player::Skeleton::Configuration{bus, object, player_defaults()}},
-              playlists{mpris::Playlists::Skeleton::Configuration{bus, object, mpris::Playlists::Skeleton::Configuration::Defaults{}}},
-              cover_art_resolver{cover_art_resolver}
-        {
-            object->install_method_handler<core::dbus::interfaces::Properties::GetAll>([this](const core::dbus::Message::Ptr& msg)
-            {
-                // Extract the interface
-                std::string itf; msg->reader() >> itf;
-                core::dbus::Message::Ptr reply = core::dbus::Message::make_method_return(msg);
-
-                if (itf == mpris::Player::name())
-                    reply->writer() << player.get_all_properties();
-                else if (itf == mpris::MediaPlayer2::name())
-                    reply->writer() << media_player.get_all_properties();
-                else if (itf == mpris::Playlists::name())
-                    reply->writer() << playlists.get_all_properties();
-
-                Exported::bus->send(reply);
-            });
-
-            // Setup method handlers for mpris::Player methods.
-            auto next = [this](const core::dbus::Message::Ptr& msg)
-            {
-                auto sp = current_player.lock();
-
-                if (sp)
-                    sp->next();
-
-                Exported::bus->send(core::dbus::Message::make_method_return(msg));
-            };
-            object->install_method_handler<mpris::Player::Next>(next);
-
-            auto previous = [this](const core::dbus::Message::Ptr& msg)
-            {
-                auto sp = current_player.lock();
-
-                if (sp)
-                    sp->previous();
-
-                Exported::bus->send(core::dbus::Message::make_method_return(msg));
-            };
-            object->install_method_handler<mpris::Player::Previous>(previous);
-
-            auto pause = [this](const core::dbus::Message::Ptr& msg)
-            {
-                auto sp = current_player.lock();
-
-                if (sp)
-                    sp->pause();
-
-                Exported::bus->send(core::dbus::Message::make_method_return(msg));
-            };
-            object->install_method_handler<mpris::Player::Pause>(pause);
-
-            auto stop = [this](const core::dbus::Message::Ptr& msg)
-            {
-                auto sp = current_player.lock();
-
-                if (sp)
-                    sp->stop();
-
-                Exported::bus->send(core::dbus::Message::make_method_return(msg));
-            };
-            object->install_method_handler<mpris::Player::Stop>(stop);
-
-            auto play = [this](const core::dbus::Message::Ptr& msg)
-            {
-                auto sp = current_player.lock();
-
-                if (sp)
-                    sp->play();
-
-                Exported::bus->send(core::dbus::Message::make_method_return(msg));
-            };
-            object->install_method_handler<mpris::Player::Play>(play);
-
-            auto play_pause = [this](const core::dbus::Message::Ptr& msg)
-            {
-                auto sp = current_player.lock();
-
-                if (sp)
-                {
-                    if (sp->playback_status() == media::Player::PlaybackStatus::playing)
-                        sp->pause();
-                    else if (sp->playback_status() != media::Player::PlaybackStatus::null)
-                        sp->play();
-                }
-
-                Exported::bus->send(core::dbus::Message::make_method_return(msg));
-            };
-            object->install_method_handler<mpris::Player::PlayPause>(play_pause);
-        }
-
-        void set_current_player(const std::shared_ptr<media::Player>& cp)
-        {
-            unset_current_player();
-
-            // We will not keep the object alive.
-            current_player = cp;
-
-            // And announce that we can be controlled again.
-            player.properties.can_control->set(false);
-
-            // We wire up player state changes
-            connections.seeked_to = cp->seeked_to().connect([this](std::uint64_t position)
-            {
-                player.signals.seeked_to->emit(position);
-            });
-
-            connections.duration_changed = cp->duration().changed().connect([this](std::uint64_t duration)
-            {
-                player.properties.duration->set(duration);
-            });
-
-            connections.position_changed = cp->position().changed().connect([this](std::uint64_t position)
-            {
-                player.properties.position->set(position);
-            });
-
-            connections.playback_status_changed = cp->playback_status().changed().connect([this](core::ubuntu::media::Player::PlaybackStatus status)
-            {
-                player.properties.playback_status->set(mpris::Player::PlaybackStatus::from(status));
-            });
-
-            connections.loop_status_changed = cp->loop_status().changed().connect([this](core::ubuntu::media::Player::LoopStatus status)
-            {
-                player.properties.loop_status->set(mpris::Player::LoopStatus::from(status));
-            });
-
-            connections.meta_data_changed = cp->meta_data_for_current_track().changed().connect([this](const core::ubuntu::media::Track::MetaData& md)
-            {
-                mpris::Player::Dictionary dict;
-
-                bool has_title = md.count(xesam::Title::name) > 0;
-                bool has_album_name = md.count(xesam::Album::name) > 0;
-                bool has_artist_name = md.count(xesam::Artist::name) > 0;
-
-                if (has_title)
-                    dict[xesam::Title::name] = dbus::types::Variant::encode(md.get(xesam::Title::name));
-                if (has_album_name)
-                    dict[xesam::Album::name] = dbus::types::Variant::encode(md.get(xesam::Album::name));
-                if (has_artist_name)
-                    dict[xesam::Artist::name] = dbus::types::Variant::encode(md.get(xesam::Artist::name));
-
-                dict[mpris::metadata::ArtUrl::name] = dbus::types::Variant::encode(
-                            cover_art_resolver(
-                                has_title ? md.get(xesam::Title::name) : "",
-                                has_album_name ? md.get(xesam::Album::name) : "",
-                                has_artist_name ? md.get(xesam::Artist::name) : ""));
-
-                mpris::Player::Dictionary wrap;
-                wrap[mpris::Player::Properties::Metadata::name()] = dbus::types::Variant::encode(dict);
-
-                player.signals.properties_changed->emit(
-                            std::make_tuple(
-                                dbus::traits::Service<mpris::Player::Properties::Metadata::Interface>::interface_name(),
-                                wrap,
-                                std::vector<std::string>()));
-            });
-        }
-
-        void unset_current_player()
-        {
-            current_player.reset();
-
-            // We disconnect all previous event connections.
-            connections.seeked_to.disconnect();
-            connections.duration_changed.disconnect();
-            connections.position_changed.disconnect();
-            connections.playback_status_changed.disconnect();
-            connections.loop_status_changed.disconnect();
-            connections.meta_data_changed.disconnect();
-
-            // And announce that we cannot be controlled anymore.
-            player.properties.can_control->set(false);
-        }
-
-        void unset_if_current(const std::shared_ptr<media::Player>& cp)
-        {
-            if (cp == current_player.lock())
-                unset_current_player();
-        }
-
-        dbus::Bus::Ptr bus;
-        dbus::Service::Ptr service;
-        dbus::Object::Ptr object;
-
-        mpris::MediaPlayer2::Skeleton media_player;
-        mpris::Player::Skeleton player;
-        mpris::Playlists::Skeleton playlists;
-
-        // Helper to resolve (title, artist, album) tuples to cover art.
-        media::CoverArtResolver cover_art_resolver;
-        // The actual player instance.
-        std::weak_ptr<media::Player> current_player;
-        // We track event connections.
-        struct
-        {
-            core::Connection seeked_to
-            {
-                the_empty_signal.connect([](){})
-            };
-            core::Connection duration_changed
-            {
-                the_empty_signal.connect([](){})
-            };
-            core::Connection position_changed
-            {
-                the_empty_signal.connect([](){})
-            };
-            core::Connection playback_status_changed
-            {
-                the_empty_signal.connect([](){})
-            };
-            core::Connection loop_status_changed
-            {
-                the_empty_signal.connect([](){})
-            };
-            core::Connection meta_data_changed
-            {
-                the_empty_signal.connect([](){})
-            };
-        } connections;
-    } exported;
+        core::ScopedConnection current_player_changed;
+    } connections;
 };
 
-media::ServiceSkeleton::ServiceSkeleton(const media::CoverArtResolver& resolver)
-    : dbus::Skeleton<media::Service>(the_session_bus()),
-      d(new Private(this, resolver))
+media::ServiceSkeleton::ServiceSkeleton(const media::ServiceSkeleton::Configuration& configuration)
+      : d(new Private(this, configuration))
 {
 }
 
@@ -411,47 +119,17 @@
 {
 }
 
-bool media::ServiceSkeleton::has_player_for_key(const media::Player::PlayerKey& key) const
-{
-    return d->session_store.count(key) > 0;
-}
-
-std::shared_ptr<media::Player> media::ServiceSkeleton::player_for_key(const media::Player::PlayerKey& key) const
-{
-    return d->session_store.at(key);
-}
-
-void media::ServiceSkeleton::enumerate_players(const media::ServiceSkeleton::PlayerEnumerator& enumerator) const
-{
-    for (const auto& pair : d->session_store)
-        enumerator(pair.first, pair.second);
-}
-
-void media::ServiceSkeleton::set_current_player_for_key(const media::Player::PlayerKey& key)
-{
-    if (not has_player_for_key(key))
-        return;
-
-    d->exported.set_current_player(player_for_key(key));
-}
-
-void media::ServiceSkeleton::remove_player_for_key(const media::Player::PlayerKey& key)
-{
-    if (not has_player_for_key(key))
-        return;
-
-    auto player = player_for_key(key);
-
-    d->session_store.erase(key);
-    d->exported.unset_if_current(player);
-}
-
-void media::ServiceSkeleton::run()
-{
-    access_bus()->run();
-}
-
-void media::ServiceSkeleton::stop()
-{
-    access_bus()->stop();
+std::shared_ptr<media::Player> media::ServiceSkeleton::create_session(const media::Player::Configuration& config)
+{
+    return std::make_shared<media::PlayerSkeleton>(media::PlayerSkeleton::Configuration
+    {
+        d->configuration.impl->create_session(config),
+        d->configuration.bus,
+        d->configuration.service->add_object_for_path(config.path)
+    });
+}
+
+void media::ServiceSkeleton::pause_other_sessions(media::Player::PlayerKey key)
+{
+    d->configuration.impl->pause_other_sessions(key);
 }

=== modified file 'src/core/media/service_skeleton.h'
--- src/core/media/service_skeleton.h	2014-09-09 21:27:29 +0000
+++ src/core/media/service_skeleton.h	2014-11-19 10:23:50 +0000
@@ -22,8 +22,9 @@
 #include <core/media/service.h>
 
 #include "cover_art_resolver.h"
-#include "service_traits.h"
+#include "keyed_player_store.h"
 
+#include <core/dbus/object.h>
 #include <core/dbus/skeleton.h>
 
 #include <memory>
@@ -34,42 +35,34 @@
 {
 namespace media
 {
-class ServiceSkeleton : public core::dbus::Skeleton<core::ubuntu::media::Service>
+class ServiceSkeleton : public media::Service
 {
 public:
-    // Functor for enumerating all known (key, player) pairs.
-    typedef std::function
-    <
-        void(
-            // The key of the player.
-            const core::ubuntu::media::Player::PlayerKey&,
-            // The actual player instance.
-            const std::shared_ptr<core::ubuntu::media::Player>&
-        )
-    > PlayerEnumerator;
+    // Construction time arguments go here.
+    struct Configuration
+    {
+        // The actual service implementation that we forward to.
+        std::shared_ptr<Service> impl;
+        // The bus instance that we expose the service on.
+        core::dbus::Bus::Ptr bus;
+        // The service instance owned on the bus.
+        core::dbus::Service::Ptr service;
+        // The object that represents the service instance.
+        core::dbus::Object::Ptr object;
+        // The store of currently known players.
+        KeyedPlayerStore::Ptr player_store;
+        // The cover art resolver.
+        CoverArtResolver cover_art_resolver;
+    };
 
-    ServiceSkeleton(const CoverArtResolver& cover_art_resolver = always_missing_cover_art_resolver());
+    ServiceSkeleton(const Configuration&);
     ~ServiceSkeleton();
 
-    // We keep track of all known player sessions here and render them accessible via
-    // the key. All of these functions are thread-safe but not reentrant.
-    // Returns true iff a player is known for the given key.
-    bool has_player_for_key(const Player::PlayerKey& key) const;
-    // Returns the player for the given key or throws std::out_of_range if no player is known
-    // for the given key.
-    std::shared_ptr<Player> player_for_key(const Player::PlayerKey& key) const;
-    // Enumerates all known players and invokes the given enumerator for each
-    // (key, player) pair.
-    void enumerate_players(const PlayerEnumerator& enumerator) const;
-    // Removes the player for the given key, and unsets it if it is the current one.
-    void remove_player_for_key(const Player::PlayerKey& key);
-    // Makes the player known under the given key current.
-    void set_current_player_for_key(const Player::PlayerKey& key);
-
-    void run();
-    void stop();
-
-  private:
+    // From media::Service
+    std::shared_ptr<Player> create_session(const Player::Configuration&) override;
+    void pause_other_sessions(Player::PlayerKey) override;
+
+private:
     struct Private;
     std::shared_ptr<Private> d;
 };

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-02-14 08:12:35 +0000
+++ tests/CMakeLists.txt	2014-11-19 10:23:50 +0000
@@ -1,14 +1,6 @@
 find_package(Threads)
 
-add_definitions(-DBOOST_NO_CXX11_SCOPED_ENUMS)
-
-include_directories(${CMAKE_SOURCE_DIR}/include)
-
-option(
-    MEDIA_HUB_ENABLE_DBUS_TEST_RUNNER 
-    "Rely on dbus test runner to start a private session for testing purposes" 
-    ON
-)
+add_definitions(-DBOOST_NO_CXX11_SCOPED_ENUMS -DCORE_DBUS_ENABLE_GOOGLE_TEST_FIXTURE)
 
 if (MEDIA_HUB_ENABLE_DBUS_TEST_RUNNER)
     find_program(DBUS_TEST_RUNNER_EXECUTABLE dbus-test-runner)
@@ -23,8 +15,8 @@
 add_subdirectory(${GMOCK_SOURCE_DIR} "${CMAKE_CURRENT_BINARY_DIR}/gmock")
 
 include_directories (
-  .
-  
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}/src
   ${GMOCK_INCLUDE_DIR}
   ${GTEST_INCLUDE_DIR}
 )
@@ -50,5 +42,28 @@
     "COM_UBUNTU_MEDIA_SERVICE_AUDIO_SINK_NAME=fakesink"
 )
 
-add_subdirectory(acceptance-tests)
+macro(MEDIA_HUB_ADD_TEST test_name src)
+  add_executable(
+    ${test_name}
+    ${src})
+
+  target_link_libraries(
+    ${test_name}
+
+    media-hub-client
+    media-hub-common
+    media-hub-service
+    media-hub-test-framework
+
+    gmock
+    gmock_main
+    gtest
+  )
+
+  add_test(${test_name} ${CMAKE_CURRENT_BINARY_DIR}/${test_name} --gtest_filter=*-*requires*)
+endmacro(MEDIA_HUB_ADD_TEST)
+
+
+#add_subdirectory(acceptance-tests)
+add_subdirectory(integration-tests)
 add_subdirectory(unit-tests)

=== modified file 'tests/acceptance-tests/service.cpp'
--- tests/acceptance-tests/service.cpp	2014-11-19 10:23:50 +0000
+++ tests/acceptance-tests/service.cpp	2014-11-19 10:23:50 +0000
@@ -21,6 +21,7 @@
 #include <core/media/track_list.h>
 
 #include "core/media/service_implementation.h"
+#include "core/media/gstreamer/engine_factory.h"
 
 #include "../waitable_state_transition.h"
 
@@ -103,6 +104,7 @@
             es.io_service.post(task);
         },
         media::platform_default_client_death_observer(),
+        media::gstreamer::engine_factory(),
         media::make_platform_default_recorder_observer(),
         media::power::make_platform_default_state_controller(es),
         media::power::make_platform_default_battery_observer(es),

=== added directory 'tests/integration-tests'
=== added file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/CMakeLists.txt	2014-11-19 10:23:50 +0000
@@ -0,0 +1,4 @@
+MEDIA_HUB_ADD_TEST(player_implementation_test player_implementation_test.cpp)
+MEDIA_HUB_ADD_TEST(player_skeleton_test player_skeleton_test.cpp)
+MEDIA_HUB_ADD_TEST(service_implementation_test service_implementation_test.cpp)
+

=== added file 'tests/integration-tests/player_implementation_test.cpp'
--- tests/integration-tests/player_implementation_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/player_implementation_test.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,274 @@
+/*
+ * Copyright © 2014 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 <core/media/base_engine.h>
+#include <core/media/player_implementation.h>
+
+#include "mock/client_death_observer.h"
+#include "mock/engine.h"
+#include "mock/power_state_controller.h"
+
+#include <gmock/gmock.h>
+
+namespace media = core::ubuntu::media;
+
+namespace
+{
+// Our default player key we use in testing.
+constexpr const media::Player::PlayerKey the_player_key{42};
+// Our default texture handle we use in testing.
+constexpr const std::uint32_t the_texture_id{13};
+// Constructs a PlayerImplementation::Configuration instance containing mocked
+// instances for the functional dependencies.
+media::PlayerImplementation::Configuration make_player_configuration_for_testing()
+{
+    using namespace ::testing;
+
+    static const bool timeouts_are_sync_in_testing{false};
+    static const std::chrono::milliseconds default_timeout_for_power_state_locks{0};
+
+    return media::PlayerImplementation::Configuration
+    {
+        the_player_key,
+        timeouts_are_sync_in_testing,
+        default_timeout_for_power_state_locks,
+        std::make_shared<NiceMock<MockEngine>>(),
+        std::make_shared<NiceMock<MockClientDeathObserver>>(),
+        std::make_shared<NiceMock<MockPowerStateController>>()
+    };
+}
+}
+
+TEST(PlayerImplementation, forwards_calls_to_engine_instance)
+{
+    using namespace ::testing;
+
+    const media::Track::UriType the_uri{"file:///does/not/exist"};
+    const std::chrono::microseconds the_timestamp{42};
+
+    auto config = make_player_configuration_for_testing();
+    auto engine = std::make_shared<NiceMock<MockEngine>>();
+    config.engine = engine;
+
+    EXPECT_CALL(*engine, read_duration()).Times(1);
+    EXPECT_CALL(*engine, read_is_audio()).Times(1);
+    EXPECT_CALL(*engine, read_is_video()).Times(1);
+
+    EXPECT_CALL(*engine, open_resource_for_uri(the_uri)).Times(1);
+    EXPECT_CALL(*engine, create_video_sink(the_texture_id)).Times(1);
+    EXPECT_CALL(*engine, play()).Times(1);
+    EXPECT_CALL(*engine, stop()).Times(1);
+    EXPECT_CALL(*engine, pause()).Times(1);
+    EXPECT_CALL(*engine, seek_to(the_timestamp)).Times(1);
+
+    media::PlayerImplementation impl{config};
+
+    static_cast<const media::PlayerImplementation&>(impl).is_audio_source().get();
+    static_cast<const media::PlayerImplementation&>(impl).is_video_source().get();
+    static_cast<const media::PlayerImplementation&>(impl).duration().get();
+
+    impl.open_uri(the_uri);
+    impl.create_gl_texture_video_sink(the_texture_id);
+    impl.play();
+    impl.stop();
+    impl.pause();
+    impl.seek_to(the_timestamp);
+}
+
+TEST(PlayerImplementation, subscribes_to_client_death_notifications_on_construction)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+    auto client_death_observer = std::make_shared<NiceMock<MockClientDeathObserver>>();
+    EXPECT_CALL(*client_death_observer, register_for_death_notifications_with_key(the_player_key))
+            .Times(1);
+    config.client_death_observer = client_death_observer;
+
+    media::PlayerImplementation impl{config};
+}
+
+TEST(PlayerImplementation, unsubscribes_from_client_death_notifications_on_destruction)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+    auto client_death_observer = std::make_shared<NiceMock<MockClientDeathObserver>>();
+    EXPECT_CALL(*client_death_observer, register_for_death_notifications_with_key(the_player_key))
+            .Times(1);
+    config.client_death_observer = client_death_observer;
+
+    // We scope the instance to force destruction.
+    {
+        media::PlayerImplementation impl{config};
+    }
+
+    // We assume that the implementation correctly unsubscribed
+    // and that we are free to report death here.
+    client_death_observer->signals.on_client_with_key_died(the_player_key);
+}
+
+TEST(PlayerImplementation, resets_engine_when_client_with_correct_key_dies)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+    auto engine = std::make_shared<NiceMock<MockEngine>>();
+    auto client_death_observer = std::make_shared<NiceMock<MockClientDeathObserver>>();
+
+    EXPECT_CALL(*engine, reset())
+            .Times(1);
+    EXPECT_CALL(*client_death_observer, register_for_death_notifications_with_key(the_player_key))
+            .Times(1);
+
+    config.engine = engine;
+    config.client_death_observer = client_death_observer;
+
+    media::PlayerImplementation impl{config};
+
+    // Signal death of known client.
+    client_death_observer->signals.on_client_with_key_died(the_player_key);
+    // Signal death of unknown client.
+    client_death_observer->signals.on_client_with_key_died(2*the_player_key);
+}
+
+TEST(PlayerImplementation, acquires_display_and_system_power_state_locks_on_construction)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+    auto power_state_controller = std::make_shared<NiceMock<MockPowerStateController>>();
+    EXPECT_CALL(*power_state_controller, display_state_lock())
+            .Times(1);
+    EXPECT_CALL(*power_state_controller, system_state_lock())
+            .Times(1);
+    config.power_state_controller = power_state_controller;
+
+    media::PlayerImplementation impl{config};
+}
+
+namespace
+{
+// A fixture that helps in testing for multiple different engine states.
+struct PlayerImplementationEngineState : public ::testing::TestWithParam<media::Engine::State>
+{
+};
+}
+
+TEST(PlayerImplementation, acquires_display_power_state_on_when_video_playback_starts)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+
+    auto engine = std::make_shared<NiceMock<MockEngine>>();
+    ON_CALL(*engine, read_is_video()).WillByDefault(Return(true));
+    auto power_state_controller = std::make_shared<NiceMock<MockPowerStateController>>();
+
+    EXPECT_CALL(*power_state_controller->system_lock, request_acquire(media::power::SystemState::active))
+            .Times(0);
+    EXPECT_CALL(*power_state_controller->display_lock, request_acquire(media::power::DisplayState::on))
+            .Times(1);
+
+    config.engine = engine;
+    config.power_state_controller = power_state_controller;
+
+    media::PlayerImplementation impl{config};
+
+    // And switch our state.
+    engine->mutable_state() = media::Engine::State::playing;
+}
+
+TEST_P(PlayerImplementationEngineState, releases_display_power_state_on_when_engine_state_changes_away_from_playing)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+
+    auto engine = std::make_shared<NiceMock<MockEngine>>();
+    ON_CALL(*engine, read_is_video()).WillByDefault(Return(true));
+    auto power_state_controller = std::make_shared<NiceMock<MockPowerStateController>>();
+
+    EXPECT_CALL(*power_state_controller->system_lock, request_release(media::power::SystemState::active))
+            .Times(0);
+    EXPECT_CALL(*power_state_controller->display_lock, request_release(media::power::DisplayState::on))
+            .Times(1);
+
+    config.engine = engine;
+    config.power_state_controller = power_state_controller;
+
+    media::PlayerImplementation impl{config};
+
+    // And switch our state.
+    engine->mutable_state() = media::Engine::State::playing;
+    engine->mutable_state() = GetParam();
+}
+
+TEST(PlayerImplementation, acquires_system_power_state_active_when_audio_playback_starts)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+
+    auto engine = std::make_shared<NiceMock<MockEngine>>();
+    ON_CALL(*engine, read_is_audio()).WillByDefault(Return(true));
+    auto power_state_controller = std::make_shared<NiceMock<MockPowerStateController>>();
+
+    EXPECT_CALL(*power_state_controller->system_lock, request_acquire(media::power::SystemState::active))
+            .Times(1);
+    EXPECT_CALL(*power_state_controller->display_lock, request_acquire(media::power::DisplayState::on))
+            .Times(0);
+
+    config.engine = engine;
+    config.power_state_controller = power_state_controller;
+
+    media::PlayerImplementation impl{config};
+
+    // And switch our state.
+    engine->mutable_state() = media::Engine::State::playing;
+}
+
+TEST_P(PlayerImplementationEngineState, releases_system_power_state_active_when_engine_state_changes_away_from_playing)
+{
+    using namespace ::testing;
+
+    auto config = make_player_configuration_for_testing();
+
+    auto engine = std::make_shared<NiceMock<MockEngine>>();
+    ON_CALL(*engine, read_is_audio()).WillByDefault(Return(true));
+    auto power_state_controller = std::make_shared<NiceMock<MockPowerStateController>>();
+
+    EXPECT_CALL(*power_state_controller->system_lock, request_release(media::power::SystemState::active))
+            .Times(1);
+    EXPECT_CALL(*power_state_controller->display_lock, request_release(media::power::DisplayState::on))
+            .Times(0);
+
+    config.engine = engine;
+    config.power_state_controller = power_state_controller;
+
+    media::PlayerImplementation impl{config};
+
+    // And switch our state.
+    engine->mutable_state() = media::Engine::State::playing;
+    engine->mutable_state() = GetParam();
+}
+
+INSTANTIATE_TEST_CASE_P(
+        Power,
+        PlayerImplementationEngineState,
+        ::testing::Values(media::Engine::State::stopped, media::Engine::State::paused, media::Engine::State::ready));

=== added file 'tests/integration-tests/player_skeleton_test.cpp'
--- tests/integration-tests/player_skeleton_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/player_skeleton_test.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,363 @@
+/*
+ * Copyright © 2014 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 <core/media/player_skeleton.h>
+
+#include <core/media/base_player.h>
+#include <core/media/track.h>
+
+#include "mock/player.h"
+
+#include <core/dbus/fixture.h>
+
+#include <core/testing/fork_and_run.h>
+
+#include <gmock/gmock.h>
+
+namespace media = core::ubuntu::media;
+
+namespace
+{
+// Custom predicate to help asserting that a child process in a test finished successfully.
+::testing::AssertionResult did_finish_successfully(const core::posix::wait::Result& result)
+{
+    if (result.status != core::posix::wait::Result::Status::exited)
+        return ::testing::AssertionFailure() << "Process did not exit, but: " << (int)result.status;
+    if (result.detail.if_exited.status != core::posix::exit::Status::success)
+        return ::testing::AssertionFailure() << "Process did exit with failure.";
+
+    return ::testing::AssertionSuccess();
+}
+
+// Our custom fixture that provides us with private session and system
+// bus instances. In addition, we define a custom service name and object
+// path to enable maximum test isolation.
+struct PlayerSkeleton : public core::dbus::testing::Fixture
+{
+    static constexpr const char* service_name_for_testing
+    {
+        "this.is.the.media.service.for.testing"
+    };
+
+    static constexpr const char* object_path_for_testing
+    {
+        "/this/is/the/media/player/skeleton/for/testing"
+    };
+};
+
+// A helper to track changed signal emissions on properties.
+template<typename T>
+struct EventSink
+{
+    typedef T Expected;
+    typedef std::size_t Cardinality;
+
+    EventSink(const core::Property<T>& property)
+        : event_connection
+          {
+              property.changed().connect([this](const T& value)
+              {
+                  on_new_event(value);
+              })
+          }
+    {
+    }
+
+    EventSink(const core::Signal<T>& sig)
+        : event_connection
+          {
+              sig.connect([this](const T& value)
+              {
+                  on_new_event(value);
+              })
+          }
+    {
+    }
+
+    EventSink(const core::Property<T>& property, Expected expected_value, Cardinality cardinality)
+        : EventSink(property)
+    {
+        EXPECT_CALL(*this, on_new_event(expected_value)).Times(cardinality);
+    }
+
+    EventSink(const core::Signal<T>& sig, Expected expected_value, Cardinality cardinality)
+        : EventSink(sig)
+    {
+        EXPECT_CALL(*this, on_new_event(expected_value)).Times(cardinality);
+    }
+
+    // Invoked for every changed signal emission.
+    MOCK_METHOD1_T(on_new_event, void(const T&));
+
+    // We keep track of the event connection here.
+    // On destruction, the connection is automatically cut.
+    core::ScopedConnection event_connection;
+};
+// And a void overload
+template<>
+struct EventSink<void>
+{
+    typedef std::size_t Cardinality;
+
+    EventSink(const core::Signal<void>& sig)
+        : event_connection
+          {
+              sig.connect([this]()
+              {
+                  on_new_event();
+              })
+          }
+    {
+    }
+
+    EventSink(const core::Signal<void>& sig, Cardinality cardinality)
+        : EventSink(sig)
+    {
+        EXPECT_CALL(*this, on_new_event()).Times(cardinality);
+    }
+
+    // Invoked for every changed signal emission.
+    MOCK_METHOD0_T(on_new_event, void());
+
+    // We keep track of the event connection here.
+    // On destruction, the connection is automatically cut.
+    core::ScopedConnection event_connection;
+};
+
+// Our default player key we use in testing.
+constexpr const media::Player::PlayerKey the_player_key{42};
+// Our default texture handle we use in testing.
+constexpr const std::uint32_t the_texture_id{13};
+// Our default uri we use in testing.
+const media::Track::UriType the_uri{"file:///does/not/exist"};
+// Our default timestamp we use in testing.
+const std::chrono::microseconds the_timestamp{42};
+// A helper to create a mock player instance.
+std::shared_ptr<testing::NiceMock<MockPlayer>> make_mock_player()
+{
+    return std::make_shared<testing::NiceMock<MockPlayer>>();
+}
+// A helper return our default track meta data we use in testing.
+media::Track::MetaData the_track_meta_data()
+{
+    media::Track::MetaData md;
+    md.set("key1", "value1");
+    md.set("key2", "value2");
+
+    return md;
+}
+}
+
+// Please make sure that tests are executed in child processes
+// to ensure maximum test isolation.
+TEST_F(PlayerSkeleton, forwards_calls_to_implementation)
+{
+    auto child = core::posix::fork([this]()
+    {
+        using namespace ::testing;
+
+        auto bus = session_bus();
+        auto service = core::dbus::Service::add_service(bus, PlayerSkeleton::service_name_for_testing);
+        auto object = service->add_object_for_path(core::dbus::types::ObjectPath{PlayerSkeleton::object_path_for_testing});
+
+        auto impl = make_mock_player();
+
+        media::PlayerSkeleton skeleton
+        {
+            media::PlayerSkeleton::Configuration
+            {
+                impl, bus, object
+            }
+        };
+
+        EXPECT_CALL(*impl, track_list()).Times(1);
+        EXPECT_CALL(*impl, key()).Times(1);
+        EXPECT_CALL(*impl, create_gl_texture_video_sink(the_texture_id)).Times(1);
+        EXPECT_CALL(*impl, open_uri(the_uri)).Times(1);
+        EXPECT_CALL(*impl, next()).Times(1);
+        EXPECT_CALL(*impl, previous()).Times(1);
+        EXPECT_CALL(*impl, play()).Times(1);
+        EXPECT_CALL(*impl, pause()).Times(1);
+        EXPECT_CALL(*impl, stop()).Times(1);
+        EXPECT_CALL(*impl, seek_to(the_timestamp)).Times(1);
+
+        skeleton.track_list();
+        skeleton.key();
+        skeleton.create_gl_texture_video_sink(the_texture_id);
+        skeleton.open_uri(the_uri);
+        skeleton.next();
+        skeleton.previous();
+        skeleton.play();
+        skeleton.pause();
+        skeleton.stop();
+        skeleton.seek_to(the_timestamp);
+
+        return HasFailure() ? core::posix::exit::Status::failure
+                            : core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+    EXPECT_TRUE(did_finish_successfully(child.wait_for(core::posix::wait::Flags::untraced)));
+}
+
+TEST_F(PlayerSkeleton, property_changes_and_signals_are_forwarded_from_impl)
+{
+    auto child = core::posix::fork([this]()
+    {
+        using namespace ::testing;
+
+        auto bus = session_bus();
+        auto service = core::dbus::Service::add_service(bus, PlayerSkeleton::service_name_for_testing);
+        auto object = service->add_object_for_path(core::dbus::types::ObjectPath{PlayerSkeleton::object_path_for_testing});
+
+        auto impl = make_mock_player();
+
+        media::PlayerSkeleton skeleton
+        {
+            media::PlayerSkeleton::Configuration
+            {
+                impl, bus, object
+            }
+        };
+
+        // We have to scope our expectations to make sure we catch them at exit
+        {
+            EventSink<bool> es_can_play{skeleton.can_play()};
+            EXPECT_CALL(es_can_play, on_new_event(true)).Times(1);
+            EventSink<bool> es_can_pause{skeleton.can_pause()};
+            EXPECT_CALL(es_can_pause, on_new_event(true)).Times(1);
+            EventSink<bool> es_can_seek{skeleton.can_seek()};
+            EXPECT_CALL(es_can_seek, on_new_event(true)).Times(1);
+            EventSink<bool> es_can_go_previous{skeleton.can_go_previous()};
+            EXPECT_CALL(es_can_go_previous, on_new_event(true)).Times(1);
+            EventSink<bool> es_can_go_next{skeleton.can_go_next()};
+            EXPECT_CALL(es_can_go_next, on_new_event(true)).Times(1);
+            EventSink<bool> es_is_video_source{skeleton.is_video_source()};
+            EXPECT_CALL(es_is_video_source, on_new_event(true)).Times(1);
+            EventSink<bool> es_is_audio_source{skeleton.is_audio_source()};
+            EXPECT_CALL(es_is_audio_source, on_new_event(true)).Times(1);
+
+            EventSink<media::Player::PlaybackStatus> es_playback_status{skeleton.playback_status()};
+            EXPECT_CALL(es_playback_status, on_new_event(media::Player::PlaybackStatus::playing)).Times(1);
+            EventSink<media::Player::LoopStatus> es_loop_status{skeleton.loop_status()};
+            EXPECT_CALL(es_loop_status, on_new_event(media::Player::LoopStatus::track)).Times(1);
+            EventSink<media::Player::PlaybackRate> es_playback_rate{skeleton.playback_rate()};
+            EXPECT_CALL(es_playback_rate, on_new_event(media::Player::PlaybackRate{42})).Times(1);
+            EventSink<bool> es_is_shuffle{skeleton.is_shuffle()};
+            EXPECT_CALL(es_is_shuffle, on_new_event(true)).Times(1);
+            EventSink<media::Track::MetaData> es_meta_data{skeleton.meta_data_for_current_track()};
+            EXPECT_CALL(es_meta_data, on_new_event(the_track_meta_data())).Times(1);
+            EventSink<media::Player::Volume> es_volume{skeleton.volume()};
+            EXPECT_CALL(es_volume, on_new_event(media::Player::Volume{42})).Times(1);
+            EventSink<media::Player::PlaybackRate> es_minimum_playback_rate{skeleton.minimum_playback_rate()};
+            EXPECT_CALL(es_minimum_playback_rate, on_new_event(media::Player::PlaybackRate{42})).Times(1);
+            EventSink<media::Player::PlaybackRate> es_maximum_playback_rate{skeleton.maximum_playback_rate()};
+            EXPECT_CALL(es_maximum_playback_rate, on_new_event(media::Player::PlaybackRate{42})).Times(1);
+            EventSink<std::int64_t> es_position{skeleton.position()};
+            EXPECT_CALL(es_position, on_new_event(42)).Times(1);
+            EventSink<std::int64_t> es_duration{skeleton.duration()};
+            EXPECT_CALL(es_duration, on_new_event(42)).Times(1);
+            EventSink<media::Player::AudioStreamRole> es_audio_stream_role{skeleton.audio_stream_role()};
+            EXPECT_CALL(es_audio_stream_role, on_new_event(media::Player::AudioStreamRole::phone)).Times(1);
+            EventSink<media::Player::Orientation> es_orientation{skeleton.orientation()};
+            EXPECT_CALL(es_orientation, on_new_event(media::Player::Orientation::rotate180)).Times(1);
+
+            EventSink<int64_t> es_seeked_to{skeleton.seeked_to()};
+            EXPECT_CALL(es_seeked_to, on_new_event(42)).Times(1);
+            EventSink<void> es_end_of_stream{skeleton.end_of_stream()};
+            EXPECT_CALL(es_end_of_stream, on_new_event()).Times(1);
+            EventSink<media::Player::PlaybackStatus> es_playback_status_changed{skeleton.playback_status_changed()};
+            EXPECT_CALL(es_playback_status_changed, on_new_event(media::Player::PlaybackStatus::playing)).Times(1);
+            EventSink<media::video::Dimensions> es_video_dimension_changed{skeleton.video_dimension_changed()};
+            EXPECT_CALL(es_video_dimension_changed, on_new_event(std::make_tuple(media::video::Height{42}, media::video::Width{84}))).Times(1);
+
+            impl->can_play() = true;
+            impl->can_pause() = true;
+            impl->can_seek() = true;
+            impl->can_go_previous() = true;
+            impl->can_go_next() = true;
+            impl->is_video_source() = true;
+            impl->is_audio_source() = true;
+            impl->playback_status() = media::Player::PlaybackStatus::playing;
+            impl->loop_status() = media::Player::LoopStatus::track;
+            impl->playback_rate() = media::Player::PlaybackRate{42};
+            impl->is_shuffle() = true;
+            impl->meta_data_for_current_track() = the_track_meta_data();
+            impl->volume() = media::Player::Volume{42};
+            impl->minimum_playback_rate() = media::Player::PlaybackRate{42};
+            impl->maximum_playback_rate() = media::Player::PlaybackRate{42};
+            impl->position() = 42;
+            impl->duration() = 42;
+            impl->audio_stream_role() = media::Player::AudioStreamRole::phone;
+            impl->orientation() = media::Player::Orientation::rotate180;
+
+            impl->seeked_to()(42);
+            impl->end_of_stream()();
+            impl->playback_status_changed()(media::Player::PlaybackStatus::playing);
+            impl->video_dimension_changed()(std::make_tuple(media::video::Height{42}, media::video::Width{84}));
+        }
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure
+                                             : core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+    EXPECT_TRUE(did_finish_successfully(child.wait_for(core::posix::wait::Flags::untraced)));
+}
+
+TEST_F(PlayerSkeleton, property_changes_and_signals_are_forwarded_from_skeleton_to_impl)
+{
+    auto child = core::posix::fork([this]()
+    {
+        using namespace ::testing;
+
+        auto bus = session_bus();
+        auto service = core::dbus::Service::add_service(bus, PlayerSkeleton::service_name_for_testing);
+        auto object = service->add_object_for_path(core::dbus::types::ObjectPath{PlayerSkeleton::object_path_for_testing});
+
+        auto impl = make_mock_player();
+
+        media::PlayerSkeleton skeleton
+        {
+            media::PlayerSkeleton::Configuration
+            {
+                impl, bus, object
+            }
+        };
+
+        // We have to scope our expectations to make sure we catch them at exit
+        {
+            EventSink<media::Player::LoopStatus> es_loop_status{impl->loop_status()};
+            EXPECT_CALL(es_loop_status, on_new_event(media::Player::LoopStatus::track)).Times(1);
+            EventSink<media::Player::PlaybackRate> es_playback_rate{impl->playback_rate()};
+            EXPECT_CALL(es_playback_rate, on_new_event(media::Player::PlaybackRate{42})).Times(1);
+            EventSink<bool> es_is_shuffle{impl->is_shuffle()};
+            EXPECT_CALL(es_is_shuffle, on_new_event(true)).Times(1);
+            EventSink<media::Player::Volume> es_volume{impl->volume()};
+            EXPECT_CALL(es_volume, on_new_event(media::Player::Volume{42})).Times(1);
+
+            skeleton.loop_status() = media::Player::LoopStatus::track;
+            skeleton.playback_rate() = media::Player::PlaybackRate{42};
+            skeleton.is_shuffle() = true;
+            skeleton.volume() = media::Player::Volume{42};
+        }
+
+        return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure
+                                             : core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+    EXPECT_TRUE(did_finish_successfully(child.wait_for(core::posix::wait::Flags::untraced)));
+}

=== added file 'tests/integration-tests/service_implementation_test.cpp'
--- tests/integration-tests/service_implementation_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/service_implementation_test.cpp	2014-11-19 10:23:50 +0000
@@ -0,0 +1,421 @@
+/*
+ * Copyright © 2014 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 <core/media/service_implementation.h>
+#include <core/media/player_configuration.h>
+
+#include "mock/client_death_observer.h"
+#include "mock/keyed_player_store.h"
+#include "mock/player.h"
+#include "mock/power_state_controller.h"
+#include "mock/engine.h"
+
+#include <gmock/gmock.h>
+
+namespace media = core::ubuntu::media;
+
+namespace
+{
+struct MockRecorderObserver : public media::RecorderObserver
+{
+    MockRecorderObserver()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, recording_state())
+                .WillByDefault(ReturnRef(properties.recording_state));
+    }
+
+    // Getable/observable property describing the recording state of the system.
+    MOCK_CONST_METHOD0(recording_state, const core::Property<media::RecordingState>&());
+
+    struct
+    {
+        core::Property<media::RecordingState> recording_state;
+    } properties;
+};
+
+struct MockBatteryObserver : public media::power::BatteryObserver
+{
+    MockBatteryObserver()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, level())
+                .WillByDefault(ReturnRef(properties.level));
+        ON_CALL(*this, is_warning_active())
+                .WillByDefault(ReturnRef(properties.is_warning_active));
+    }
+
+    // A getable/observable property reporting the current power-level
+    // of the system.
+    MOCK_CONST_METHOD0(level, const core::Property<media::power::Level>&());
+    // A getable/observable property indicating whether a power-level
+    // warning is currently presented to the user.
+    MOCK_CONST_METHOD0(is_warning_active, const core::Property<bool>&());
+
+    struct
+    {
+        core::Property<media::power::Level> level;
+        core::Property<bool> is_warning_active;
+    } properties;
+};
+
+struct MockCallMonitor : public media::telephony::CallMonitor
+{
+    MockCallMonitor()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, on_call_state_changed())
+                .WillByDefault(ReturnRef(signals.on_call_state_changed));
+    }
+
+    MOCK_CONST_METHOD0(on_call_state_changed, const core::Signal<State>&());
+
+    struct
+    {
+        core::Signal<State> on_call_state_changed;
+    } signals;
+};
+
+struct MockDispatcher : public std::enable_shared_from_this<MockDispatcher>
+{
+    MockDispatcher()
+    {
+        using namespace ::testing;
+        ON_CALL(*this, dispatch(_))
+                .WillByDefault(Invoke(this, &MockDispatcher::run_task));
+    }
+
+    MOCK_METHOD1(dispatch, void(media::Task));
+
+    media::Dispatcher to_dispatcher()
+    {
+        auto sp = shared_from_this();
+
+        return [sp](media::Task task)
+        {
+            sp->dispatch(task);
+        };
+    }
+
+    void run_task(media::Task task)
+    {
+        task();
+    }
+};
+
+struct MockEngineFactory : public std::enable_shared_from_this<MockEngineFactory>
+{
+    MockEngineFactory()
+    {
+        using namespace ::testing;
+        ON_CALL(*this, make_engine())
+                .WillByDefault(Return(std::make_shared<MockEngine>()));
+    }
+
+    media::EngineFactory to_engine_factory()
+    {
+        auto sp = shared_from_this();
+        return [sp]()
+        {
+            return sp->make_engine();
+        };
+    }
+
+    MOCK_METHOD0(make_engine, media::Engine::Ptr());
+};
+
+// We use a tuple to pass around mocked instances
+// and to allow for setting up expectations.
+typedef std::tuple
+<
+    std::shared_ptr<MockDispatcher>,
+    std::shared_ptr<MockKeyedPlayerStore>,
+    std::shared_ptr<MockClientDeathObserver>,
+    std::shared_ptr<MockEngineFactory>,
+    std::shared_ptr<MockRecorderObserver>,
+    std::shared_ptr<MockPowerStateController>,
+    std::shared_ptr<MockBatteryObserver>,
+    std::shared_ptr<MockCallMonitor>
+> MockedConfiguration;
+
+namespace idx
+{
+    constexpr const std::size_t dispatcher{0};
+    constexpr const std::size_t keyed_player_store{1};
+    constexpr const std::size_t death_observer{2};
+    constexpr const std::size_t engine_factory{3};
+    constexpr const std::size_t recorder_observer{4};
+    constexpr const std::size_t power_state_controller{5};
+    constexpr const std::size_t battery_observer{6};
+    constexpr const std::size_t call_monitor{7};
+};
+
+MockedConfiguration make_mocked_configuration()
+{
+    return std::make_tuple(
+        std::make_shared<testing::NiceMock<MockDispatcher>>(),
+        std::make_shared<testing::NiceMock<MockKeyedPlayerStore>>(),
+        std::make_shared<testing::NiceMock<MockClientDeathObserver>>(),
+        std::make_shared<testing::NiceMock<MockEngineFactory>>(),
+        std::make_shared<testing::NiceMock<MockRecorderObserver>>(),
+        std::make_shared<testing::NiceMock<MockPowerStateController>>(),
+        std::make_shared<testing::NiceMock<MockBatteryObserver>>(),
+        std::make_shared<testing::NiceMock<MockCallMonitor>>());
+}
+
+media::ServiceImplementation::Configuration tie_to_mocked_configuration(MockedConfiguration& mc)
+{
+    return media::ServiceImplementation::Configuration
+    {
+        std::get<idx::dispatcher>(mc)->to_dispatcher(),
+        std::get<idx::keyed_player_store>(mc),
+        std::get<idx::death_observer>(mc),
+        std::get<idx::engine_factory>(mc)->to_engine_factory(),
+        std::get<idx::recorder_observer>(mc),
+        std::get<idx::power_state_controller>(mc),
+        std::get<idx::battery_observer>(mc),
+        std::get<idx::call_monitor>(mc)
+    };
+}
+
+std::shared_ptr<::testing::NiceMock<MockPlayer>> make_alarm_player()
+{
+    auto player = std::make_shared<::testing::NiceMock<MockPlayer>>();
+    player->playback_status() = media::Player::PlaybackStatus::playing;
+    player->audio_stream_role() = media::Player::AudioStreamRole::alarm;
+    return player;
+}
+
+std::shared_ptr<::testing::NiceMock<MockPlayer>> make_multimedia_player()
+{
+    auto player = std::make_shared<::testing::NiceMock<MockPlayer>>();
+    player->playback_status() = media::Player::PlaybackStatus::playing;
+    player->audio_stream_role() = media::Player::AudioStreamRole::multimedia;
+    return player;
+}
+
+// Our default player key we use in testing.
+constexpr const media::Player::PlayerKey the_player_key{42};
+}
+
+TEST(ServiceImplementation, requests_display_state_on_when_recording_starts)
+{
+    auto mc = make_mocked_configuration();
+
+    auto recorder_observer = std::get<idx::recorder_observer>(mc);
+    auto power_state_controller = std::get<idx::power_state_controller>(mc);
+
+    EXPECT_CALL(*power_state_controller->display_lock, request_acquire(media::power::DisplayState::on)).Times(1);
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report that the recording started.
+    recorder_observer->properties.recording_state = media::RecordingState::started;
+}
+
+TEST(ServiceImplementation, releases_display_state_on_when_recording_starts)
+{
+    auto mc = make_mocked_configuration();
+
+    auto recorder_observer = std::get<idx::recorder_observer>(mc);
+    auto power_state_controller = std::get<idx::power_state_controller>(mc);
+
+    EXPECT_CALL(*power_state_controller->display_lock, request_release(media::power::DisplayState::on)).Times(1);
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report that the recording started ...
+    recorder_observer->properties.recording_state = media::RecordingState::started;
+    // prior to stopping it.
+    recorder_observer->properties.recording_state = media::RecordingState::stopped;
+}
+
+TEST(ServiceImplementation, pauses_all_multimedia_session_if_battery_level_reaches_low)
+{
+    auto multimedia_player = make_multimedia_player();
+    auto alarm_player = make_alarm_player();
+
+    EXPECT_CALL(*multimedia_player, pause()).Times(1);
+    EXPECT_CALL(*alarm_player, pause()).Times(0);
+
+    auto mc = make_mocked_configuration();
+
+    auto keyed_player_store = std::get<idx::keyed_player_store>(mc);
+    auto battery_observer = std::get<idx::battery_observer>(mc);
+
+    keyed_player_store->properties.map[0] = multimedia_player;
+    keyed_player_store->properties.map[1] = alarm_player;
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report the battery reaching low.
+    battery_observer->properties.level = media::power::Level::low;
+}
+
+TEST(ServiceImplementation, pauses_all_multimedia_session_if_battery_level_reaches_very_low)
+{
+    auto multimedia_player = make_multimedia_player();
+    auto alarm_player = make_alarm_player();
+
+    EXPECT_CALL(*multimedia_player, pause()).Times(1);
+    EXPECT_CALL(*alarm_player, pause()).Times(0);
+
+    auto mc = make_mocked_configuration();
+
+    auto keyed_player_store = std::get<idx::keyed_player_store>(mc);
+    auto battery_observer = std::get<idx::battery_observer>(mc);
+
+    keyed_player_store->properties.map[0] = multimedia_player;
+    keyed_player_store->properties.map[1] = alarm_player;
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report the battery reaching low.
+    battery_observer->properties.level = media::power::Level::very_low;
+}
+
+TEST(ServiceImplementation, resumes_all_multimedia_sessions_when_battery_critical_notification_is_gone)
+{
+    auto multimedia_player = make_multimedia_player();
+    auto alarm_player = make_alarm_player();
+
+    EXPECT_CALL(*multimedia_player, play()).Times(1);
+    EXPECT_CALL(*alarm_player, play()).Times(0);
+
+    auto mc = make_mocked_configuration();
+
+    auto keyed_player_store = std::get<idx::keyed_player_store>(mc);
+    auto battery_observer = std::get<idx::battery_observer>(mc);
+
+    keyed_player_store->properties.map[0] = multimedia_player;
+    keyed_player_store->properties.map[1] = alarm_player;
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report a critical notification to be shown.
+    battery_observer->properties.is_warning_active = true;
+    // Which is acknowledged by the user, and we subsequently resume playback.
+    battery_observer->properties.is_warning_active = false;
+}
+
+TEST(ServiceImplementation, pauses_all_multimedia_sessions_when_accepting_a_call)
+{
+    auto multimedia_player = make_multimedia_player();
+    auto alarm_player = make_alarm_player();
+
+    EXPECT_CALL(*multimedia_player, pause()).Times(1);
+    EXPECT_CALL(*alarm_player, pause()).Times(0);
+
+    auto mc = make_mocked_configuration();
+
+    auto keyed_player_store = std::get<idx::keyed_player_store>(mc);
+    auto call_monitor = std::get<idx::call_monitor>(mc);
+
+    keyed_player_store->properties.map[0] = multimedia_player;
+    keyed_player_store->properties.map[1] = alarm_player;
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report an incoming call.
+    call_monitor->signals.on_call_state_changed(media::telephony::CallMonitor::State::OnHook);
+}
+
+TEST(ServiceImplementation, resumes_all_paused_multimedias_session_when_accepting_a_call)
+{
+    auto multimedia_player1 = make_multimedia_player();
+    auto multimedia_player2 = make_multimedia_player();
+    multimedia_player2->playback_status() = media::Player::PlaybackStatus::stopped;
+    auto alarm_player = make_alarm_player();
+
+    EXPECT_CALL(*multimedia_player1, pause()).Times(1);
+    EXPECT_CALL(*multimedia_player2, pause()).Times(0);
+    EXPECT_CALL(*alarm_player, pause()).Times(0);
+
+    EXPECT_CALL(*multimedia_player1, play()).Times(1);
+    EXPECT_CALL(*multimedia_player2, play()).Times(0);
+    EXPECT_CALL(*alarm_player, play()).Times(0);
+
+    auto mc = make_mocked_configuration();
+
+    auto keyed_player_store = std::get<idx::keyed_player_store>(mc);
+    auto call_monitor = std::get<idx::call_monitor>(mc);
+
+    keyed_player_store->properties.map[0] = multimedia_player1;
+    keyed_player_store->properties.map[1] = multimedia_player2;
+    keyed_player_store->properties.map[2] = alarm_player;
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    // We report an incoming call.
+    call_monitor->signals.on_call_state_changed(media::telephony::CallMonitor::State::OnHook);
+    // That is terminated afterwards.
+    call_monitor->signals.on_call_state_changed(media::telephony::CallMonitor::State::OffHook);
+}
+
+TEST(ServiceImplementation, calls_into_engine_factory_when_creating_a_session)
+{
+    using namespace ::testing;
+
+    auto engine = std::make_shared<MockEngine>();
+
+    auto mc = make_mocked_configuration();
+    auto engine_factory = std::get<idx::engine_factory>(mc);
+
+    EXPECT_CALL(*engine_factory, make_engine())
+            .Times(1).WillRepeatedly(Return(engine));
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+
+    impl->create_session(media::Player::Configuration{core::dbus::types::ObjectPath::root(), 42});
+}
+
+TEST(ServiceImplementation, hands_down_correct_player_key_when_creating_a_session)
+{
+    using namespace ::testing;
+
+    auto mc = make_mocked_configuration();
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+    auto session = impl->create_session(media::Player::Configuration{core::dbus::types::ObjectPath::root(), 42});
+
+    EXPECT_EQ(42, session->key());
+}
+
+// Fails right now, thus disabling it. We have to investigate why the player is not correctly removed from
+// the player store.
+TEST(ServiceImplementation, DISABLED_subscribes_to_on_client_disconnected_signal_and_removes_disconnected_clients_from_store)
+{
+    using namespace ::testing;
+
+    auto mc = make_mocked_configuration();
+
+    auto player_store = std::get<idx::keyed_player_store>(mc);
+    auto client_death_observer = std::get<idx::death_observer>(mc);
+
+    EXPECT_CALL(*player_store, remove_player_for_key(the_player_key)).Times(1);
+
+    auto impl = media::ServiceImplementation::create(tie_to_mocked_configuration(mc));
+    auto session = impl->create_session(media::Player::Configuration
+    {
+        core::dbus::types::ObjectPath::root(), the_player_key
+    });
+
+    client_death_observer->signals.on_client_with_key_died(the_player_key);
+}

=== added directory 'tests/mock'
=== added file 'tests/mock/client_death_observer.h'
--- tests/mock/client_death_observer.h	1970-01-01 00:00:00 +0000
+++ tests/mock/client_death_observer.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2014 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 MOCK_CLIENT_DEATH_OBSERVER_H_
+#define MOCK_CLIENT_DEATH_OBSERVER_H_
+
+#include <core/media/client_death_observer.h>
+
+#include <gmock/gmock.h>
+
+struct MockClientDeathObserver : public core::ubuntu::media::ClientDeathObserver
+{
+    MockClientDeathObserver()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, on_client_with_key_died())
+                .WillByDefault(ReturnRef(signals.on_client_with_key_died));
+    }
+
+    // Registers the client with the given key for death notifications.
+    MOCK_METHOD1(register_for_death_notifications_with_key, void(const core::ubuntu::media::Player::PlayerKey&));
+    // Emitted whenver a client dies, reporting the key under which the
+    // respective client was known.
+    MOCK_CONST_METHOD0(on_client_with_key_died, const core::Signal<core::ubuntu::media::Player::PlayerKey>&());
+
+    struct
+    {
+        core::Signal<core::ubuntu::media::Player::PlayerKey> on_client_with_key_died;
+    } signals;
+};
+
+#endif // MOCK_CLIENT_DEATH_OBSERVER_H_

=== added file 'tests/mock/engine.h'
--- tests/mock/engine.h	1970-01-01 00:00:00 +0000
+++ tests/mock/engine.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2014 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 MOCK_ENGINE_H_
+#define MOCK_ENGINE_H_
+
+#include <core/media/base_engine.h>
+
+#include <gmock/gmock.h>
+
+#include <chrono>
+
+struct MockEngine : public core::ubuntu::media::BaseEngine
+{
+    MockEngine()
+    {
+        using namespace ::testing;
+
+        mutable_is_audio_source().install([this]() -> bool
+        {
+            return read_is_audio();
+        });
+
+        mutable_is_video_source().install([this]() -> bool
+        {
+            return read_is_video();
+        });
+
+        mutable_duration().install([this]() -> std::uint64_t
+        {
+            return read_duration();
+        });
+
+        ON_CALL(*this, reset())
+                .WillByDefault(Invoke(this, &MockEngine::do_reset));
+    }
+
+    // Pull out to make accessible to test cases.
+    using BaseEngine::mutable_state;
+    using BaseEngine::mutable_is_audio_source;
+    using BaseEngine::mutable_is_video_source;
+    using BaseEngine::mutable_duration;
+
+    MOCK_METHOD0(read_duration, std::uint64_t());
+    MOCK_METHOD0(read_is_audio, bool());
+    MOCK_METHOD0(read_is_video, bool());
+
+    // Dependency resolving
+    MOCK_CONST_METHOD0(meta_data_extractor, const std::shared_ptr<core::ubuntu::media::Engine::MetaDataExtractor>&());
+    // Functional part of the interface.
+    MOCK_METHOD1(open_resource_for_uri, bool(const core::ubuntu::media::Track::UriType&));
+    MOCK_METHOD1(create_video_sink, void(uint32_t));
+    MOCK_METHOD0(play, bool());
+    MOCK_METHOD0(stop, bool());
+    MOCK_METHOD0(pause, bool());
+    MOCK_METHOD1(seek_to, bool(const std::chrono::microseconds&));
+    MOCK_METHOD0(reset, void());
+
+    void do_reset()
+    {
+        // This is ugly and relies on implementation-specific behavior.
+        // We should refactor PlayerImplementation to manually emit the
+        // signal.
+        mutable_client_disconnected_signal();
+    }
+};
+
+#endif // MOCK_ENGINE_H_

=== added file 'tests/mock/keyed_player_store.h'
--- tests/mock/keyed_player_store.h	1970-01-01 00:00:00 +0000
+++ tests/mock/keyed_player_store.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2014 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 MOCK_KEYED_PLAYER_STORE_H_
+#define MOCK_KEYED_PLAYER_STORE_H_
+
+#include <core/media/keyed_player_store.h>
+
+struct MockKeyedPlayerStore : public core::ubuntu::media::KeyedPlayerStore
+{
+    MockKeyedPlayerStore()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, current_player())
+                .WillByDefault(ReturnRef(properties.current_player));
+        ON_CALL(*this, enumerate_players(_))
+                .WillByDefault(Invoke(this, &MockKeyedPlayerStore::do_enumerate));
+        ON_CALL(*this, player_for_key(_))
+                .WillByDefault(Invoke(this, &MockKeyedPlayerStore::do_player_for_key));
+    }
+
+    MOCK_CONST_METHOD0(current_player, const core::Property<std::shared_ptr<core::ubuntu::media::Player>>&());
+    MOCK_CONST_METHOD1(has_player_for_key, bool(const core::ubuntu::media::Player::PlayerKey& key));
+    MOCK_CONST_METHOD1(player_for_key, std::shared_ptr<core::ubuntu::media::Player>(const core::ubuntu::media::Player::PlayerKey&));
+    MOCK_CONST_METHOD1(enumerate_players, void(const core::ubuntu::media::KeyedPlayerStore::PlayerEnumerator&));
+    MOCK_METHOD2(add_player_for_key, void(const core::ubuntu::media::Player::PlayerKey&, const std::shared_ptr<core::ubuntu::media::Player>&));
+    MOCK_METHOD1(remove_player_for_key, void(const core::ubuntu::media::Player::PlayerKey&));
+    MOCK_METHOD1(set_current_player_for_key, void(const core::ubuntu::media::Player::PlayerKey&));
+
+    void do_enumerate(PlayerEnumerator enumerator) const
+    {
+        for (const auto& pair : properties.map)
+            enumerator(pair.first, pair.second);
+    }
+
+    std::shared_ptr<core::ubuntu::media::Player> do_player_for_key(const core::ubuntu::media::Player::PlayerKey& key)
+    {
+        return properties.map.at(key);
+    }
+
+    struct
+    {
+        std::map<core::ubuntu::media::Player::PlayerKey, std::shared_ptr<core::ubuntu::media::Player>> map;
+        core::Property<std::shared_ptr<core::ubuntu::media::Player>> current_player;
+    } properties;
+};
+
+#endif // MOCK_KEYED_PLAYER_STORE_H_

=== added file 'tests/mock/player.h'
--- tests/mock/player.h	1970-01-01 00:00:00 +0000
+++ tests/mock/player.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2014 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 MOCK_PLAYER_H_
+#define MOCK_PLAYER_H_
+
+#include <core/media/base_player.h>
+
+#include <gmock/gmock.h>
+
+#include <chrono>
+
+struct MockPlayer : public core::ubuntu::media::BasePlayer
+{
+    MockPlayer()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, track_list())
+                .WillByDefault(Return(std::shared_ptr<core::ubuntu::media::TrackList>{}));
+        ON_CALL(*this, key())
+                .WillByDefault(Return(std::numeric_limits<core::ubuntu::media::Player::PlayerKey>::max()));
+        ON_CALL(*this, create_gl_texture_video_sink(_))
+                .WillByDefault(Return(core::ubuntu::media::video::Sink::Ptr{}));
+    }
+
+    // We pull in the non-const overloads from BasePlayer
+    using BasePlayer::can_play;
+    using BasePlayer::playback_status;
+    using BasePlayer::can_play;
+    using BasePlayer::can_pause;
+    using BasePlayer::can_seek;
+    using BasePlayer::can_go_previous;
+    using BasePlayer::can_go_next;
+    using BasePlayer::is_video_source;
+    using BasePlayer::is_audio_source;
+    using BasePlayer::meta_data_for_current_track;
+    using BasePlayer::minimum_playback_rate;
+    using BasePlayer::maximum_playback_rate;
+    using BasePlayer::position;
+    using BasePlayer::duration;
+    using BasePlayer::orientation;
+
+    using BasePlayer::seeked_to;
+    using BasePlayer::end_of_stream;
+    using BasePlayer::video_dimension_changed;
+
+    MOCK_METHOD0(track_list, std::shared_ptr<core::ubuntu::media::TrackList>());
+    MOCK_CONST_METHOD0(key, core::ubuntu::media::Player::PlayerKey());
+    MOCK_METHOD1(create_gl_texture_video_sink, core::ubuntu::media::video::Sink::Ptr(std::uint32_t));
+
+    MOCK_METHOD1(open_uri, bool(const core::ubuntu::media::Track::UriType&));
+    MOCK_METHOD0(next, void());
+    MOCK_METHOD0(previous, void());
+    MOCK_METHOD0(play, void());
+    MOCK_METHOD0(pause, void());
+    MOCK_METHOD0(stop, void());
+    MOCK_METHOD1(seek_to, void(const std::chrono::microseconds&));
+};
+#endif // MOCK_PLAYER_H_

=== added file 'tests/mock/power_state_controller.h'
--- tests/mock/power_state_controller.h	1970-01-01 00:00:00 +0000
+++ tests/mock/power_state_controller.h	2014-11-19 10:23:50 +0000
@@ -0,0 +1,127 @@
+/*
+ * Copyright © 2014 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 MOCK_POWER_STATE_CONTROLLER_H
+#define MOCK_POWER_STATE_CONTROLLER_H
+
+#include <core/media/power/state_controller.h>
+
+#include <gmock/gmock.h>
+
+struct MockPowerStateController : public core::ubuntu::media::power::StateController
+{
+    // We really would like to use a templated approach here. However, Google Mock lacks
+    // a typename and the resulting error message for resolving the result type is:
+    //   player_implementation_test.cpp:70:9: error: need 'typename' before 'testing::internal::Function<void(State)>::Result' because 'testing::internal::Function<void(State)>' is a dependent scope
+    //   MOCK_METHOD1(request_acquire, void(State));
+    // With that, just replicate the class.
+    struct DisplayStateLock : public core::ubuntu::media::power::StateController::Lock<core::ubuntu::media::power::DisplayState>
+    {
+        // Save us some typing here.
+        typedef std::shared_ptr<MockPowerStateController::DisplayStateLock> Ptr;
+
+        DisplayStateLock()
+        {
+            using namespace ::testing;
+
+            ON_CALL(*this, acquired())
+                    .WillByDefault(ReturnRef(signals.acquired));
+            ON_CALL(*this, acquired())
+                    .WillByDefault(ReturnRef(signals.released));
+        }
+
+        // Informs the system that the caller would like
+        // the system to stay active.
+        MOCK_METHOD1(request_acquire, void(core::ubuntu::media::power::DisplayState));
+        // Informs the system that the caller does not
+        // require the system to stay active anymore.
+        MOCK_METHOD1(request_release, void(core::ubuntu::media::power::DisplayState));
+
+        // Emitted whenever the acquire request completes.
+        MOCK_CONST_METHOD0(acquired, const core::Signal<core::ubuntu::media::power::DisplayState>&());
+        // Emitted whenever the release request completes.
+        MOCK_CONST_METHOD0(released, const core::Signal<core::ubuntu::media::power::DisplayState>&());
+
+        struct
+        {
+            core::Signal<core::ubuntu::media::power::DisplayState> acquired;
+            core::Signal<core::ubuntu::media::power::DisplayState> released;
+        } signals;
+    };
+
+    struct SystemStateLock : public core::ubuntu::media::power::StateController::Lock<core::ubuntu::media::power::SystemState>
+    {
+        // Save us some typing here.
+        typedef std::shared_ptr<MockPowerStateController::SystemStateLock> Ptr;
+
+        SystemStateLock()
+        {
+            using namespace ::testing;
+
+            ON_CALL(*this, acquired())
+                    .WillByDefault(ReturnRef(signals.acquired));
+            ON_CALL(*this, acquired())
+                    .WillByDefault(ReturnRef(signals.released));
+        }
+
+        // Informs the system that the caller would like
+        // the system to stay active.
+        MOCK_METHOD1(request_acquire, void(core::ubuntu::media::power::SystemState));
+        // Informs the system that the caller does not
+        // require the system to stay active anymore.
+        MOCK_METHOD1(request_release, void(core::ubuntu::media::power::SystemState));
+
+        // Emitted whenever the acquire request completes.
+        MOCK_CONST_METHOD0(acquired, const core::Signal<core::ubuntu::media::power::SystemState>&());
+        // Emitted whenever the release request completes.
+        MOCK_CONST_METHOD0(released, const core::Signal<core::ubuntu::media::power::SystemState>&());
+
+        struct
+        {
+            core::Signal<core::ubuntu::media::power::SystemState> acquired;
+            core::Signal<core::ubuntu::media::power::SystemState> released;
+        } signals;
+    };
+
+    MockPowerStateController()
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, display_state_lock())
+                .WillByDefault(Return(display_lock));
+        ON_CALL(*this, system_state_lock())
+                .WillByDefault(Return(system_lock));
+    }
+
+    // Returns a power::StateController::Lock<DisplayState> instance.