Merge lp:~thomas-voss/media-hub/add-display-controller-interface into lp:media-hub

[Thomas Voß]

Factor out functional dependencies into interfaces and implementations.

Factor out functional dependencies into interfaces and implementations.

[lp:~thomas-voss/media-hub/add-display-controller-interface]

96. By Thomas Voß on 2014-11-12

Move around implementation.
Remove no longer needed interfaces and implementations.

97. By Thomas Voß on 2014-11-12

Put the CallMonitor interface into its own namespace.

98. By Thomas Voß on 2014-11-13

Remerge prerequisite branch.

99. By Thomas Voß on 2014-11-13

Make media::RecorderObserver an external dependency.

[Jim Hodapp (jhodapp)]

A lot of code but in general looking good. See my comments inline below. Also, I'd like to see unit tests for all of the new classes that you introduced such as BatteryObserver, StateController, etc.

review: Needs Fixing (code)

[lp:~thomas-voss/media-hub/add-display-controller-interface]

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

Re-merge prerequisite branch.

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

Adjust setup of service instance in acceptance tests.

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

Make ClientDeathObserver instance a dependency passed down through ctors.

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

* Factor out audio output observation into media::audio::OutputObserver.

[ Jim Hodapp ]
* Pause playback when a headphone is unplugged or an A2DP device is
  unpaired (LP: #1368300)
[ Ricardo Mendoza ]
* Pause playback when a headphone is unplugged or an A2DP device is
  unpaired (LP: #1368300)

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

Merge prerequisite branch.

Unmerged revisions

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

Merge prerequisite branch.

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

* Factor out audio output observation into media::audio::OutputObserver.

[ Jim Hodapp ]
* Pause playback when a headphone is unplugged or an A2DP device is
  unpaired (LP: #1368300)
[ Ricardo Mendoza ]
* Pause playback when a headphone is unplugged or an A2DP device is
  unpaired (LP: #1368300)

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.

99. By Thomas Voß on 2014-11-13

Make media::RecorderObserver an external dependency.

98. By Thomas Voß on 2014-11-13

Remerge prerequisite branch.

97. By Thomas Voß on 2014-11-12

Put the CallMonitor interface into its own namespace.

96. By Thomas Voß on 2014-11-12

Move around implementation.
Remove no longer needed interfaces and implementations.

95. By Thomas Voß on 2014-11-12

* Refactor client-facing interfaces to pull out explicit dependency on hybris-based media layer.
[ Ubuntu daily release ]
* New rebuild forced
[ Justin McPherson ]
* #1239432 Music fails to pause on incoming/outgoing calls (LP:
  #1239432)
[ thomas-voss ]
* Bump build dependency on dbus-cpp to pull in exception safe dtor.
  (LP: #1390618)

=== modified file 'include/core/media/service.h'
--- include/core/media/service.h	2014-04-23 19:00:55 +0000
+++ include/core/media/service.h	2014-11-25 11:08:14 +0000
@@ -28,7 +28,7 @@
 {
 namespace media
 {
-class Service : public std::enable_shared_from_this<Service>
+class Service
 {
   public:
     struct Client

=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2014-11-25 11:08:14 +0000
+++ src/core/media/CMakeLists.txt	2014-11-25 11:08:14 +0000
@@ -11,7 +11,7 @@
 
 message(STATUS ${MEDIA_HUB_HEADERS})
 
-add_subdirectory(call-monitor)
+add_subdirectory(telephony)
 
 add_library(
   media-hub-common SHARED
@@ -90,8 +90,16 @@
     hybris_client_death_observer.cpp
     cover_art_resolver.cpp
     engine.cpp
+
+    audio/pulse_audio_output_observer.cpp
+    audio/output_observer.cpp
+
+    power/battery_observer.cpp
+    power/state_controller.cpp
+
     recorder_observer.cpp
     hybris_recorder_observer.cpp
+
     gstreamer/engine.cpp
     gstreamer/playbin.cpp
 

=== added directory 'src/core/media/audio'
=== added file 'src/core/media/audio/output_observer.cpp'
--- src/core/media/audio/output_observer.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/audio/output_observer.cpp	2014-11-25 11:08:14 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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/audio/output_observer.h>
+
+#include <core/media/audio/pulse_audio_output_observer.h>
+
+#include <iostream>
+
+namespace audio = core::ubuntu::media::audio;
+
+std::ostream& audio::operator<<(std::ostream& out, audio::OutputState state)
+{
+    switch (state)
+    {
+    case audio::OutputState::connected:
+        return out << "OutputState::connected";
+    case audio::OutputState::disconnected:
+        return out << "OutputState::disconnected";
+    }
+
+    return out;
+}
+
+audio::OutputObserver::Ptr audio::make_platform_default_output_observer()
+{
+    return std::make_shared<audio::PulseAudioOutputObserver>();
+}

=== added file 'src/core/media/audio/output_observer.h'
--- src/core/media/audio/output_observer.h	1970-01-01 00:00:00 +0000
+++ src/core/media/audio/output_observer.h	2014-11-25 11:08:14 +0000
@@ -0,0 +1,74 @@
+/*
+ * 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_AUDIO_OUTPUT_OBSERVER_H_
+#define CORE_UBUNTU_MEDIA_AUDIO_OUTPUT_OBSERVER_H_
+
+#include <core/property.h>
+
+#include <iosfwd>
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace audio
+{
+// All known states of an audio output.
+enum class OutputState
+{
+    // The output is connected.
+    connected,
+    // The output is disconnected.
+    disconnected,
+};
+
+// Models observation of audio outputs of a device.
+// Right now, we are only interested in monitoring the
+// state of external outputs to react accordingly if
+// wired or bluetooth outputs are connected/disconnected.
+class OutputObserver
+{
+public:
+    // Save us some typing.
+    typedef std::shared_ptr<OutputObserver> Ptr;
+
+    virtual ~OutputObserver() = default;
+
+    // Getable/observable property holding the state of external outputs.
+    virtual const core::Property<OutputState>& external_output_state() const = 0;
+
+protected:
+    OutputObserver() = default;
+    OutputObserver(const OutputObserver&) = delete;
+    OutputObserver& operator=(const OutputObserver&) = delete;
+};
+
+// Pretty prints the given state to the given output stream.
+std::ostream& operator<<(std::ostream&, OutputState);
+
+// Creats a platform default instance for observing audio outputs.
+OutputObserver::Ptr make_platform_default_output_observer();
+}
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_AUDIO_OUTPUT_OBSERVER_H_

=== added file 'src/core/media/audio/pulse_audio_output_observer.cpp'
--- src/core/media/audio/pulse_audio_output_observer.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/audio/pulse_audio_output_observer.cpp	2014-11-25 11:08:14 +0000
@@ -0,0 +1,241 @@
+/*
+ * 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]>
+ *              Ricardo Mendoza <[e-mail]>
+ */
+
+#include <core/media/audio/pulse_audio_output_observer.h>
+
+#include <pulse/pulseaudio.h>
+
+#include <cstdint>
+
+#include <string>
+
+namespace audio = core::ubuntu::media::audio;
+
+namespace
+{
+namespace pa
+{
+static constexpr const char* a2dp_output_prefix{"output-a2dp"};
+static constexpr const char* wired_output_prefix{"output-wired"};
+
+// Wraps a pulseaudio sink
+struct Sink
+{
+    static constexpr const std::int32_t the_invalid_index{-1};
+    static constexpr const std::int32_t the_invalid_port{-1};
+
+    std::int32_t index{the_invalid_index};
+    std::string name{};
+};
+
+typedef std::shared_ptr<pa_threaded_mainloop> ThreadedMainLoopPtr;
+ThreadedMainLoopPtr make_threaded_main_loop()
+{
+    return ThreadedMainLoopPtr
+    {
+        pa_threaded_mainloop_new(),
+        [](pa_threaded_mainloop* ml)
+        {
+            pa_threaded_mainloop_stop(ml);
+            pa_threaded_mainloop_free(ml);
+        }
+    };
+}
+
+typedef std::shared_ptr<pa_context> ContextPtr;
+ContextPtr make_context(ThreadedMainLoopPtr main_loop)
+{
+    return ContextPtr
+    {
+        pa_context_new(pa_threaded_mainloop_get_api(main_loop.get()), "MediaHubPulseContext"),
+        pa_context_unref
+    };
+}
+
+void start_main_loop(ThreadedMainLoopPtr ml)
+{
+    pa_threaded_mainloop_start(ml.get());
+}
+
+void get_index_of_primary_sink_async(ContextPtr ctxt, pa_sink_info_cb_t cb, void* cookie)
+{
+    pa_context_get_sink_info_by_name(ctxt.get(), "sink.primary", cb, cookie);
+}
+
+void get_sink_info_by_index_async(ContextPtr ctxt, std::uint32_t index, pa_sink_info_cb_t cb, void* cookie)
+{
+    pa_context_get_sink_info_by_index(ctxt.get(), index, cb, cookie);
+}
+
+void connect_async(ContextPtr ctxt)
+{
+    pa_context_connect(ctxt.get(), nullptr, static_cast<pa_context_flags_t>(PA_CONTEXT_NOAUTOSPAWN | PA_CONTEXT_NOFAIL), nullptr);
+}
+
+bool is_port_available_on_sink(const pa_sink_info* info, const std::string& port)
+{
+    if (not info)
+        return false;
+
+    for (std::uint32_t i = 0; i < info->n_ports; i++)
+    {
+        if (info->ports[i]->available == PA_PORT_AVAILABLE_NO)
+            continue;
+
+        if (std::string{info->ports[i]->name}.find(port) == 0)
+            return true;
+    }
+
+    return false;
+}
+}
+}
+
+struct audio::PulseAudioOutputObserver::Private
+{
+    static void context_notification_cb(pa_context* ctxt, void* cookie)
+    {
+        if (auto thiz = static_cast<Private*>(cookie))
+        {
+            // Better safe than sorry: Check if we got signaled for the
+            // context we are actually interested in.
+            if (thiz->context.get() != ctxt)
+                return;
+
+            switch (pa_context_get_state(ctxt))
+            {
+            case PA_CONTEXT_READY:
+                thiz->on_context_ready();
+                break;
+            case PA_CONTEXT_FAILED:
+                thiz->on_context_failed();
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    static void context_subscription_cb(pa_context* ctxt, pa_subscription_event_type_t ev, uint32_t idx, void* cookie)
+    {
+        (void) idx;
+
+        if (auto thiz = static_cast<Private*>(cookie))
+        {
+            // Better safe than sorry: Check if we got signaled for the
+            // context we are actually interested in.
+            if (thiz->context.get() != ctxt)
+                return;
+
+            if ((ev & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK)
+                thiz->on_sink_event_with_index(idx);
+        }
+    }
+
+    static void query_for_primary_sink_finished(pa_context* ctxt, const pa_sink_info* si, int eol, void* cookie)
+    {
+        if (eol)
+            return;
+
+        if (auto thiz = static_cast<Private*>(cookie))
+        {
+            // Better safe than sorry: Check if we got signaled for the
+            // context we are actually interested in.
+            if (thiz->context.get() != ctxt)
+                return;
+
+            thiz->on_query_for_primary_sink_finished(si);
+        }
+    }
+
+    Private()
+        : external_output_state{audio::OutputState::disconnected},
+          main_loop{pa::make_threaded_main_loop()},
+          context{pa::make_context(main_loop)}
+    {
+        pa_context_set_state_callback(context.get(), Private::context_notification_cb, this);
+        pa_context_set_subscribe_callback(context.get(), Private::context_subscription_cb, this);
+
+        output.a2dp | external_output_state;
+        output.wired | external_output_state;
+
+        pa::connect_async(context);
+
+    }
+
+    // The connection attempt has been successful and we are connected
+    // to pulseaudio now.
+    void on_context_ready()
+    {
+        pa::get_index_of_primary_sink_async(context, Private::query_for_primary_sink_finished, this);
+    }
+
+    // Either a connection attempt failed, or an existing connection
+    // was unexpectedly terminated.
+    void on_context_failed()
+    {
+        pa::connect_async(context);
+    }
+
+    // Something changed on the sink with index idx.
+    void on_sink_event_with_index(std::int32_t index)
+    {
+        if (index != primary_sink_index)
+            return;
+
+        pa::get_sink_info_by_index_async(context, index, Private::query_for_primary_sink_finished, this);
+    }
+
+    // Query for primary sink finished.
+    void on_query_for_primary_sink_finished(const pa_sink_info* info)
+    {
+        output.wired = pa::is_port_available_on_sink(info, pa::wired_output_prefix)
+                ? media::audio::OutputState::connected
+                : media::audio::OutputState::disconnected;
+
+        output.a2dp = pa::is_port_available_on_sink(info, pa::a2dp_output_prefix)
+                ? media::audio::OutputState::connected
+                : media::audio::OutputState::disconnected;
+
+        primary_sink_index = info->index;
+    }
+
+    core::Property<audio::OutputState> external_output_state;
+
+    pa::ThreadedMainLoopPtr main_loop;
+    pa::ContextPtr context;
+    std::uint32_t primary_sink_index;
+    struct
+    {
+        core::Property<media::audio::OutputState> wired;
+        core::Property<media::audio::OutputState> a2dp;
+    } output;
+};
+
+// Constructs a new instance, or throws std::runtime_error
+// if connection to pulseaudio fails.
+audio::PulseAudioOutputObserver::PulseAudioOutputObserver() : d{new Private{}}
+{
+}
+
+// Getable/observable property holding the state of external outputs.
+const core::Property<audio::OutputState>& audio::PulseAudioOutputObserver::external_output_state() const
+{
+    return d->external_output_state;
+}

=== added file 'src/core/media/audio/pulse_audio_output_observer.h'
--- src/core/media/audio/pulse_audio_output_observer.h	1970-01-01 00:00:00 +0000
+++ src/core/media/audio/pulse_audio_output_observer.h	2014-11-25 11:08:14 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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]>
+ *              Ricardo Mendoza <[e-mail]>
+ */
+#ifndef CORE_UBUNTU_MEDIA_AUDIO_PULSE_AUDIO_OUTPUT_OBSERVER_H_
+#define CORE_UBUNTU_MEDIA_AUDIO_PULSE_AUDIO_OUTPUT_OBSERVER_H_
+
+#include <core/media/audio/output_observer.h>
+
+#include <iosfwd>
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace audio
+{
+// Implements the audio::OutputObserver interface
+// relying on pulse to query the connected ports
+// of the primary card of the system.
+class PulseAudioOutputObserver : public OutputObserver
+{
+public:
+    // Save us some typing.
+    typedef std::shared_ptr<PulseAudioOutputObserver> Ptr;
+
+    // Constructs a new instance, or throws std::runtime_error
+    // if connection to pulseaudio fails.
+    PulseAudioOutputObserver();
+
+    // Getable/observable property holding the state of external outputs.
+    const core::Property<OutputState>& external_output_state() const override;
+
+private:
+    struct Private;
+    std::shared_ptr<Private> d;
+};
+}
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_AUDIO_PULSE_AUDIO_OUTPUT_OBSERVER_H_

=== added file 'src/core/media/dispatcher.h'
--- src/core/media/dispatcher.h	1970-01-01 00:00:00 +0000
+++ src/core/media/dispatcher.h	2014-11-25 11:08:14 +0000
@@ -0,0 +1,38 @@
+/*
+ * 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_DISPATCHER_H_
+#define CORE_UBUNTU_MEDIA_DISPATCHER_H_
+
+#include <functional>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// Functional describing a task to be executed later.
+typedef std::function<void()> Task;
+// Functional describing a Dispatcher that takes tasks
+// and executes them. The implementation is expected to
+// execute the task later, on a different thread.
+typedef std::function<void(Task)> Dispatcher;
+}
+}
+}
+#endif // CORE_UBUNTU_MEDIA_DISPATCHER_H_

=== added file 'src/core/media/external_services.h'
--- src/core/media/external_services.h	1970-01-01 00:00:00 +0000
+++ src/core/media/external_services.h	2014-11-25 11:08:14 +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_EXTERNAL_SERVICES_H_
+#define CORE_UBUNTU_MEDIA_EXTERNAL_SERVICES_H_
+
+#include <core/dbus/bus.h>
+
+#include <core/dbus/asio/executor.h>
+
+#include <boost/asio.hpp>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace helper
+{
+// A helper struct that bundles:
+//   * a dispatcher, i.e., the io_service
+//   * access to the system and session bus
+//
+// In addtion, it allows us to mock out services and
+// for acceptance testing purposes.
+struct ExternalServices
+{
+    ExternalServices(const core::dbus::Bus::Ptr& session, const core::dbus::Bus::Ptr& system)
+        : keep_alive{io_service},
+          session{session},
+          system{system}
+    {
+    }
+
+    ExternalServices()
+        : ExternalServices
+          {
+              core::dbus::Bus::Ptr{new core::dbus::Bus{core::dbus::WellKnownBus::session}},
+              core::dbus::Bus::Ptr{new core::dbus::Bus{core::dbus::WellKnownBus::system}}
+          }
+    {
+        session->install_executor(core::dbus::asio::make_executor(session, io_service));
+        system->install_executor(core::dbus::asio::make_executor(session, io_service));
+    }
+
+
+    void run()
+    {
+        io_service.run();
+    }
+
+    void stop()
+    {
+        io_service.stop();
+    }
+
+    boost::asio::io_service io_service;
+    boost::asio::io_service::work keep_alive;
+
+    core::dbus::Bus::Ptr session;
+    core::dbus::Bus::Ptr system;
+};
+}
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_EXTERNAL_SERVICES_H_

=== removed file 'src/core/media/indicator_power_service.h'
--- src/core/media/indicator_power_service.h	2014-09-05 18:59:48 +0000
+++ src/core/media/indicator_power_service.h	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-/*
- * 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/>.
- *
- *      Author: Jim Hodapp <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include <string>
-
-namespace core
-{
-
-struct IndicatorPower
-{
-    static std::string& name()
-    {
-        static std::string s = "com.canonical.indicator.power.Battery";
-        return s;
-    }
-
-    struct PowerLevel
-    {
-        static std::string name()
-        {
-            static std::string s = "PowerLevel";
-            return s;
-        }
-
-        typedef IndicatorPower Interface;
-        // Possible values: "ok", "low", "very_low", "critical"
-        typedef std::string ValueType;
-        static const bool readable = true;
-        static const bool writable = false;
-    };
-
-    struct IsWarning
-    {
-        static std::string name()
-        {
-            static std::string s = "IsWarning";
-            return s;
-        }
-
-        typedef IndicatorPower Interface;
-        typedef bool ValueType;
-        static const bool readable = true;
-        static const bool writable = false;
-    };
-
-}; // IndicatorPower
-
-}

=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2014-11-25 11:08:14 +0000
+++ src/core/media/player_implementation.cpp	2014-11-25 11:08:14 +0000
@@ -25,8 +25,6 @@
 #include "engine.h"
 #include "track_list_implementation.h"
 
-#include "powerd_service.h"
-#include "unity_screen_service.h"
 #include "gstreamer/engine.h"
 
 #include <memory>
@@ -52,41 +50,25 @@
         WAKELOCK_CLEAR_INVALID
     };
 
-    Private(PlayerImplementation* parent,
-            const dbus::types::ObjectPath& session_path,
-            const std::shared_ptr<media::Service>& service,
-            PlayerImplementation::PlayerKey key)
+    Private(PlayerImplementation* parent, const media::PlayerImplementation::Configuration& config)
         : parent(parent),
-          service(service),
+          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>()),
-          session_path(session_path),
           track_list(
               new media::TrackListImplementation(
-                  session_path.as_string() + "/TrackList",
+                  config.session->path().as_string() + "/TrackList",
                   engine->meta_data_extractor())),
-          sys_lock_name("media-hub-music-playback"),
-          disp_cookie(-1),
           system_wakelock_count(0),
           display_wakelock_count(0),
           previous_state(Engine::State::stopped),
-          key(key),
           engine_state_change_connection(engine->state().changed().connect(make_state_change_handler()))
     {
-        auto bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::system));
-        bus->install_executor(dbus::asio::make_executor(bus));
-
-        auto stub_service = dbus::Service::use_service(bus, dbus::traits::Service<core::Powerd>::interface_name());
-        powerd_session = stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/powerd"));
-
-        auto uscreen_stub_service = dbus::Service::use_service(bus, dbus::traits::Service<core::UScreen>::interface_name());
-        uscreen_session = uscreen_stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/Unity/Screen"));
-
-        auto client_death_observer = media::platform_default_client_death_observer();
-
-        client_death_observer->register_for_death_notifications_with_key(key);
-        client_death_observer->on_client_with_key_died().connect([this](const media::Player::PlayerKey& died)
+        config.client_death_observer->register_for_death_notifications_with_key(config.key);
+        config.client_death_observer->on_client_with_key_died().connect([this](const media::Player::PlayerKey& died)
         {
-            if (died != this->key)
+            if (died != this->config.key)
                 return;
 
             on_client_died();
@@ -169,24 +151,12 @@
             if (parent->is_video_source())
             {
                 if (++display_wakelock_count == 1)
-                {
-                    auto result = uscreen_session->invoke_method_synchronously<core::UScreen::keepDisplayOn, int>();
-                    if (result.is_error())
-                        throw std::runtime_error(result.error().print());
-                    disp_cookie = result.value();
-                    cout << "Requested new display wakelock" << endl;
-                }
+                    display_state_lock->request_acquire(media::power::DisplayState::on);
             }
             else
             {
                 if (++system_wakelock_count == 1)
-                {
-                    auto result = powerd_session->invoke_method_synchronously<core::Powerd::requestSysState, std::string>(sys_lock_name, static_cast<int>(1));
-                    if (result.is_error())
-                        throw std::runtime_error(result.error().print());
-                    sys_cookie = result.value();
-                    cout << "Requested new system wakelock" << endl;
-                }
+                    system_state_lock->request_acquire(media::power::SystemState::active);
             }
         }
         catch(const std::exception& e)
@@ -208,20 +178,12 @@
                 case wakelock_clear_t::WAKELOCK_CLEAR_SYSTEM:
                     // Only actually clear the system wakelock once the count reaches zero
                     if (--system_wakelock_count == 0)
-                    {
-                        cout << "Clearing system wakelock" << endl;
-                        powerd_session->invoke_method_synchronously<core::Powerd::clearSysState, void>(sys_cookie);
-                        sys_cookie.clear();
-                    }
+                        system_state_lock->request_release(media::power::SystemState::active);
                     break;
                 case wakelock_clear_t::WAKELOCK_CLEAR_DISPLAY:
                     // Only actually clear the display wakelock once the count reaches zero
                     if (--display_wakelock_count == 0)
-                    {
-                        cout << "Clearing display wakelock" << endl;
-                        uscreen_session->invoke_method_synchronously<core::UScreen::removeDisplayOnRequest, void>(disp_cookie);
-                        disp_cookie = -1;
-                    }
+                        display_state_lock->request_release(media::power::DisplayState::on);
                     break;
                 case wakelock_clear_t::WAKELOCK_CLEAR_INVALID:
                 default:
@@ -275,44 +237,33 @@
         engine->reset();
     }
 
-    PlayerImplementation* parent;
-    std::shared_ptr<Service> service;
+    // Our link back to our parent.
+    media::PlayerImplementation* parent;
+    // We just store the parameters passed on construction.
+    media::PlayerImplementation::Configuration config;
+    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;
-    dbus::types::ObjectPath session_path;
     std::shared_ptr<TrackListImplementation> track_list;
-    std::shared_ptr<dbus::Object> powerd_session;
-    std::shared_ptr<dbus::Object> uscreen_session;
-    std::string sys_lock_name;
-    int disp_cookie;
-    std::string sys_cookie;
     std::atomic<int> system_wakelock_count;
     std::atomic<int> display_wakelock_count;
     Engine::State previous_state;
-    PlayerImplementation::PlayerKey key;
     core::Signal<> on_client_disconnected;
     core::Connection engine_state_change_connection;
 };
 
-media::PlayerImplementation::PlayerImplementation(
-        const std::string& identity,
-        const std::shared_ptr<core::dbus::Bus>& bus,
-        const std::shared_ptr<core::dbus::Object>& session,
-        const std::shared_ptr<Service>& service,
-        PlayerKey key)
+media::PlayerImplementation::PlayerImplementation(const media::PlayerImplementation::Configuration& config)
     : media::PlayerSkeleton
       {
           media::PlayerSkeleton::Configuration
           {
-              bus,
-              session,
-              identity
+              config.bus,
+              config.session,
+              config.identity
           }
       },
-      d(make_shared<Private>(
-            this,
-            session->path(),
-            service,
-            key))
+      d{std::make_shared<Private>(this, config)}
 {
     // Initialize default values for Player interface properties
     can_play().set(true);
@@ -452,7 +403,7 @@
 // TODO: Convert this to be a property instead of sync call
 media::Player::PlayerKey media::PlayerImplementation::key() const
 {
-    return d->key;
+    return d->config.key;
 }
 
 media::video::Sink::Ptr media::PlayerImplementation::create_gl_texture_video_sink(std::uint32_t texture_id)

=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2014-11-25 11:08:14 +0000
+++ src/core/media/player_implementation.h	2014-11-25 11:08:14 +0000
@@ -21,6 +21,9 @@
 
 #include "player_skeleton.h"
 
+#include "client_death_observer.h"
+#include "power/state_controller.h"
+
 #include <memory>
 
 namespace core
@@ -35,12 +38,21 @@
 class PlayerImplementation : public PlayerSkeleton
 {
 public:
-    PlayerImplementation(
-            const std::string& identity,
-            const std::shared_ptr<core::dbus::Bus>& bus,
-            const std::shared_ptr<core::dbus::Object>& session,
-            const std::shared_ptr<Service>& service,
-            PlayerKey key);
+    // 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;
+        PlayerKey key;
+
+        // Functional dependencies
+        ClientDeathObserver::Ptr client_death_observer;
+        power::StateController::Ptr power_state_controller;
+    };
+
+    PlayerImplementation(const Configuration& configuration);
     ~PlayerImplementation();
 
     virtual std::shared_ptr<TrackList> track_list();

=== added directory 'src/core/media/power'
=== added file 'src/core/media/power/battery_observer.cpp'
--- src/core/media/power/battery_observer.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/power/battery_observer.cpp	2014-11-25 11:08:14 +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]>
+ */
+
+#include <core/media/power/battery_observer.h>
+
+#include <core/dbus/macros.h>
+#include <core/dbus/object.h>
+#include <core/dbus/property.h>
+
+namespace media = core::ubuntu::media;
+
+namespace com { namespace canonical { namespace indicator { namespace power {
+struct Battery
+{
+    static std::string& name()
+    {
+        static std::string s = "com.canonical.indicator.power.Battery";
+        return s;
+    }
+
+    static const core::dbus::types::ObjectPath& path()
+    {
+        static core::dbus::types::ObjectPath p{"/com/canonical/indicator/power/Battery"};
+        return p;
+    }
+
+    // Possible values: "ok", "low", "very_low", "critical"
+    DBUS_CPP_READABLE_PROPERTY_DEF(PowerLevel, Battery, std::string)
+    DBUS_CPP_READABLE_PROPERTY_DEF(IsWarning, Battery, bool)
+}; // IndicatorPower
+}}}}
+
+namespace
+{
+namespace impl
+{
+struct BatteryObserver : public media::power::BatteryObserver
+{
+    static core::ubuntu::media::power::Level power_level_from_string(const std::string& s)
+    {
+        static const std::map<std::string, core::ubuntu::media::power::Level> lut =
+        {
+            {"ok", core::ubuntu::media::power::Level::ok},
+            {"low", core::ubuntu::media::power::Level::low},
+            {"very_low", core::ubuntu::media::power::Level::very_low},
+            {"critical", core::ubuntu::media::power::Level::critical}
+        };
+
+        if (lut.count(s) == 0)
+            return core::ubuntu::media::power::Level::unknown;
+
+        return lut.at(s);
+    }
+
+    BatteryObserver(const core::dbus::Object::Ptr& object)
+        : object{object},
+          properties
+          {
+              core::Property<core::ubuntu::media::power::Level>{core::ubuntu::media::power::Level::unknown},
+              object->get_property<com::canonical::indicator::power::Battery::PowerLevel>(),
+              object->get_property<com::canonical::indicator::power::Battery::IsWarning>(),
+          },
+          connections
+          {
+              properties.power_level->changed().connect([this](const std::string& value)
+              {
+                  properties.typed_power_level = BatteryObserver::power_level_from_string(value);
+              })
+          }
+    {
+    }
+
+    const core::Property<core::ubuntu::media::power::Level>& level() const override
+    {
+        return properties.typed_power_level;
+    }
+
+    const core::Property<bool>& is_warning_active() const override
+    {
+        return *properties.is_warning;
+    }
+
+    // The object representing the remote indicator instance.
+    core::dbus::Object::Ptr object;
+    // All properties go here.
+    struct
+    {
+        // We have to translate from the raw strings coming in via the bus to
+        // the strongly typed enumeration exposed via the interface.
+        core::Property<core::ubuntu::media::power::Level> typed_power_level;
+        std::shared_ptr<core::dbus::Property<com::canonical::indicator::power::Battery::PowerLevel>> power_level;
+
+        std::shared_ptr<core::dbus::Property<com::canonical::indicator::power::Battery::IsWarning>> is_warning;
+    } properties;
+    // Our event connections
+    struct
+    {
+        core::ScopedConnection power_level;
+    } connections;
+
+};
+}
+}
+
+media::power::BatteryObserver::Ptr media::power::make_platform_default_battery_observer(media::helper::ExternalServices& es)
+{
+    auto service = core::dbus::Service::use_service<com::canonical::indicator::power::Battery>(es.session);
+    auto object = service->object_for_path(com::canonical::indicator::power::Battery::path());
+
+    return std::make_shared<impl::BatteryObserver>(object);
+}
+

=== added file 'src/core/media/power/battery_observer.h'
--- src/core/media/power/battery_observer.h	1970-01-01 00:00:00 +0000
+++ src/core/media/power/battery_observer.h	2014-11-25 11:08:14 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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_POWER_STATE_OBSERVER_H_
+#define CORE_UBUNTU_MEDIA_POWER_STATE_OBSERVER_H_
+
+#include <core/media/external_services.h>
+
+#include <core/property.h>
+
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace power
+{
+// Enumerates known power levels.
+enum class Level
+{
+    unknown,
+    ok,
+    low,
+    very_low,
+    critical
+};
+
+// Interface that enables observation of the system power state.
+struct BatteryObserver
+{
+    // To safe us some typing.
+    typedef std::shared_ptr<BatteryObserver> Ptr;
+
+    BatteryObserver() = default;
+    virtual ~BatteryObserver() = default;
+
+    // A getable/observable property reporting the current power-level
+    // of the system.
+    virtual const core::Property<Level>& level() const = 0;
+    // A getable/observable property indicating whether a power-level
+    // warning is currently presented to the user.
+    virtual const core::Property<bool>& is_warning_active() const = 0;
+};
+
+// Creates a BatteryObserver instance that connects to the platform default
+// services to observe battery levels.
+core::ubuntu::media::power::BatteryObserver::Ptr make_platform_default_battery_observer(core::ubuntu::media::helper::ExternalServices&);
+}
+}
+}
+}
+#endif // CORE_UBUNTU_MEDIA_POWER_STATE_OBSERVER_H_

=== added file 'src/core/media/power/state_controller.cpp'
--- src/core/media/power/state_controller.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/power/state_controller.cpp	2014-11-25 11:08:14 +0000
@@ -0,0 +1,302 @@
+/*
+ * 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/power/state_controller.h>
+
+#include <core/dbus/macros.h>
+#include <core/dbus/object.h>
+
+namespace media = core::ubuntu::media;
+
+namespace com { namespace canonical {
+struct Unity
+{
+    struct Screen
+    {
+        static const std::string& name()
+        {
+            static std::string s = "com.canonical.Unity.Screen";
+            return s;
+        }
+
+        static const core::dbus::types::ObjectPath& path()
+        {
+            static core::dbus::types::ObjectPath p{"/com/canonical/Unity/Screen"};
+            return p;
+        }
+
+        DBUS_CPP_METHOD_DEF(keepDisplayOn, Screen)
+        DBUS_CPP_METHOD_DEF(removeDisplayOnRequest, Screen)
+    };
+};
+namespace powerd {
+struct Interface
+{
+    static std::string& name()
+    {
+        static std::string s = "com.canonical.powerd";
+        return s;
+    }
+
+    static const core::dbus::types::ObjectPath& path()
+    {
+        static core::dbus::types::ObjectPath p{"/com/canonical/powerd"};
+        return p;
+    }
+
+    DBUS_CPP_METHOD_DEF(requestSysState, com::canonical::powerd::Interface)
+    DBUS_CPP_METHOD_DEF(clearSysState, com::canonical::powerd::Interface)
+};
+}}}
+
+namespace
+{
+namespace impl
+{
+struct DisplayStateLock : public media::power::StateController::Lock<media::power::DisplayState>,
+                          public std::enable_shared_from_this<DisplayStateLock>
+{
+    // To safe us some typing
+    typedef std::shared_ptr<DisplayStateLock> Ptr;
+
+    // We postpone releasing the display for this amount of time.
+    static boost::posix_time::seconds timeout_for_release()
+    {
+        return boost::posix_time::seconds{4};
+    }
+
+    // The invalid cookie marker.
+    static constexpr const std::int32_t the_invalid_cookie{-1};
+
+    DisplayStateLock(const media::power::StateController::Ptr& parent,
+                     boost::asio::io_service& io_service,
+                     const core::dbus::Object::Ptr& object)
+        : parent{parent},
+          timeout{io_service},
+          object{object},
+          cookie{the_invalid_cookie}
+    {
+    }
+
+    // From core::ubuntu::media::power::StateController::Lock<DisplayState>
+    void request_acquire(media::power::DisplayState state) override
+    {
+        if (state == media::power::DisplayState::off)
+            return;
+
+        std::weak_ptr<DisplayStateLock> wp{shared_from_this()};
+
+        object->invoke_method_asynchronously_with_callback<com::canonical::Unity::Screen::keepDisplayOn, std::int32_t>([wp, state](const core::dbus::Result<std::int32_t>& result)
+        {
+            if (result.is_error()) // We should at least log the error case here.
+                return;
+
+            if (auto sp = wp.lock())
+            {
+                sp->cookie = result.value();
+                sp->signals.acquired(state);
+            }
+        });
+    }
+
+    void request_release(media::power::DisplayState state) override
+    {
+        if (state == media::power::DisplayState::off)
+            return;
+
+        if (cookie == the_invalid_cookie)
+            return;
+
+        std::weak_ptr<DisplayStateLock> wp{shared_from_this()};
+
+        auto current_cookie(cookie);
+
+        timeout.expires_from_now(timeout_for_release());
+        timeout.async_wait([wp, state, current_cookie](const boost::system::error_code& ec)
+        {
+            if (not ec)
+            {
+                if (auto sp = wp.lock())
+                {
+                    sp->object->invoke_method_asynchronously_with_callback<com::canonical::Unity::Screen::removeDisplayOnRequest, void>([wp, state, current_cookie](const core::dbus::Result<void>& result)
+                    {
+                        if (result.is_error()) // We should at least log the error case here.
+                            return;
+
+                        if (auto sp = wp.lock())
+                        {
+                            sp->signals.released(state);
+
+                            // We might have issued a different request before and
+                            // only call the display state done if the original cookie
+                            // corresponds to the one we just gave up.
+                            if (sp->cookie == current_cookie)
+                                sp->cookie = the_invalid_cookie;
+                        }
+
+                    }, current_cookie);
+                }
+            }
+        });
+    }
+
+    // Emitted whenever the acquire request completes.
+    const core::Signal<media::power::DisplayState>& acquired() const override
+    {
+        return signals.acquired;
+    }
+
+    // Emitted whenever the release request completes.
+    const core::Signal<media::power::DisplayState>& released() const override
+    {
+        return signals.released;
+    }
+
+    media::power::StateController::Ptr parent;
+    boost::asio::deadline_timer timeout;
+    core::dbus::Object::Ptr object;
+    std::int32_t cookie;
+
+    struct
+    {
+        core::Signal<media::power::DisplayState> acquired;
+        core::Signal<media::power::DisplayState> released;
+    } signals;
+};
+
+struct SystemStateLock : public media::power::StateController::Lock<media::power::SystemState>
+{
+    static constexpr const char* wake_lock_name
+    {
+        "media-hub-playback_lock"
+    };
+
+    SystemStateLock(const media::power::StateController::Ptr& parent, const core::dbus::Object::Ptr& object)
+        : parent{parent},
+          object{object}
+    {
+    }
+
+    // Informs the system that the caller would like
+    // the system to stay active.
+    void request_acquire(media::power::SystemState state) override
+    {
+        if (state == media::power::SystemState::suspend)
+            return;
+
+        std::lock_guard<std::mutex> lg{cookie_store_guard};
+        if (cookie_store.count(state) > 0)
+            return;
+
+        object->invoke_method_asynchronously_with_callback<com::canonical::powerd::Interface::requestSysState, std::string>([this, state](const core::dbus::Result<std::string>& result)
+        {
+            if (result.is_error()) // TODO(tvoss): We should log the error condition here.
+                return;
+
+            std::lock_guard<std::mutex> lg{cookie_store_guard};
+
+            cookie_store[state] = result.value();
+            signals.acquired(state);
+        }, std::string{wake_lock_name}, static_cast<std::int32_t>(state));
+    }
+
+    // Informs the system that the caller does not
+    // require the system to stay active anymore.
+    void request_release(media::power::SystemState state) override
+    {
+        if (state == media::power::SystemState::suspend)
+            return;
+
+        std::lock_guard<std::mutex> lg{cookie_store_guard};
+
+        if (cookie_store.count(state) == 0)
+            return;
+
+        object->invoke_method_asynchronously_with_callback<com::canonical::powerd::Interface::clearSysState, void>([this, state](const core::dbus::Result<void>& result)
+        {
+            if (result.is_error()) {/*TODO(tvoss): We should log the error condition here.*/}
+
+            std::lock_guard<std::mutex> lg{cookie_store_guard};
+
+            cookie_store.erase(state);
+            signals.released(state);
+        }, cookie_store.at(state));
+    }
+
+    // Emitted whenever the acquire request completes.
+    const core::Signal<media::power::SystemState>& acquired() const override
+    {
+        return signals.acquired;
+    }
+
+    // Emitted whenever the release request completes.
+    const core::Signal<media::power::SystemState>& released() const override
+    {
+        return signals.released;
+    }
+
+    std::mutex cookie_store_guard;
+    std::map<media::power::SystemState, std::string> cookie_store;
+    media::power::StateController::Ptr parent;
+    core::dbus::Object::Ptr object;
+    struct
+    {
+        core::Signal<media::power::SystemState> acquired;
+        core::Signal<media::power::SystemState> released;
+    } signals;
+};
+
+struct StateController : public media::power::StateController,
+                         public std::enable_shared_from_this<impl::StateController>
+{
+    StateController(media::helper::ExternalServices& es)
+        : external_services{es},
+          powerd
+          {
+              core::dbus::Service::use_service<com::canonical::powerd::Interface>(external_services.system)
+                  ->object_for_path(com::canonical::powerd::Interface::path())
+          },
+          unity_screen
+          {
+              core::dbus::Service::use_service<com::canonical::Unity::Screen>(external_services.system)
+                  ->object_for_path(com::canonical::Unity::Screen::path())
+          }
+    {
+    }
+
+    media::power::StateController::Lock<media::power::SystemState>::Ptr system_state_lock() override
+    {
+        return std::make_shared<impl::SystemStateLock>(shared_from_this(), powerd);
+    }
+
+    media::power::StateController::Lock<media::power::DisplayState>::Ptr display_state_lock() override
+    {
+        return std::make_shared<impl::DisplayStateLock>(shared_from_this(), external_services.io_service, unity_screen);
+    }
+
+    media::helper::ExternalServices& external_services;
+    core::dbus::Object::Ptr powerd;
+    core::dbus::Object::Ptr unity_screen;
+};
+}
+}
+
+media::power::StateController::Ptr media::power::make_platform_default_state_controller(core::ubuntu::media::helper::ExternalServices& external_services)
+{
+    return std::make_shared<impl::StateController>(external_services);
+}

=== added file 'src/core/media/power/state_controller.h'
--- src/core/media/power/state_controller.h	1970-01-01 00:00:00 +0000
+++ src/core/media/power/state_controller.h	2014-11-25 11:08:14 +0000
@@ -0,0 +1,102 @@
+/*
+ * 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_POWER_STATE_CONTROLLER_H_
+#define CORE_UBUNTU_MEDIA_POWER_STATE_CONTROLLER_H_
+
+#include <core/media/external_services.h>
+
+#include <core/property.h>
+
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace power
+{
+// Enumerates all known power states of a display.
+enum class DisplayState
+{
+    // The display is off.
+    off = 0,
+    // The display is on.
+    on = 1
+};
+
+// Enumerates known power states of the system.
+enum class SystemState
+{
+    // Note that callers will be notified of suspend state changes
+    // but may not request this state.
+    suspend = 0,
+    // The Active state will prevent system suspend
+    active = 1,
+    // Substate of Active with disabled proximity based blanking
+    blank_on_proximity = 2
+};
+
+// Interface that enables observation of the system power state.
+struct StateController
+{
+    // To safe us some typing.
+    typedef std::shared_ptr<StateController> Ptr;
+
+    // When acquired, ensures that the system stays active,
+    // and decreases the reference count when released.
+    template<typename State>
+    struct Lock
+    {
+        // To safe us some typing.
+        typedef std::shared_ptr<Lock> Ptr;
+
+        Lock() = default;
+        virtual ~Lock() = default;
+
+        // Informs the system that the caller would like
+        // the system to stay active.
+        virtual void request_acquire(State state) = 0;
+        // Informs the system that the caller does not
+        // require the system to stay active anymore.
+        virtual void request_release(State state) = 0;
+
+        // Emitted whenever the acquire request completes.
+        virtual const core::Signal<State>& acquired() const = 0;
+        // Emitted whenever the release request completes.
+        virtual const core::Signal<State>& released() const = 0;
+    };
+
+    StateController() = default;
+    virtual ~StateController() = default;
+
+    // Returns a power::StateController::Lock<DisplayState> instance.
+    virtual Lock<DisplayState>::Ptr display_state_lock() = 0;
+    // Returns a power::StateController::Lock<SystemState> instance.
+    virtual Lock<SystemState>::Ptr system_state_lock() = 0;
+};
+
+// 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&);
+}
+}
+}
+}
+#endif // CORE_UBUNTU_MEDIA_POWER_STATE_CONTROLLER_H_

=== removed file 'src/core/media/powerd_service.h'
--- src/core/media/powerd_service.h	2014-08-08 14:36:29 +0000
+++ src/core/media/powerd_service.h	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-/*
- * 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/>.
- *
- *      Author: Ricardo Mendoza <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include <string>
-#include <vector>
-#include <chrono>
-
-namespace core
-{
-
-struct Powerd
-{
-    static std::string& name()
-    {
-        static std::string s = "com.canonical.powerd";
-        return s;
-    }
-
-    struct requestSysState
-    {
-        static std::string name()
-        {
-            static std::string s = "requestSysState";
-            return s;
-        }
-
-        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-
-        typedef Powerd Interface;
-    };
-
-    struct clearSysState
-    {
-        static std::string name()
-        {
-            static std::string s = "clearSysState";
-            return s;
-        }
-
-        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-
-        typedef Powerd Interface;
-    };
-
-};
-
-}

=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2014-11-25 11:08:14 +0000
+++ src/core/media/server/server.cpp	2014-11-25 11:08:14 +0000
@@ -20,8 +20,12 @@
 #include <core/media/player.h>
 #include <core/media/track_list.h>
 
+#include <core/posix/signal.h>
+
 #include "core/media/service_implementation.h"
 
+#include "core/media/audio/pulse_audio_output_observer.h"
+
 #include <iostream>
 
 namespace media = core::ubuntu::media;
@@ -52,12 +56,104 @@
 
 int main()
 {
+    auto trap = core::posix::trap_signals_for_all_subsequent_threads(
+    {
+        core::posix::Signal::sig_int,
+        core::posix::Signal::sig_term
+    });
+
+    trap->signal_raised().connect([trap](core::posix::Signal)
+    {
+        trap->stop();
+    });
+
+    // Init platform-specific functionality.
     platform_init();
 
     cout << "Starting DecodingService..." << endl;
 
-    auto service = std::make_shared<media::ServiceImplementation>();
-    service->run();
+    // We keep track of our state.
+    bool shutdown_requested{false};
+
+    // Our helper for connecting to external services.
+    core::ubuntu::media::helper::ExternalServices external_services;
+
+    std::thread external_services_worker
+    {
+        [&shutdown_requested, &external_services]()
+        {
+            while (not shutdown_requested)
+            {
+                try
+                {
+                    external_services.io_service.run();
+                }
+                catch (const std::exception& e)
+                {
+                    std::cerr << "Error while executing the underlying io_service: " << e.what() << std::endl;
+                }
+                catch (...)
+                {
+                    std::cerr << "Error while executing the underlying io_service." << std::endl;
+                }
+            }
+        }
+    };
+
+    // We assemble the configuration for executing the service now.
+    media::ServiceImplementation::Configuration service_config
+    {
+        [&external_services](core::ubuntu::media::Task task)
+        {
+            external_services.io_service.post(task);
+        },
+        media::platform_default_client_death_observer(),
+        media::make_platform_default_recorder_observer(),
+        media::audio::make_platform_default_output_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);
+
+    std::thread service_worker
+    {
+        [&shutdown_requested, service]()
+        {
+            while (not shutdown_requested)
+            {
+                try
+                {
+                    service->run();
+                }
+                catch (const std::exception& e)
+                {
+                    std::cerr << "Recoverable error while executing the service: " << e.what() << std::endl;
+                }
+                catch (...)
+                {
+                    std::cerr << "Recoverable error while executing the service." << std::endl;
+                }
+            }
+        }
+    };
+
+    // We block on waiting for signals telling us to gracefully shutdown.
+    trap->run();
+
+    // Inform our workers that we should shutdown gracefully
+    shutdown_requested = true;
+
+    // And stop execution of helper and actual service.
+    external_services.stop();
+    service->stop();
+
+    if (external_services_worker.joinable())
+        external_services_worker.join();
+
+    if (service_worker.joinable())
+        service_worker.join();
 
     return 0;
 }

=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2014-11-25 11:08:14 +0000
+++ src/core/media/service_implementation.cpp	2014-11-25 11:08:14 +0000
@@ -22,11 +22,8 @@
 
 #include "service_implementation.h"
 
-#include "indicator_power_service.h"
-#include "call-monitor/call_monitor.h"
 #include "player_configuration.h"
 #include "player_implementation.h"
-#include "recorder_observer.h"
 
 #include <boost/asio.hpp>
 
@@ -40,7 +37,6 @@
 #include <pulse/pulseaudio.h>
 
 #include "util/timeout.h"
-#include "unity_screen_service.h"
 
 namespace media = core::ubuntu::media;
 
@@ -48,462 +44,117 @@
 
 struct media::ServiceImplementation::Private
 {
-    Private()
-        : resume_key(std::numeric_limits<std::uint32_t>::max()),
-          keep_alive(io_service),
-          disp_cookie(0),
-          pulse_mainloop_api(nullptr),
-          pulse_context(nullptr),
-          headphones_connected(false),
-          a2dp_connected(false),
-          primary_idx(-1),
-          call_monitor(new CallMonitor)
-    {
-        bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::session));
-        bus->install_executor(dbus::asio::make_executor(bus, io_service));
-        worker = std::move(std::thread([this]()
-        {
-            bus->run();
-        }));
-
-        // Spawn pulse watchdog
-        pulse_mainloop = nullptr;
-        pulse_worker = std::move(std::thread([this]()
-        {
-            std::unique_lock<std::mutex> lk(pulse_mutex);
-            pcv.wait(lk,
-                [this]{
-                    if (pulse_mainloop != nullptr || pulse_context != nullptr)
-                    {
-                        // We come from instance death, destroy and create.
-                        if (pulse_context != nullptr)
-                        {
-                            pa_threaded_mainloop_lock(pulse_mainloop);
-                            pa_operation *o;
-                            o = pa_context_drain(pulse_context,
-                                [](pa_context *context, void *userdata)
-                                {
-                                    (void) context;
-
-                                    Private *p = reinterpret_cast<Private*>(userdata);
-                                    pa_threaded_mainloop_signal(p->mainloop(), 0);
-                                }, this);
-                            
-                            if (o)
-                            {
-                                while (pa_operation_get_state(o) == PA_OPERATION_RUNNING)
-                                    pa_threaded_mainloop_wait(pulse_mainloop);
-
-                                pa_operation_unref(o);
-                            }
-
-                            pa_context_set_state_callback(pulse_context, NULL, NULL);
-                            pa_context_set_subscribe_callback(pulse_context, NULL, NULL);
-                            pa_context_disconnect(pulse_context);
-                            pa_context_unref(pulse_context);
-                            pulse_context = nullptr;
-                            pa_threaded_mainloop_unlock(pulse_mainloop);
-                        }
-                    }
-        
-                    if (pulse_mainloop == nullptr)
-                    {
-                        pulse_mainloop = pa_threaded_mainloop_new();
-
-                        if (pa_threaded_mainloop_start(pulse_mainloop) != 0)
-                        {
-                            std::cerr << "Unable to start pulseaudio mainloop, audio output detection will not function" << std::endl;
-                            pa_threaded_mainloop_free(pulse_mainloop);
-                            pulse_mainloop = nullptr;
-                        }
-                    }
-                  
-                    do {
-                        create_pulse_context();
-                    } while (pulse_context == nullptr);
-                    
-                    // Wait for next instance death.
-                    return false;
-                });
-        }));
-        
-        // Connect the property change signal that will allow media-hub to take appropriate action
-        // when the battery level reaches critical
-        auto stub_service = dbus::Service::use_service(bus, "com.canonical.indicator.power");
-        indicator_power_session = stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/indicator/power/Battery"));
-        power_level = indicator_power_session->get_property<core::IndicatorPower::PowerLevel>();
-        is_warning = indicator_power_session->get_property<core::IndicatorPower::IsWarning>();
-
-        // Obtain session with Unity.Screen so that we request state when doing recording
-        auto bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::system));
-        bus->install_executor(dbus::asio::make_executor(bus));
-
-        auto uscreen_stub_service = dbus::Service::use_service(bus, dbus::traits::Service<core::UScreen>::interface_name());
-        uscreen_session = uscreen_stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/Unity/Screen"));
-
-        recorder_observer = media::make_platform_default_recorder_observer();
-        recorder_observer->recording_state().changed().connect([this](media::RecordingState state)
-        {
-            media_recording_state_changed(state);
-        });
+    Private(ServiceImplementation& parent, const media::ServiceImplementation::Configuration& config)
+        : resume_key{std::numeric_limits<std::uint32_t>::max()},
+          parent{parent},
+          dispatcher{config.dispatcher},
+          display_state_lock{config.power_state_controller->display_state_lock()},
+          power_state_controller{config.power_state_controller},
+          power_state_observer{config.power_state_observer},
+          audio_output_observer{config.audio_output_observer},
+          call_monitor(config.call_monitor),
+          client_death_observer(config.client_death_observer),
+          recorder_observer(config.recorder_observer),
+          connections          
+          {
+              power_state_observer->level().changed().connect([this](const core::ubuntu::media::power::Level& level)
+              {
+                  // When the battery level hits 10% or 5%, pause all multimedia sessions.
+                  // Playback will resume when the user clears the presented notification.
+                  switch (level)
+                  {
+                  case core::ubuntu::media::power::Level::low:
+                  case core::ubuntu::media::power::Level::very_low:
+                      this->parent.pause_all_multimedia_sessions();
+                      break;
+                  default:
+                      break;
+                  }
+              }),
+              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();
+              }),
+              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();
+                      break;
+                  case media::telephony::CallMonitor::OnHook:
+                      this->parent.resume_paused_multimedia_sessions();
+                      break;
+                  }
+              }),
+              recorder_observer->recording_state().changed().connect([this](media::RecordingState state)
+              {
+                  media_recording_state_changed(state);
+              }),
+              audio_output_observer->external_output_state().changed().connect([this](media::audio::OutputState state)
+              {
+                    switch (state)
+                    {
+                    case media::audio::OutputState::disconnected:
+                        this->parent.pause_all_multimedia_sessions();
+                        break;
+                    case media::audio::OutputState::connected:
+                        break;
+                    }
+              })
+          }
+    {        
     }
 
     ~Private()
-    {
-        release_pulse_context();
-
-        if (pulse_mainloop != nullptr)
-        {
-            pa_threaded_mainloop_stop(pulse_mainloop);
-            pa_threaded_mainloop_free(pulse_mainloop);
-            pulse_mainloop = nullptr;
-        }
-
-        bus->stop();
-
-        if (worker.joinable())
-            worker.join();
-
-        if (pulse_worker.joinable())
-            pulse_worker.join();
+    {        
     }
 
     void media_recording_state_changed(media::RecordingState state)
     {
-        if (uscreen_session == nullptr)
-            return;
-
-        if (state == media::RecordingState::started)
-        {
-            if (disp_cookie > 0)
-                return;
-
-            auto result = uscreen_session->invoke_method_synchronously<core::UScreen::keepDisplayOn, int>();
-            if (result.is_error())
-                throw std::runtime_error(result.error().print());
-            disp_cookie = result.value();
-        }
-        else if (state == media::RecordingState::stopped)
-        {
-            if (disp_cookie != -1)
-            {
-                timeout(4000, true, [this](){
-                    this->uscreen_session->invoke_method_synchronously<core::UScreen::removeDisplayOnRequest, void>(this->disp_cookie);
-                    this->disp_cookie = -1;
-                });
-            }
-        }
-    }
-
-    pa_threaded_mainloop *mainloop()
-    {
-        return pulse_mainloop;
-    }
-
-    bool is_port_available(pa_card_port_info **ports, uint32_t n_ports, const char *name)
-    {
-        bool ret = false;
-
-        if (ports != nullptr && n_ports > 0 && name != nullptr)
-        {
-            for (uint32_t i=0; i<n_ports; i++)
-            {
-                if (strstr(ports[i]->name, name) != nullptr && ports[i]->available != PA_PORT_AVAILABLE_NO)
-                {
-                    ret = true;
-                    break;
-                }
-            }
-        }
-
-        return ret;
-    }
-
-    void update_wired_output()
-    {
-        const pa_operation *o = pa_context_get_card_info_by_index(pulse_context, primary_idx,
-                [](pa_context *context, const pa_card_info *info, int eol, void *userdata)
-                {
-                    (void) context;
-                    (void) eol;
-
-                    if (info == nullptr || userdata == nullptr)
-                        return;
-
-                    Private *p = reinterpret_cast<Private*>(userdata);
-                    if (p->is_port_available(info->ports, info->n_ports, "output-wired"))
-                    {
-                        if (!p->headphones_connected)
-                            std::cout << "Wired headphones connected" << std::endl;
-                        p->headphones_connected = true;
-                    }
-                    else if (p->headphones_connected == true)
-                    {
-                        std::cout << "Wired headphones disconnected" << std::endl;
-                        p->headphones_connected = false;
-                        p->pause_playback_if_necessary(std::get<0>(p->active_sink));
-                    }
-                }, this);
-        (void) o;
-    }
-
-    void pause_playback_if_necessary(int index)
-    {
-        // Catch uninitialized case (active index == -1)
-        if (std::get<0>(active_sink) == -1)
-            return;
-
-        if (headphones_connected)
-            return;
-
-        // No headphones/fallback on primary sink? Pause.
-        if (index == primary_idx)
-            pause_playback();
-    }
-
-    void set_active_sink(const char *name)
-    {
-        const pa_operation *o = pa_context_get_sink_info_by_name(pulse_context, name,
-                [](pa_context *context, const pa_sink_info *i, int eol, void *userdata)
-                {
-                    (void) context;
-
-                    if (eol)
-                        return;
-
-                    Private *p = reinterpret_cast<Private*>(userdata); 
-                    std::tuple<uint32_t, uint32_t, std::string> new_sink(std::make_tuple(i->index, i->card, i->name));
-
-                    printf("pulsesink: active_sink=('%s',%d,%d) -> ('%s',%d,%d)\n",
-                        std::get<2>(p->active_sink).c_str(), std::get<0>(p->active_sink),
-                        std::get<1>(p->active_sink), i->name, i->index, i->card);
-
-                    p->pause_playback_if_necessary(i->index);
-                    p->active_sink = new_sink;
-                }, this);
-     
-        (void) o;
-    }
-
-    void update_active_sink()
-    {
-        const pa_operation *o = pa_context_get_server_info(pulse_context,
-                [](pa_context *context, const pa_server_info *i, void *userdata)
-                {
-                    (void) context;
-
-                    Private *p = reinterpret_cast<Private*>(userdata);
-                    if (i->default_sink_name != std::get<2>(p->active_sink))
-                        p->set_active_sink(i->default_sink_name);
-                    p->update_wired_output();
-                }, this);
-
-        (void) o;
-    }
-
-    void create_pulse_context()
-    {
-        if (pulse_context != nullptr)
-            return;
-        
-        active_sink = std::make_tuple(-1, -1, "");
-
-        bool keep_going = true, ok = true;
-
-        pulse_mainloop_api = pa_threaded_mainloop_get_api(pulse_mainloop);
-        pa_threaded_mainloop_lock(pulse_mainloop);
-
-        pulse_context = pa_context_new(pulse_mainloop_api, "MediaHubPulseContext");
-        pa_context_set_state_callback(pulse_context,
-                [](pa_context *context, void *userdata)
-                {
-                    (void) context;
-                    Private *p = reinterpret_cast<Private*>(userdata);
-                    // Signals the pa_threaded_mainloop_wait below to proceed
-                    pa_threaded_mainloop_signal(p->mainloop(), 0);
-                }, this);
-
-        if (pulse_context == nullptr)
-        {
-            std::cerr << "Unable to create new pulseaudio context" << std::endl;
-            pa_threaded_mainloop_unlock(pulse_mainloop);
-            return;
-        }
-
-        pa_context_connect(pulse_context, nullptr, pa_context_flags_t((int) PA_CONTEXT_NOAUTOSPAWN | (int) PA_CONTEXT_NOFAIL), nullptr); 
-        pa_threaded_mainloop_wait(pulse_mainloop);
-
-        while (keep_going)
-        {
-            switch (pa_context_get_state(pulse_context))
-            {
-                case PA_CONTEXT_CONNECTING: // Wait for service to be available
-                case PA_CONTEXT_AUTHORIZING:
-                case PA_CONTEXT_SETTING_NAME:
-                    break;
-
-                case PA_CONTEXT_READY:
-                    std::cout << "Pulseaudio connection established." << std::endl;
-                    keep_going = false;
-                    break;
-
-                case PA_CONTEXT_FAILED:
-                case PA_CONTEXT_TERMINATED:
-                    keep_going = false;
-                    ok = false;
-                    break;
-
-                default:
-                    std::cerr << "Pulseaudio connection failure: " << pa_strerror(pa_context_errno(pulse_context));
-                    keep_going = false;
-                    ok = false;
-            }
-
-            if (keep_going)
-                pa_threaded_mainloop_wait(pulse_mainloop);
-        }
-
-        if (ok)
-        {
-            pa_context_set_state_callback(pulse_context,
-                    [](pa_context *context, void *userdata)
-                    {
-                        (void) context;
-                        (void) userdata;
-                        Private *p = reinterpret_cast<Private*>(userdata);
-                        std::unique_lock<std::mutex> lk(p->pulse_mutex);
-                        switch (pa_context_get_state(context))
-                        {
-                            case PA_CONTEXT_FAILED:
-                            case PA_CONTEXT_TERMINATED:
-                                p->pcv.notify_all();
-                                break;
-                            default:
-                                break;
-                        }
-                    }, this);
-
-            //FIXME: Get index for "sink.primary", the default onboard card on Touch.
-            pa_context_get_sink_info_by_name(pulse_context, "sink.primary",
-                    [](pa_context *context, const pa_sink_info *i, int eol, void *userdata)
-                    {
-                        (void) context;
-
-                        if (eol)
-                            return;
-                        
-                        Private *p = reinterpret_cast<Private*>(userdata);
-                        p->primary_idx = i->index;
-                        p->update_wired_output();
-                    }, this);
-            
-            update_active_sink(); 
-
-            pa_context_set_subscribe_callback(pulse_context,
-                    [](pa_context *context, pa_subscription_event_type_t t, uint32_t idx, void *userdata)
-                    {
-                        (void) context;
-                        (void) idx;
-
-                        if (userdata == nullptr)
-                            return;
-
-                        Private *p = reinterpret_cast<Private*>(userdata);
-                        if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK)
-                        {
-                            p->update_active_sink(); 
-                        }
-                    }, this);
-            pa_context_subscribe(pulse_context, PA_SUBSCRIPTION_MASK_SINK, nullptr, this);
-        }
-        else
-        {
-            std::cerr << "Connection to pulseaudio failed or was dropped." << std::endl;
-            pa_context_unref(pulse_context);
-            pulse_context = nullptr;
-        }
-
-        pa_threaded_mainloop_unlock(pulse_mainloop);
-    }
-
-    void release_pulse_context()
-    {
-        if (pulse_context != nullptr)
-        {
-            pa_threaded_mainloop_lock(pulse_mainloop);
-            pa_context_disconnect(pulse_context);
-            pa_context_unref(pulse_context);
-            pa_threaded_mainloop_unlock(pulse_mainloop);
-            pulse_context = nullptr;
+        switch (state)
+        {
+        case media::RecordingState::started:
+            display_state_lock->request_acquire(media::power::DisplayState::on);
+            break;
+        case media::RecordingState::stopped:
+            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;
-    std::thread worker;
-    dbus::Bus::Ptr bus;
-    boost::asio::io_service io_service;
-    boost::asio::io_service::work keep_alive;
-    std::shared_ptr<dbus::Object> indicator_power_session;
-    std::shared_ptr<core::dbus::Property<core::IndicatorPower::PowerLevel>> power_level;
-    std::shared_ptr<core::dbus::Property<core::IndicatorPower::IsWarning>> is_warning;
-    int disp_cookie;
-    std::shared_ptr<dbus::Object> uscreen_session;
+
+    media::ServiceImplementation& parent;
+
+    media::Dispatcher dispatcher;
+
+    media::power::StateController::Lock<media::power::DisplayState>::Ptr display_state_lock;
+    media::power::StateController::Ptr power_state_controller;
+    media::power::BatteryObserver::Ptr power_state_observer;
+    media::audio::OutputObserver::Ptr audio_output_observer;
+    media::telephony::CallMonitor::Ptr call_monitor;
+    media::ClientDeathObserver::Ptr client_death_observer;
     media::RecorderObserver::Ptr recorder_observer;
-    // Pulse-specific
-    pa_mainloop_api *pulse_mainloop_api;
-    pa_threaded_mainloop *pulse_mainloop;
-    pa_context *pulse_context;
-    std::thread pulse_worker;
-    std::mutex pulse_mutex;
-    std::condition_variable pcv;
-    bool headphones_connected;
-    bool a2dp_connected;
-    std::tuple<int, int, std::string> active_sink;
-    int primary_idx;
+    // All event connections go here.
+    struct
+    {
+        core::ScopedConnection power_level;
+        core::ScopedConnection is_warning_active;
+        core::ScopedConnection call_state;
+        core::ScopedConnection recording_state;
+        core::ScopedConnection external_audio_output_state;
+    } connections;
 
-    // Gets signaled when both the headphone jack is removed or an A2DP device is
-    // disconnected and playback needs pausing
-    core::Signal<void> pause_playback;
-    std::unique_ptr<CallMonitor> call_monitor;
     std::list<media::Player::PlayerKey> paused_sessions;
 };
 
-media::ServiceImplementation::ServiceImplementation() : d(new Private())
+media::ServiceImplementation::ServiceImplementation(const media::ServiceImplementation::Configuration& config)
+    : d(new Private(*this, config))
 {
-    d->power_level->changed().connect([this](const core::IndicatorPower::PowerLevel::ValueType &level)
-    {
-        // When the battery level hits 10% or 5%, pause all multimedia sessions.
-        // Playback will resume when the user clears the presented notification.
-        if (level == "low" || level == "very_low")
-            pause_all_multimedia_sessions();
-    });
-
-    d->is_warning->changed().connect([this](const core::IndicatorPower::IsWarning::ValueType &notifying)
-    {
-        // If the low battery level notification is no longer being displayed,
-        // resume what the user was previously playing
-        if (!notifying)
-            resume_multimedia_session();
-    });
-
-    d->pause_playback.connect([this]()
-    {
-        std::cout << "Got pause_playback signal, pausing all multimedia sessions" << std::endl;
-        pause_all_multimedia_sessions();
-    });
-
-    d->call_monitor->on_change([this](CallMonitor::State state) {
-        switch (state) {
-        case CallMonitor::OffHook:
-            pause_all_multimedia_sessions();
-            break;
-        case CallMonitor::OnHook:
-            resume_paused_multimedia_sessions();
-            break;
-        }
-    });
 }
 
 media::ServiceImplementation::~ServiceImplementation()
@@ -513,20 +164,34 @@
 std::shared_ptr<media::Player> media::ServiceImplementation::create_session(
         const media::Player::Configuration& conf)
 {
-    auto player = std::make_shared<media::PlayerImplementation>(
-            conf.identity, conf.bus, conf.session, shared_from_this(), conf.key);
+    media::PlayerImplementation::Configuration player_config
+    {
+        conf.identity,
+        conf.bus,
+        conf.session,
+        ServiceImplementation::shared_from_this(),
+        conf.key,
+        d->client_death_observer,
+        d->power_state_controller
+    };
+
+    auto player = std::make_shared<media::PlayerImplementation>(player_config);
 
     auto key = conf.key;
-    player->on_client_disconnected().connect([this, key]()
+
+    // We hold a reference to ourselves.
+    auto sp = ServiceImplementation::shared_from_this();
+
+    player->on_client_disconnected().connect([sp, key]()
     {
         // Call remove_player_for_key asynchronously otherwise deadlock can occur
         // if called within this dispatcher context.
         // remove_player_for_key can destroy the player instance which in turn
         // destroys the "on_client_disconnected" signal whose destructor will wait
         // until all dispatches are done
-        d->io_service.post([this, key]()
+        sp->d->dispatcher([sp, key]()
         {
-            remove_player_for_key(key);
+            sp->remove_player_for_key(key);
         });
     });
 

=== modified file 'src/core/media/service_implementation.h'
--- src/core/media/service_implementation.h	2014-10-31 07:49:33 +0000
+++ src/core/media/service_implementation.h	2014-11-25 11:08:14 +0000
@@ -19,6 +19,15 @@
 #ifndef CORE_UBUNTU_MEDIA_SERVICE_IMPLEMENTATION_H_
 #define CORE_UBUNTU_MEDIA_SERVICE_IMPLEMENTATION_H_
 
+#include "dispatcher.h"
+
+#include "client_death_observer.h"
+#include "recorder_observer.h"
+#include "audio/output_observer.h"
+#include "power/battery_observer.h"
+#include "power/state_controller.h"
+#include "telephony/call_monitor.h"
+
 #include "service_skeleton.h"
 
 namespace core
@@ -30,10 +39,24 @@
 
 class Player;
 
-class ServiceImplementation : public ServiceSkeleton
+class ServiceImplementation
+        : public ServiceSkeleton,
+          public std::enable_shared_from_this<ServiceImplementation>
 {
 public:
-    ServiceImplementation ();
+    // All creation time arguments go here.
+    struct Configuration
+    {
+        Dispatcher dispatcher;
+        media::ClientDeathObserver::Ptr client_death_observer;
+        media::RecorderObserver::Ptr recorder_observer;
+        media::audio::OutputObserver::Ptr audio_output_observer;
+        power::StateController::Ptr power_state_controller;
+        power::BatteryObserver::Ptr power_state_observer;
+        telephony::CallMonitor::Ptr call_monitor;
+    };
+
+    ServiceImplementation (const Configuration& configuration);
     ~ServiceImplementation ();
 
     std::shared_ptr<Player> create_session(const Player::Configuration&);
@@ -46,7 +69,7 @@
     void resume_multimedia_session();
 
     struct Private;
-    std::shared_ptr<Private> d;
+    std::unique_ptr<Private> d;
 };
 }
 }

=== modified file 'src/core/media/service_stub.h'
--- src/core/media/service_stub.h	2014-10-16 15:30:44 +0000
+++ src/core/media/service_stub.h	2014-11-25 11:08:14 +0000
@@ -33,7 +33,9 @@
 {
 namespace media
 {
-class ServiceStub : public core::dbus::Stub<core::ubuntu::media::Service>
+class ServiceStub
+        : public core::dbus::Stub<core::ubuntu::media::Service>,
+          public std::enable_shared_from_this<ServiceStub>
 {
   public:
     ServiceStub();

=== renamed directory 'src/core/media/call-monitor' => 'src/core/media/telephony'
=== modified file 'src/core/media/telephony/call_monitor.cpp'
--- src/core/media/call-monitor/call_monitor.cpp	2014-11-04 23:37:22 +0000
+++ src/core/media/telephony/call_monitor.cpp	2014-11-25 11:08:14 +0000
@@ -29,8 +29,12 @@
 #include <list>
 #include <mutex>
 
+namespace media = core::ubuntu::media;
 
-namespace {
+namespace
+{
+namespace impl
+{
 class TelepathyCallMonitor : public QObject
 {
     Q_OBJECT
@@ -73,7 +77,7 @@
         }
     }
 
-    void on_change(const std::function<void(CallMonitor::State)>& func) {
+    void on_change(const std::function<void(media::telephony::CallMonitor::State)>& func) {
         std::lock_guard<std::mutex> l(cb_lock);
         cb = func;
     }
@@ -128,19 +132,19 @@
     {
         std::lock_guard<std::mutex> l(cb_lock);
         if (cb)
-            cb(CallMonitor::OffHook);
+            cb(media::telephony::CallMonitor::OffHook);
     }
 
     void onHook()
     {
         std::lock_guard<std::mutex> l(cb_lock);
         if (cb)
-            cb(CallMonitor::OnHook);
+            cb(media::telephony::CallMonitor::OnHook);
     }
 
 private:
     std::mutex cb_lock;
-    std::function<void (CallMonitor::State)>   cb;
+    std::function<void (media::telephony::CallMonitor::State)>   cb;
     Tp::AccountManagerPtr mAccountManager;
     std::list<TelepathyCallMonitor*> mCallMonitors;
 
@@ -157,12 +161,11 @@
         }
     }
 };
-}
 
-class CallMonitorPrivate
+struct CallMonitor : public media::telephony::CallMonitor
 {
-public:
-    CallMonitorPrivate() {
+    CallMonitor()
+    {
         try {
             std::thread([this]() {
                 qt::core::world::build_and_run(0, nullptr, [this]() {
@@ -176,30 +179,32 @@
         } catch(...) {
             std::cerr << "exception(...) in CallMonitor thread start" << std::endl;
         }
-    }
-
-    ~CallMonitorPrivate() {
-        qt::core::world::destroy();
+
+        mBridge->on_change([this](CallMonitor::State state)
+        {
+            call_state_changed(state);
+        });
+    }
+
+    ~CallMonitor()
+    {
+        delete mBridge;
+    }
+
+    const core::Signal<media::telephony::CallMonitor::State>& on_call_state_changed() const
+    {
+        return call_state_changed;
     }
 
     TelepathyBridge *mBridge;
+    core::Signal<media::telephony::CallMonitor::State> call_state_changed;
 };
-
-
-CallMonitor::CallMonitor():
-    d(new CallMonitorPrivate)
-{
-}
-
-CallMonitor::~CallMonitor()
-{
-    delete d->mBridge;
-    delete d;
-}
-
-void CallMonitor::on_change(const std::function<void(CallMonitor::State)>& func)
-{
-    d->mBridge->on_change(func);
+}
+}
+
+media::telephony::CallMonitor::Ptr media::telephony::make_platform_default_call_monitor()
+{
+    return std::make_shared<impl::CallMonitor>();
 }
 
 #include "call_monitor.moc"

=== modified file 'src/core/media/telephony/call_monitor.h'
--- src/core/media/call-monitor/call_monitor.h	2014-10-31 07:49:33 +0000
+++ src/core/media/telephony/call_monitor.h	2014-11-25 11:08:14 +0000
@@ -17,25 +17,43 @@
  */
 
 
-#ifndef CALLMONITOR_H
-#define CALLMONITOR_H
+#ifndef CORE_UBUNTU_MEDIA_TELEPHONY_CALL_MONITOR_H_
+#define CORE_UBUNTU_MEDIA_TELEPHONY_CALL_MONITOR_H_
+
+#include <core/signal.h>
 
 #include <functional>
-
-class CallMonitorPrivate;
-
-class CallMonitor
-{
-public:
-    enum State { OffHook, OnHook };
-
-    CallMonitor();
-    ~CallMonitor();
-
-    void on_change(const std::function<void(CallMonitor::State)>& func);
-
-private:
-    CallMonitorPrivate *d;
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace telephony
+{
+struct CallMonitor
+{
+    typedef std::shared_ptr<CallMonitor> Ptr;
+
+    enum State
+    {
+        OffHook,
+        OnHook
+    };
+
+    CallMonitor() = default;
+    virtual ~CallMonitor() = default;
+
+    virtual const core::Signal<State>& on_call_state_changed() const = 0;
 };
 
-#endif // CALLMONITOR_H
+CallMonitor::Ptr make_platform_default_call_monitor();
+}
+}
+}
+}
+
+
+#endif // CORE_UBUNTU_MEDIA_TELEPHONY_CALL_MONITOR_H_

=== removed file 'src/core/media/unity_screen_service.h'
--- src/core/media/unity_screen_service.h	2014-06-16 22:28:53 +0000
+++ src/core/media/unity_screen_service.h	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-/*
- * 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/>.
- *
- *      Author: Alberto Aguirre <[e-mail]>
- */
-
-#include <core/dbus/dbus.h>
-#include <core/dbus/fixture.h>
-#include <core/dbus/object.h>
-#include <core/dbus/property.h>
-#include <core/dbus/service.h>
-#include <core/dbus/interfaces/properties.h>
-#include <core/dbus/types/stl/tuple.h>
-#include <core/dbus/types/stl/vector.h>
-
-#include <core/dbus/asio/executor.h>
-
-#include <string>
-#include <vector>
-#include <chrono>
-
-namespace core
-{
-
-struct UScreen
-{
-    static std::string& name()
-    {
-        static std::string s = "com.canonical.Unity.Screen";
-        return s;
-    }
-
-    struct keepDisplayOn
-    {
-        static std::string name()
-        {
-            static std::string s = "keepDisplayOn";
-            return s;
-        }
-
-        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-
-        typedef UScreen Interface;
-    };
-
-    struct removeDisplayOnRequest
-    {
-        static std::string name()
-        {
-            static std::string s = "removeDisplayOnRequest";
-            return s;
-        }
- 
-        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
-
-        typedef UScreen Interface;
-    };
-};
-
-}

=== modified file 'tests/acceptance-tests/service.cpp'
--- tests/acceptance-tests/service.cpp	2014-04-04 14:31:43 +0000
+++ tests/acceptance-tests/service.cpp	2014-11-25 11:08:14 +0000
@@ -21,6 +21,7 @@
 #include <core/media/track_list.h>
 
 #include "core/media/service_implementation.h"
+#include "core/media/audio/pulse_audio_output_observer.h"
 
 #include "../waitable_state_transition.h"
 
@@ -68,6 +69,48 @@
     timespec ts{ 0, static_cast<long int>(ms.count()) * 1000 * 1000};
     ::nanosleep(&ts, nullptr);
 }
+
+std::thread make_external_services_worker(bool shutdown_requested, media::helper::ExternalServices& es)
+{
+    return std::thread
+    {
+        [&shutdown_requested, &es]()
+        {
+            while (not shutdown_requested)
+            {
+                try
+                {
+                    es.io_service.run();
+                }
+                catch (const std::exception& e)
+                {
+                    std::cerr << "Error while executing the underlying io_service: " << e.what() << std::endl;
+                }
+                catch (...)
+                {
+                    std::cerr << "Error while executing the underlying io_service." << std::endl;
+                }
+            }
+        }
+    };
+}
+
+media::ServiceImplementation::Configuration make_default_service_configuration(media::helper::ExternalServices& es)
+{
+    return media::ServiceImplementation::Configuration
+    {
+        [&es](media::Task task)
+        {
+            es.io_service.post(task);
+        },
+        media::platform_default_client_death_observer(),
+        media::make_platform_default_recorder_observer(),
+        media::audio::make_platform_default_output_observer(),
+        media::power::make_platform_default_state_controller(es),
+        media::power::make_platform_default_battery_observer(es),
+        media::telephony::make_platform_default_call_monitor()
+    };
+}
 }
 
 TEST(MusicService, DISABLED_accessing_and_creating_a_session_works)
@@ -78,7 +121,17 @@
     {
         SigTermCatcher sc;
 
-        auto service = std::make_shared<media::ServiceImplementation>();
+        // We keep track of our state.
+        bool shutdown_requested{false};
+
+        // Our helper for connecting to external services.
+        media::helper::ExternalServices external_services;
+        std::thread external_services_worker
+        {
+            make_external_services_worker(shutdown_requested, external_services)
+        };
+
+        auto service = std::make_shared<media::ServiceImplementation>(make_default_service_configuration(external_services));
         std::thread t([&service](){service->run();});
 
         sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
@@ -120,7 +173,16 @@
     {
         SigTermCatcher sc;
 
-        auto service = std::make_shared<media::ServiceImplementation>();
+        // We keep track of our state.
+        bool shutdown_requested{false};
+
+        media::helper::ExternalServices external_services;
+        std::thread external_services_worker
+        {
+            make_external_services_worker(shutdown_requested, external_services)
+        };
+
+        auto service = std::make_shared<media::ServiceImplementation>(make_default_service_configuration(external_services));
         std::thread t([&service](){service->run();});
 
         sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
@@ -173,7 +235,16 @@
     {
         SigTermCatcher sc;
 
-        auto service = std::make_shared<media::ServiceImplementation>();
+        // We keep track of our state.
+        bool shutdown_requested{false};
+
+        media::helper::ExternalServices external_services;
+        std::thread external_services_worker
+        {
+            make_external_services_worker(shutdown_requested, external_services)
+        };
+
+        auto service = std::make_shared<media::ServiceImplementation>(make_default_service_configuration(external_services));
         std::thread t([&service](){service->run();});
 
         sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
@@ -252,7 +323,16 @@
     {
         SigTermCatcher sc;
 
-        auto service = std::make_shared<media::ServiceImplementation>();
+        // We keep track of our state.
+        bool shutdown_requested{false};
+
+        media::helper::ExternalServices external_services;
+        std::thread external_services_worker
+        {
+            make_external_services_worker(shutdown_requested, external_services)
+        };
+
+        auto service = std::make_shared<media::ServiceImplementation>(make_default_service_configuration(external_services));
         std::thread t([&service](){service->run();});
 
         sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});
@@ -311,7 +391,16 @@
     {
         SigTermCatcher sc;
 
-        auto service = std::make_shared<media::ServiceImplementation>();
+        // We keep track of our state.
+        bool shutdown_requested{false};
+
+        media::helper::ExternalServices external_services;
+        std::thread external_services_worker
+        {
+            make_external_services_worker(shutdown_requested, external_services)
+        };
+
+        auto service = std::make_shared<media::ServiceImplementation>(make_default_service_configuration(external_services));
         std::thread t([&service](){service->run();});
 
         sync_service_start.try_signal_ready_for(std::chrono::milliseconds{500});