Merge lp:~jhodapp/media-hub/fix-zero-position-while-seeking into lp:media-hub

[Jim Hodapp]

* Prevent a 0 position from being reported to the app which happens while seeking. Covers bad behavior that happens from GStreamer. Also expose the about_to_finish signal to the client.
* Enable playback again after manually seeking all the way to EOS. Also only send VideoDimensionsChanged signal only when necessary.

* Prevent a 0 position from being reported to the app which happens while seeking. Covers bad behavior that happens from GStreamer. Also expose the about_to_finish signal to the client.
* Enable playback again after manually seeking all the way to EOS. Also only send VideoDimensionsChanged signal only when necessary.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:121
http://jenkins.qa.ubuntu.com/job/media-hub-ci/304/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/144/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/144
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/144/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/144

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

review: Needs Fixing (continuous-integration)

[lp:~jhodapp/media-hub/fix-zero-position-while-seeking]

122. By Jim Hodapp on 2015-03-16

Merged prereqs.

123. By Jim Hodapp on 2015-03-16

Merge prereqs.

124. By Jim Hodapp on 2015-03-16

Fix the last merge.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

=== modified file 'debian/changelog'
--- debian/changelog	2015-03-16 15:38:27 +0000
+++ debian/changelog	2015-03-16 15:38:27 +0000
@@ -1,4 +1,9 @@
-<<<<<<< TREE
+media-hub (3.0.0) UNRELEASED; urgency=medium
+
+  * Refactor client-facing interfaces to pull out explicit dependency on hybris-based media layer.
+
+ -- Thomas Voss <[e-mail]>  Tue, 11 Nov 2014 17:15:52 +0100
+
 media-hub (2.0.0+15.04.20150303-0ubuntu2) vivid; urgency=medium
 
   * debian/control:
@@ -17,14 +22,6 @@
 
  -- CI Train Bot <[e-mail]>  Tue, 03 Mar 2015 22:56:52 +0000
 
-=======
-media-hub (3.0.0) UNRELEASED; urgency=medium
-
-  * Refactor client-facing interfaces to pull out explicit dependency on hybris-based media layer.
-
- -- Thomas Voss <[e-mail]>  Tue, 11 Nov 2014 17:15:52 +0100
-
->>>>>>> MERGE-SOURCE
 media-hub (2.0.0+15.04.20150120-0ubuntu1) vivid; urgency=low
 
   [ Jim Hodapp ]

=== modified file 'debian/control'
--- debian/control	2015-03-16 15:38:27 +0000
+++ debian/control	2015-03-16 15:38:27 +0000
@@ -39,14 +39,8 @@
 Section: libdevel
 Architecture: any
 Multi-Arch: same
-<<<<<<< TREE
-Depends: libmedia-hub-common2 (= ${binary:Version}),
-         libmedia-hub-client2 (= ${binary:Version}),
-=======
-Pre-Depends: dpkg (>= 1.15.6~)
 Depends: libmedia-hub-common3 (= ${binary:Version}),
          libmedia-hub-client3 (= ${binary:Version}),
->>>>>>> MERGE-SOURCE
          ${misc:Depends},
          libproperties-cpp-dev,
 Suggests: libmedia-hub-doc

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2015-03-16 15:38:27 +0000
+++ include/core/media/player.h	2015-03-16 15:38:27 +0000
@@ -168,6 +168,7 @@
     virtual core::Property<Lifetime>& lifetime() = 0;
 
     virtual const core::Signal<int64_t>& seeked_to() const = 0;
+    virtual const core::Signal<void>& about_to_finish() const = 0;
     virtual const core::Signal<void>& end_of_stream() const = 0;
     virtual core::Signal<PlaybackStatus>& playback_status_changed() = 0;
     virtual const core::Signal<video::Dimensions>& video_dimension_changed() const = 0;

=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2015-03-16 15:38:27 +0000
+++ src/core/media/CMakeLists.txt	2015-03-16 15:38:27 +0000
@@ -11,7 +11,7 @@
 
 message(STATUS ${MEDIA_HUB_HEADERS})
 
-add_subdirectory(call-monitor)
+add_subdirectory(telephony)
 
 add_library(
   media-hub-common SHARED
@@ -87,10 +87,14 @@
     ${MPRIS_HEADERS}
 
     client_death_observer.cpp
-    hybris_client_death_observer.cpp
+    hashed_keyed_player_store.cpp
+    hybris_client_death_observer.cpp    
     cover_art_resolver.cpp
     engine.cpp
 
+    apparmor/context.cpp
+    apparmor/ubuntu.cpp
+
     audio/pulse_audio_output_observer.cpp
     audio/ostream_reporter.cpp
     audio/output_observer.cpp

=== added directory 'src/core/media/apparmor'
=== removed file 'src/core/media/apparmor.h'
--- src/core/media/apparmor.h	2014-09-01 07:49:45 +0000
+++ src/core/media/apparmor.h	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2013-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]>
- */
-
-#ifndef APPARMOR_DBUS_H_
-#define APPARMOR_DBUS_H_
-
-#include <core/dbus/macros.h>
-#include <core/dbus/object.h>
-#include <core/dbus/service.h>
-
-#include <string>
-#include <chrono>
-
-// TODO(tvoss): This really should live in trust-store, providing a straightforward
-// way for parties involved in managing trust relationships to query peers' apparmor
-// profiles. Please see https://bugs.launchpad.net/trust-store/+bug/1350736 for the
-// related bug
-namespace org
-{
-namespace freedesktop
-{
-namespace dbus
-{
-struct DBus
-{
-    static const std::string& name()
-    {
-        static const std::string s = "org.freedesktop.DBus";
-        return s;
-    }
-
-    // Gets the AppArmor confinement string associated with the unique connection name. If
-    // D-Bus is not performing AppArmor mediation, the
-    // org.freedesktop.DBus.Error.AppArmorSecurityContextUnknown error is returned.
-    DBUS_CPP_METHOD_DEF(GetConnectionAppArmorSecurityContext, DBus)
-
-    struct Stub
-    {
-        // Creates a new stub instance for the given object to access
-        // DBus functionality.
-        Stub(const core::dbus::Object::Ptr& object) : object{object}
-        {
-        }
-
-        // Creates a new stub instance for the given bus connection
-        Stub(const core::dbus::Bus::Ptr& bus)
-            : object
-              {
-                  core::dbus::Service::use_service<org::freedesktop::dbus::DBus>(bus)
-                      ->object_for_path(core::dbus::types::ObjectPath{"/org/freedesktop/DBus"})
-              }
-        {
-        }
-
-        // Gets the AppArmor confinement string associated with the unique connection name. If
-        // D-Bus is not performing AppArmor mediation, the
-        // org.freedesktop.DBus.Error.AppArmorSecurityContextUnknown error is returned.
-        //
-        // Invokes the given handler on completion.
-        void get_connection_app_armor_security_async(
-                    const std::string& name,
-                    std::function<void(const std::string&)> handler)
-        {
-            object->invoke_method_asynchronously_with_callback<GetConnectionAppArmorSecurityContext, std::string>(
-                        [handler](const core::dbus::Result<std::string>& result)
-                        {
-                            if (not result.is_error()) handler(result.value());
-                        }, name);
-        }
-
-        core::dbus::Object::Ptr object;
-    };
-};
-}
-}
-}
-
-#endif // APPARMOR_DBUS_H_

=== added file 'src/core/media/apparmor/context.cpp'
--- src/core/media/apparmor/context.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/apparmor/context.cpp	2015-03-16 15:38:27 +0000
@@ -0,0 +1,34 @@
+/*
+ * 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/apparmor/context.h>
+
+namespace apparmor = core::ubuntu::media::apparmor;
+
+apparmor::Context::Context(const std::string& name) : name{name}
+{
+    if (name.empty()) throw std::runtime_error
+    {
+        "apparmor::Context cannot be created for empty name."
+    };
+}
+
+const std::string& apparmor::Context::str() const
+{
+    return name;
+}

=== added file 'src/core/media/apparmor/context.h'
--- src/core/media/apparmor/context.h	1970-01-01 00:00:00 +0000
+++ src/core/media/apparmor/context.h	2015-03-16 15:38:27 +0000
@@ -0,0 +1,51 @@
+/*
+ * 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_APPARMOR_AUTHENTICATOR_H_
+#define CORE_UBUNTU_MEDIA_APPARMOR_AUTHENTICATOR_H_
+
+#include <memory>
+#include <string>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+namespace apparmor
+{
+// Models an apparmor context name, and provides convenience functionality
+// on top of it.
+class Context
+{
+public:
+    // Constructs a new Context instance for the given raw name.
+    // Throws std::logic_error for empty names.
+    explicit Context(const std::string& name);
+    virtual ~Context() = default;
+    // Returns the raw string describing the context.
+    const std::string& str() const;
+
+private:
+    const std::string name;
+};
+}
+}
+}
+}
+#endif // CORE_UBUNTU_MEDIA_APPARMOR_AUTHENTICATOR_H_

=== added file 'src/core/media/apparmor/dbus.h'
--- src/core/media/apparmor/dbus.h	1970-01-01 00:00:00 +0000
+++ src/core/media/apparmor/dbus.h	2015-03-16 15:38:27 +0000
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2013-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]>
+ */
+
+#ifndef CORE_UBUNTU_MEDIA_APPARMOR_DBUS_H_
+#define CORE_UBUNTU_MEDIA_APPARMOR_DBUS_H_
+
+#include <core/dbus/bus.h>
+#include <core/dbus/macros.h>
+#include <core/dbus/object.h>
+#include <core/dbus/service.h>
+
+#include <string>
+#include <chrono>
+
+// TODO(tvoss): This really should live in trust-store, providing a straightforward
+// way for parties involved in managing trust relationships to query peers' apparmor
+// profiles. Please see https://bugs.launchpad.net/trust-store/+bug/1350736 for the
+// related bug
+namespace org
+{
+namespace freedesktop
+{
+namespace dbus
+{
+struct DBus
+{
+    static const std::string& name()
+    {
+        static const std::string s = "org.freedesktop.DBus";
+        return s;
+    }
+
+    // Gets the AppArmor confinement string associated with the unique connection name. If
+    // D-Bus is not performing AppArmor mediation, the
+    // org.freedesktop.DBus.Error.AppArmorSecurityContextUnknown error is returned.
+    DBUS_CPP_METHOD_DEF(GetConnectionAppArmorSecurityContext, DBus)
+
+    struct Stub
+    {
+        // Creates a new stub instance for the given object to access
+        // DBus functionality.
+        Stub(const core::dbus::Object::Ptr& object) : object{object}
+        {
+        }
+
+        // Creates a new stub instance for the given bus connection
+        Stub(const core::dbus::Bus::Ptr& bus)
+            : object
+              {
+                  core::dbus::Service::use_service<org::freedesktop::dbus::DBus>(bus)
+                      ->object_for_path(core::dbus::types::ObjectPath{"/org/freedesktop/DBus"})
+              }
+        {
+        }
+
+        // Gets the AppArmor confinement string associated with the unique connection name. If
+        // D-Bus is not performing AppArmor mediation, the
+        // org.freedesktop.DBus.Error.AppArmorSecurityContextUnknown error is returned.
+        //
+        // Invokes the given handler on completion.
+        void get_connection_app_armor_security_async(
+                    const std::string& name,
+                    std::function<void(const std::string&)> handler)
+        {
+            object->invoke_method_asynchronously_with_callback<GetConnectionAppArmorSecurityContext, std::string>(
+                        [handler](const core::dbus::Result<std::string>& result)
+                        {
+                            if (not result.is_error()) handler(result.value());
+                        }, name);
+        }
+
+        core::dbus::Object::Ptr object;
+    };
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_APPARMOR_DBUS_H_

=== added file 'src/core/media/apparmor/ubuntu.cpp'
--- src/core/media/apparmor/ubuntu.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/apparmor/ubuntu.cpp	2015-03-16 15:38:27 +0000
@@ -0,0 +1,198 @@
+/*
+ * 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/apparmor/ubuntu.h>
+
+#include <core/media/external_services.h>
+
+#include <iostream>
+#include <regex>
+
+namespace apparmor = core::ubuntu::media::apparmor;
+namespace media = core::ubuntu::media;
+namespace ubuntu = apparmor::ubuntu;
+
+namespace
+{
+struct Uri
+{
+    std::string scheme;
+    std::string authority;
+    std::string path;
+    std::string query;
+    std::string fragment;
+};
+
+// Poor mans version of a uri parser.
+// See https://tools.ietf.org/html/rfc3986#appendix-B
+Uri parse_uri(const std::string& s)
+{
+    // Indices into the regex match go here.
+    struct Index
+    {
+        const std::size_t scheme{2};
+        const std::size_t authority{4};
+        const std::size_t path{5};
+        const std::size_t query{7};
+        const std::size_t fragment{9};
+    } static index;
+
+    static const std::regex regex{R"delim(^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)delim"};
+    std::smatch match;
+
+    if (not std::regex_match(s, match, regex)) throw std::runtime_error
+    {
+        "Not a valid URI: " + s
+    };
+
+    return Uri
+    {
+        match.str(index.scheme),
+        match.str(index.authority),
+        match.str(index.path),
+        match.str(index.query),
+        match.str(index.fragment)
+    };
+}
+
+static constexpr std::size_t index_package{1};
+static constexpr std::size_t index_app{2};
+
+// Returns true if the context name is a valid Ubuntu app id.
+// If it is, out is populated with the package and app name.
+bool process_context_name(const std::string& s, std::smatch& out)
+{
+    // See https://wiki.ubuntu.com/AppStore/Interfaces/ApplicationId.
+    static const std::regex short_re{"(.*)_(.*)"};
+    static const std::regex full_re{"(.*)_(.*)_(.*)"};
+
+    if (std::regex_match(s, out, full_re))
+        return true;
+
+    if (std::regex_match(s, out, short_re))
+        return true;
+
+    return false;
+}
+}
+
+apparmor::ubuntu::Context::Context(const std::string& name)
+    : apparmor::Context{name},
+      unconfined_{str() == ubuntu::unconfined},
+      has_package_name_{process_context_name(str(), match_)}
+{
+    if (not is_unconfined() && not has_package_name()) throw std::logic_error
+    {
+        "apparmor::ubuntu::Context: Invalid profile name " + str()
+    };
+}
+
+bool apparmor::ubuntu::Context::is_unconfined() const
+{
+    return unconfined_;
+}
+
+bool apparmor::ubuntu::Context::has_package_name() const
+{
+    return has_package_name_;
+}
+
+
+std::string apparmor::ubuntu::Context::package_name() const
+{
+    return std::string{match_[index_package]};
+}
+
+apparmor::ubuntu::DBusDaemonRequestContextResolver::DBusDaemonRequestContextResolver(const core::dbus::Bus::Ptr& bus) : dbus_daemon{bus}
+{
+}
+
+void apparmor::ubuntu::DBusDaemonRequestContextResolver::resolve_context_for_dbus_name_async(
+        const std::string& name,
+        apparmor::ubuntu::RequestContextResolver::ResolveCallback cb)
+{
+    dbus_daemon.get_connection_app_armor_security_async(name, [cb](const std::string& context_name)
+    {
+        cb(apparmor::ubuntu::Context{context_name});
+    });
+}
+
+apparmor::ubuntu::RequestAuthenticator::Result apparmor::ubuntu::ExistingAuthenticator::authenticate_open_uri_request(const apparmor::ubuntu::Context& context, const std::string& uri)
+{
+    if (context.is_unconfined())
+        return Result{true, "Client allowed access since it's unconfined"};
+
+    Uri parsed_uri = parse_uri(uri);
+
+    // All confined apps can access their own files
+    if (parsed_uri.path.find(std::string(".local/share/" + context.package_name() + "/")) != std::string::npos ||
+        parsed_uri.path.find(std::string(".cache/" + context.package_name() + "/")) != std::string::npos)
+    {
+        return Result
+        {
+            true,
+            "Client can access content in ~/.local/share/" + context.package_name() + " or ~/.cache/" + context.package_name()
+        };
+    }
+    else if (parsed_uri.path.find(std::string("opt/click.ubuntu.com/")) != std::string::npos &&
+             parsed_uri.path.find(context.package_name()) != std::string::npos)
+    {
+        return Result{true, "Client can access content in own opt directory"};
+    }
+    else if ((parsed_uri.path.find(std::string("/system/media/audio/ui/")) != std::string::npos ||
+              parsed_uri.path.find(std::string("/android/system/media/audio/ui/")) != std::string::npos) &&
+              context.package_name() == "com.ubuntu.camera")
+    {
+        return Result{true, "Camera app can access ui sounds"};
+    }
+
+    // TODO: Check if the trust store previously allowed direct access to uri
+
+    // Check in ~/Music and ~/Videos
+    // TODO: when the trust store lands, check it to see if this app can access the dirs and
+    // then remove the explicit whitelist of the music-app, and gallery-app
+    else if ((context.package_name() == "com.ubuntu.music" || context.package_name() == "com.ubuntu.gallery") &&
+            (parsed_uri.path.find(std::string("Music/")) != std::string::npos ||
+             parsed_uri.path.find(std::string("Videos/")) != std::string::npos ||
+             parsed_uri.path.find(std::string("/media")) != std::string::npos))
+    {
+        return Result{true, "Client can access content in ~/Music or ~/Videos"};
+    }
+    else if (parsed_uri.path.find(std::string("/usr/share/sounds")) != std::string::npos)
+    {
+        return Result{true, "Client can access content in /usr/share/sounds"};
+    }
+    else if (parsed_uri.scheme == "http" || parsed_uri.scheme == "rtsp")
+    {
+        return Result{true, "Client can access streaming content"};
+    }
+
+    return Result{false, "Client is not allowed to access: " + uri};
+}
+
+// Returns the platform-default implementation of RequestContextResolver.
+apparmor::ubuntu::RequestContextResolver::Ptr apparmor::ubuntu::make_platform_default_request_context_resolver(media::helper::ExternalServices& es)
+{
+    return std::make_shared<apparmor::ubuntu::DBusDaemonRequestContextResolver>(es.session);
+}
+
+// Returns the platform-default implementation of RequestAuthenticator.
+apparmor::ubuntu::RequestAuthenticator::Ptr apparmor::ubuntu::make_platform_default_request_authenticator()
+{
+    return std::make_shared<apparmor::ubuntu::ExistingAuthenticator>();
+}

=== added file 'src/core/media/apparmor/ubuntu.h'
--- src/core/media/apparmor/ubuntu.h	1970-01-01 00:00:00 +0000
+++ src/core/media/apparmor/ubuntu.h	2015-03-16 15:38:27 +0000
@@ -0,0 +1,167 @@
+/*
+ * 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_APPARMOR_UBUNTU_H_
+#define CORE_UBUNTU_MEDIA_APPARMOR_UBUNTU_H_
+
+#include <core/media/apparmor/context.h>
+#include <core/media/apparmor/dbus.h>
+
+#include <functional>
+#include <memory>
+#include <regex>
+#include <string>
+#include <vector>
+
+namespace core
+{
+namespace dbus
+{
+class Bus;
+}
+
+namespace ubuntu
+{
+namespace media
+{
+namespace helper
+{
+struct ExternalServices;
+}
+namespace apparmor
+{
+// Collects Ubuntu-specific apparmor conventions, e.g., format
+// of short and full package names as well as convenience functionality
+// to inspect apparmor::Context instances.
+namespace ubuntu
+{
+// The unconfined profile, unconditionally trusted
+// by the system.
+static constexpr const char* unconfined
+{
+    "unconfined"
+};
+
+class Context : public apparmor::Context
+{
+public:
+    // Constructs a new Context instance for the given raw name.
+    // Throws std::logic_error for empty names or for names not
+    // complying to Ubuntu conventions.
+    Context(const std::string& name);
+
+    // Returns true iff the context is unconfined.
+    virtual bool is_unconfined() const;
+
+    // Returns true iff the context contains a package name.
+    virtual bool has_package_name() const;
+
+    // Returns the package name or throws if no package name can be found.
+    virtual std::string package_name() const;
+
+private:
+    std::smatch match_;
+    const bool unconfined_;
+    const bool has_package_name_;
+};
+
+// Abstracts query for the apparmor context of an incoming request
+class RequestContextResolver
+{
+public:
+    // To save us some typing.
+    typedef std::shared_ptr<RequestContextResolver> Ptr;
+
+    // Callback for resolve context operations.
+    typedef std::function<void(const Context&)> ResolveCallback;
+
+    // Resolves the given name (of a dbus participant) to its apparmor context,
+    // invoking the callback whenever a result is available.
+    virtual void resolve_context_for_dbus_name_async(const std::string& name, ResolveCallback cb) = 0;
+
+protected:
+    RequestContextResolver() = default;
+    RequestContextResolver(const RequestContextResolver&) = delete;
+    virtual ~RequestContextResolver() = default;
+    RequestContextResolver& operator=(const RequestContextResolver&) = delete;
+};
+
+// An implementation of RequestContextResolver that queries the dbus
+// daemon to resolve the apparmor context.
+class DBusDaemonRequestContextResolver : public RequestContextResolver
+{
+public:
+    // To save us some typing.
+    typedef std::shared_ptr<DBusDaemonRequestContextResolver> Ptr;
+
+    // Constructs a new instance for the given bus connection.
+    DBusDaemonRequestContextResolver(const core::dbus::Bus::Ptr &);
+
+    // From RequestContextResolver
+    void resolve_context_for_dbus_name_async(const std::string& name, ResolveCallback) override;
+
+private:
+    org::freedesktop::dbus::DBus::Stub dbus_daemon;
+};
+
+// Abstracts an apparmor-based authentication of
+// incoming requests from clients.
+class RequestAuthenticator
+{
+public:
+    // To save us some typing.
+    typedef std::shared_ptr<RequestAuthenticator> Ptr;
+
+    // Return type of an authentication call.
+    typedef std::tuple
+    <
+        bool,       // True if authenticated, false if not.
+        std::string // Reason for the result.
+    > Result;
+
+    virtual ~RequestAuthenticator() = default;
+
+    // Returns true iff the client identified by the given apparmor::Context is allowed
+    // to access the given uri, false otherwise.
+    virtual Result authenticate_open_uri_request(const Context&, const std::string& uri) = 0;
+
+protected:
+    RequestAuthenticator() = default;
+    RequestAuthenticator(const RequestAuthenticator&) = default;   
+    RequestAuthenticator& operator=(const RequestAuthenticator&) = default;
+};
+
+// Takes the existing logic and exposes it as an implementation
+// of the RequestAuthenticator interface.
+struct ExistingAuthenticator : public RequestAuthenticator
+{
+    ExistingAuthenticator() = default;
+    // From RequestAuthenticator
+    Result authenticate_open_uri_request(const Context&, const std::string& uri) override;
+};
+
+// Returns the platform-default implementation of RequestContextResolver.
+RequestContextResolver::Ptr make_platform_default_request_context_resolver(helper::ExternalServices& es);
+// Returns the platform-default implementation of RequestAuthenticator.
+RequestAuthenticator::Ptr make_platform_default_request_authenticator();
+}
+}
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_APPARMOR_UBUNTU_H_

=== modified file 'src/core/media/gstreamer/engine.cpp'
--- src/core/media/gstreamer/engine.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/gstreamer/engine.cpp	2015-03-16 15:38:27 +0000
@@ -355,7 +355,7 @@
     if (result)
     {
         d->state = media::Engine::State::playing;
-        cout << "play" << endl;
+        cout << __PRETTY_FUNCTION__ << endl;
         d->playback_status_changed(media::Player::PlaybackStatus::playing);
     }
 
@@ -373,7 +373,7 @@
     if (result)
     {
         d->state = media::Engine::State::stopped;
-        cout << "stop" << endl;
+        cout << __PRETTY_FUNCTION__ << endl;
         d->playback_status_changed(media::Player::PlaybackStatus::stopped);
     }
 
@@ -387,7 +387,7 @@
     if (result)
     {
         d->state = media::Engine::State::paused;
-        cout << "pause" << endl;
+        cout << __PRETTY_FUNCTION__ << endl;
         d->playback_status_changed(media::Player::PlaybackStatus::paused);
     }
 

=== modified file 'src/core/media/gstreamer/playbin.cpp'
--- src/core/media/gstreamer/playbin.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/gstreamer/playbin.cpp	2015-03-16 15:38:27 +0000
@@ -97,11 +97,15 @@
                   this,
                   std::placeholders::_1))),
       is_seeking(false),
-      player_lifetime(media::Player::Lifetime::normal)
+      previous_position(0),
+      player_lifetime(media::Player::Lifetime::normal),
+      is_eos(false)
 {
     if (!pipeline)
         throw std::runtime_error("Could not create pipeline for playbin.");
 
+    is_eos = false;
+
     // Add audio and/or video sink elements depending on environment variables
     // being set or not set
     setup_pipeline_for_audio_video();
@@ -199,6 +203,7 @@
         }
         break;
     case GST_MESSAGE_EOS:
+        is_eos = true;
         signals.on_end_of_stream();
     default:
         break;
@@ -334,6 +339,17 @@
     int64_t pos = 0;
     gst_element_query_position (pipeline, GST_FORMAT_TIME, &pos);
 
+    // This prevents a 0 position from being reported to the app which happens while seeking.
+    // This is covering over a GStreamer issue
+    if ((static_cast<uint64_t>(pos) < duration()) && is_seeking && pos == 0)
+    {
+        return previous_position;
+    }
+
+    // Save the current position to use just in case it's needed the next time position is
+    // requested
+    previous_position = static_cast<uint64_t>(pos);
+
     // FIXME: this should be int64_t, but dbus-cpp doesn't seem to handle it correctly
     return static_cast<uint64_t>(pos);
 }
@@ -358,7 +374,7 @@
         file_type = MEDIA_FILE_TYPE_VIDEO;
     else if (is_audio_file(uri))
         file_type = MEDIA_FILE_TYPE_AUDIO;
-    
+
     request_headers = headers;
 }
 
@@ -366,7 +382,7 @@
 {
     if (source == NULL || request_headers.empty())
         return;
-    
+
     if (request_headers.find("Cookie") != request_headers.end()) {
         if (g_object_class_find_property(G_OBJECT_GET_CLASS(source),
                                          "cookies") != NULL) {
@@ -375,7 +391,7 @@
             g_strfreev(cookies);
         }
     }
-    
+
     if (request_headers.find("User-Agent") != request_headers.end()) {
         if (g_object_class_find_property(G_OBJECT_GET_CLASS(source),
                                          "user-agent") != NULL) {
@@ -427,8 +443,9 @@
     }
 
     // We only should query the pipeline if we actually succeeded in
-    // setting the requested state.
-    if (result && new_state == GST_STATE_PLAYING)
+    // setting the requested state. Also don't send on_video_dimensions_changed
+    // signal during EOS.
+    if (result && new_state == GST_STATE_PLAYING && !is_eos)
     {
         // Get the video height/width from the video sink
         try

=== modified file 'src/core/media/gstreamer/playbin.h'
--- src/core/media/gstreamer/playbin.h	2015-03-16 15:38:27 +0000
+++ src/core/media/gstreamer/playbin.h	2015-03-16 15:38:27 +0000
@@ -112,8 +112,10 @@
     GstElement* video_sink;
     core::Connection on_new_message_connection;
     bool is_seeking;
+    mutable uint64_t previous_position;
     core::ubuntu::media::Player::HeadersType request_headers;
     core::ubuntu::media::Player::Lifetime player_lifetime;
+    bool is_eos;
     struct
     {
         core::Signal<void> about_to_finish;

=== added file 'src/core/media/hashed_keyed_player_store.cpp'
--- src/core/media/hashed_keyed_player_store.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/hashed_keyed_player_store.cpp	2015-03-16 15:38:27 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <core/media/hashed_keyed_player_store.h>
+
+namespace media = core::ubuntu::media;
+
+media::HashedKeyedPlayerStore::HashedKeyedPlayerStore()
+{
+}
+
+const core::Property<std::shared_ptr<media::Player>>& media::HashedKeyedPlayerStore::current_player() const
+{
+    return prop_current_player;
+}
+
+bool media::HashedKeyedPlayerStore::has_player_for_key(const media::Player::PlayerKey& key) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    return map.count(key) > 0;
+}
+
+std::shared_ptr<media::Player> media::HashedKeyedPlayerStore::player_for_key(const media::Player::PlayerKey& key) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    auto it = map.find(key);
+
+    if (it == map.end()) throw std::out_of_range
+    {
+        "HashedKeyedPlayerStore::player_for_key: No player known for " + std::to_string(key)
+    };
+
+    return it->second;
+}
+
+void media::HashedKeyedPlayerStore::enumerate_players(const media::KeyedPlayerStore::PlayerEnumerator& enumerator) const
+{
+    std::lock_guard<std::mutex> lg{guard};
+    for (const auto& pair : map)
+        enumerator(pair.first, pair.second);
+}
+
+void media::HashedKeyedPlayerStore::add_player_for_key(const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
+{
+    std::lock_guard<std::mutex> lg{guard};
+    map[key] = player;
+}
+
+void media::HashedKeyedPlayerStore::remove_player_for_key(const media::Player::PlayerKey& key)
+{
+    std::lock_guard<std::mutex> lg{guard};
+    auto it = map.find(key);
+    if (it != map.end())
+    {
+        if (prop_current_player == it->second)
+            prop_current_player = nullptr;
+
+        map.erase(it);
+    }
+}
+
+void media::HashedKeyedPlayerStore::set_current_player_for_key(const media::Player::PlayerKey& key)
+{
+    prop_current_player = player_for_key(key);
+}

=== added file 'src/core/media/hashed_keyed_player_store.h'
--- src/core/media/hashed_keyed_player_store.h	1970-01-01 00:00:00 +0000
+++ src/core/media/hashed_keyed_player_store.h	2015-03-16 15:38:27 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef CORE_UBUNTU_MEDIA_HASHED_KEYED_PLAYER_STORE_H_
+#define CORE_UBUNTU_MEDIA_HASHED_KEYED_PLAYER_STORE_H_
+
+#include <core/media/keyed_player_store.h>
+
+#include <mutex>
+#include <unordered_map>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// Implements KeyedPlayerStore using a std::unordered_map.
+class HashedKeyedPlayerStore : public KeyedPlayerStore
+{
+public:
+    HashedKeyedPlayerStore();
+    // We keep track of the "current" player, that is, the one
+    // that has been created most recently, or has been explicitly foregrounded, or has been enabled for
+    // background playback. We provide a getable/observable access to that designated instance.
+    const core::Property<std::shared_ptr<media::Player>>& current_player() const override;
+
+    // We keep track of all known player sessions here and render them accessible via
+    // the key. All of these functions are thread-safe but not reentrant.
+    // Returns true iff a player is known for the given key.
+    bool has_player_for_key(const Player::PlayerKey& key) const override;
+
+    // Returns the player for the given key or throws std::out_of_range if no player is known
+    // for the given key.
+    // Throws std::out_of_range if no player is known for the key.
+    std::shared_ptr<Player> player_for_key(const Player::PlayerKey& key) const override;
+
+    // Enumerates all known players and invokes the given enumerator for each
+    // (key, player) pair.
+    void enumerate_players(const PlayerEnumerator& enumerator) const override;
+
+    // Adds the given player with the given key.
+    void add_player_for_key(const Player::PlayerKey& key, const std::shared_ptr<Player>& player) override;
+
+    // Removes the player for the given key, and unsets it if it is the current one.
+    void remove_player_for_key(const Player::PlayerKey& key) override;
+
+    // Makes the player known under the given key current.
+    // Throws std::out_of_range if no player is known for the key.
+    void set_current_player_for_key(const Player::PlayerKey& key) override;
+
+private:
+    core::Property<std::shared_ptr<Player>> prop_current_player;
+    mutable std::mutex guard;
+    std::unordered_map<Player::PlayerKey, std::shared_ptr<Player>> map;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_

=== added file 'src/core/media/keyed_player_store.cpp'
=== added file 'src/core/media/keyed_player_store.h'
--- src/core/media/keyed_player_store.h	1970-01-01 00:00:00 +0000
+++ src/core/media/keyed_player_store.h	2015-03-16 15:38:27 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_
+#define CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_
+
+#include <core/media/player.h>
+
+#include <core/property.h>
+
+#include <functional>
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// An interface abstracting keyed lookups of known Player instances.
+class KeyedPlayerStore
+{
+public:
+    // Save us some typing.
+    typedef std::shared_ptr<KeyedPlayerStore> Ptr;
+    // Functor for enumerating all known (key, player) pairs.
+    typedef std::function
+    <
+        void(
+            // The key of the player.
+            const Player::PlayerKey&,
+            // The actual player instance.
+            const std::shared_ptr<Player>&
+        )
+    > PlayerEnumerator;
+    // We keep track of the "current" player, that is, the one
+    // that has been created most recently and provide a getable/observable
+    // access to that designated instance.
+    virtual const core::Property<std::shared_ptr<Player>>& current_player() const = 0;
+
+    // We keep track of all known player sessions here and render them accessible via
+    // the key. All of these functions are thread-safe but not reentrant.
+    // Returns true iff a player is known for the given key.
+    virtual bool has_player_for_key(const Player::PlayerKey& key) const = 0;
+    // Returns the player for the given key or throws std::out_of_range if no player is known
+    // for the given key.
+    virtual std::shared_ptr<Player> player_for_key(const Player::PlayerKey& key) const = 0;
+    // Enumerates all known players and invokes the given enumerator for each
+    // (key, player) pair.
+    virtual void enumerate_players(const PlayerEnumerator& enumerator) const = 0;
+    // Adds the given player with the given key.
+    virtual void add_player_for_key(const Player::PlayerKey& key, const std::shared_ptr<Player>& player) = 0;
+    // Removes the player for the given key, and unsets it if it is the current one.
+    virtual void remove_player_for_key(const Player::PlayerKey& key) = 0;
+    // Makes the player known under the given key current.
+    virtual void set_current_player_for_key(const Player::PlayerKey& key) = 0;
+
+protected:
+    KeyedPlayerStore() = default;
+    KeyedPlayerStore(const KeyedPlayerStore&) = delete;
+    virtual ~KeyedPlayerStore() = default;
+    KeyedPlayerStore& operator=(const KeyedPlayerStore&) = delete;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_KEYED_PLAYER_STORE_H_

=== modified file 'src/core/media/mpris/player.h'
--- src/core/media/mpris/player.h	2015-03-16 15:38:27 +0000
+++ src/core/media/mpris/player.h	2015-03-16 15:38:27 +0000
@@ -136,6 +136,7 @@
     struct Signals
     {
         DBUS_CPP_SIGNAL_DEF(Seeked, Player, std::int64_t)
+        DBUS_CPP_SIGNAL_DEF(AboutToFinish, Player, void)
         DBUS_CPP_SIGNAL_DEF(EndOfStream, Player, void)
         DBUS_CPP_SIGNAL_DEF(PlaybackStatusChanged, Player, core::ubuntu::media::Player::PlaybackStatus)
         DBUS_CPP_SIGNAL_DEF(VideoDimensionChanged, Player, core::ubuntu::media::video::Dimensions)
@@ -246,6 +247,7 @@
               signals
               {
                   configuration.object->template get_signal<Signals::Seeked>(),
+                  configuration.object->template get_signal<Signals::AboutToFinish>(),
                   configuration.object->template get_signal<Signals::EndOfStream>(),
                   configuration.object->template get_signal<Signals::PlaybackStatusChanged>(),
                   configuration.object->template get_signal<Signals::VideoDimensionChanged>(),
@@ -373,6 +375,7 @@
         struct
         {
             typename core::dbus::Signal<Signals::Seeked, Signals::Seeked::ArgumentType>::Ptr seeked_to;
+            typename core::dbus::Signal<Signals::AboutToFinish, Signals::AboutToFinish::ArgumentType>::Ptr about_to_finish;
             typename core::dbus::Signal<Signals::EndOfStream, Signals::EndOfStream::ArgumentType>::Ptr end_of_stream;
             typename core::dbus::Signal<Signals::PlaybackStatusChanged, Signals::PlaybackStatusChanged::ArgumentType>::Ptr playback_status_changed;
             typename core::dbus::Signal<Signals::VideoDimensionChanged, Signals::VideoDimensionChanged::ArgumentType>::Ptr video_dimension_changed;

=== added file 'src/core/media/null_track_list.h'
--- src/core/media/null_track_list.h	1970-01-01 00:00:00 +0000
+++ src/core/media/null_track_list.h	2015-03-16 15:38:27 +0000
@@ -0,0 +1,114 @@
+/*
+ *
+ * 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_MEDIA_NULL_TRACK_LIST_H_
+#define CORE_MEDIA_NULL_TRACK_LIST_H_
+
+#include <core/media/track.h>
+#include <core/media/track_list.h>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// A helper type to replace the playlist implementation below.
+// Please note that this type is only a temporary manner. Ideally,
+// the actual implementation should be injected as a dependency from the
+// outside.
+struct NullTrackList : public media::TrackList
+{
+    NullTrackList() = default;
+
+    bool has_next()
+    {
+        return false;
+    }
+
+    media::Track::Id next()
+    {
+        return media::Track::Id{};
+    }
+
+    media::Track::UriType query_uri_for_track(const media::Track::Id&)
+    {
+        return media::Track::UriType{};
+    }
+
+    const core::Property<bool>& can_edit_tracks() const override
+    {
+        return props_and_sigs.can_edit_tracks;
+    }
+
+    const core::Property<Container>& tracks() const override
+    {
+        return props_and_sigs.tracks;
+    }
+
+    virtual media::Track::MetaData query_meta_data_for_track(const media::Track::Id&) override
+    {
+        return media::Track::MetaData{};
+    }
+
+    void add_track_with_uri_at(const media::Track::UriType&, const media::Track::Id&, bool) override
+    {
+    }
+
+    void remove_track(const media::Track::Id&) override
+    {
+    }
+
+    void go_to(const media::Track::Id&) override
+    {
+    }
+
+    const core::Signal<void>& on_track_list_replaced() const override
+    {
+        return props_and_sigs.on_track_list_replaced;
+    }
+
+    const core::Signal<media::Track::Id>& on_track_added() const override
+    {
+        return props_and_sigs.on_track_added;
+    }
+
+    const core::Signal<media::Track::Id>& on_track_removed() const override
+    {
+        return props_and_sigs.on_track_removed;
+    }
+
+    const core::Signal<media::Track::Id>& on_track_changed() const override
+    {
+        return props_and_sigs.on_track_changed;
+    }
+
+    struct
+    {
+        core::Property<bool> can_edit_tracks;
+        core::Property<TrackList::Container> tracks;
+        core::Signal<void> on_track_list_replaced;
+        core::Signal<media::Track::Id> on_track_added;
+        core::Signal<media::Track::Id> on_track_removed;
+        core::Signal<media::Track::Id> on_track_changed;
+    } props_and_sigs;
+};
+}
+}
+}
+
+#endif // CORE_MEDIA_NULL_TRACK_LIST_H_

=== modified file 'src/core/media/player.cpp'
--- src/core/media/player.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/player.cpp	2015-03-16 15:38:27 +0000
@@ -31,7 +31,6 @@
 {
     static const media::Player::Configuration config
     {
-        std::string{""},
         0,
         nullptr,
         nullptr

=== modified file 'src/core/media/player_configuration.h'
--- src/core/media/player_configuration.h	2014-09-09 10:28:32 +0000
+++ src/core/media/player_configuration.h	2015-03-16 15:38:27 +0000
@@ -27,9 +27,6 @@
 // to the implementation in a way that is opaque to the client.
 struct core::ubuntu::media::Player::Configuration
 {
-    // An identifier that is helpful in referencing the player instance
-    // across multiple services.
-    std::string identity;
     // Unique key for identifying the session.
     core::ubuntu::media::Player::PlayerKey key;
     // The bus connection to expose objects on.

=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/player_implementation.cpp	2015-03-16 15:38:27 +0000
@@ -23,6 +23,7 @@
 
 #include "client_death_observer.h"
 #include "engine.h"
+#include "null_track_list.h"
 #include "track_list_implementation.h"
 
 #include "gstreamer/engine.h"
@@ -39,7 +40,8 @@
 
 using namespace std;
 
-struct media::PlayerImplementation::Private :
+template<typename Parent>
+struct media::PlayerImplementation<Parent>::Private :
         public std::enable_shared_from_this<Private>
 {
     enum class wakelock_clear_t
@@ -50,30 +52,18 @@
         WAKELOCK_CLEAR_INVALID
     };
 
-    Private(PlayerImplementation* parent, const media::PlayerImplementation::Configuration& config)
+    Private(PlayerImplementation* parent, const media::PlayerImplementation<Parent>::Configuration& config)
         : parent(parent),
           config(config),
           display_state_lock(config.power_state_controller->display_state_lock()),
           system_state_lock(config.power_state_controller->system_state_lock()),
           engine(std::make_shared<gstreamer::Engine>()),
-          track_list(
-              new media::TrackListImplementation(
-                  config.session->path().as_string() + "/TrackList",
-                  engine->meta_data_extractor())),
+          track_list(std::make_shared<NullTrackList>()),
           system_wakelock_count(0),
           display_wakelock_count(0),
           previous_state(Engine::State::stopped),
           engine_state_change_connection(engine->state().changed().connect(make_state_change_handler()))
     {
-        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->config.key)
-                return;
-
-            on_client_died();
-        });
-
         // Poor man's logging of release/acquire events.
         display_state_lock->acquired().connect([](media::power::DisplayState state)
         {
@@ -207,7 +197,7 @@
                     if (--system_wakelock_count == 0)
                     {
                         std::cout << "Clearing system wakelock." << std::endl;
-                        system_state_lock->request_release(media::power::SystemState::active);                        
+                        system_state_lock->request_release(media::power::SystemState::active);
                     }
                     break;
                 case wakelock_clear_t::WAKELOCK_CLEAR_DISPLAY:
@@ -257,7 +247,7 @@
         // the execution of the functor may surpass the lifetime of this Private
         // object instance. By keeping a weak_ptr to the private object instance
         // we can check if the object is dead before calling methods on it
-        std::weak_ptr<Private> weak_self{shared_from_this()};
+        std::weak_ptr<Private> weak_self{this->shared_from_this()};
         auto wakelock_type = current_wakelock_type();
         return [weak_self, wakelock_type] {
             if (auto self = weak_self.lock())
@@ -271,14 +261,14 @@
     }
 
     // Our link back to our parent.
-    media::PlayerImplementation* parent;
+    media::PlayerImplementation<Parent>* parent;
     // We just store the parameters passed on construction.
-    media::PlayerImplementation::Configuration config;
+    media::PlayerImplementation<Parent>::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;
-    std::shared_ptr<TrackListImplementation> track_list;
+    std::shared_ptr<media::NullTrackList> track_list;
     std::atomic<int> system_wakelock_count;
     std::atomic<int> display_wakelock_count;
     Engine::State previous_state;
@@ -286,36 +276,29 @@
     core::Connection engine_state_change_connection;
 };
 
-media::PlayerImplementation::PlayerImplementation(const media::PlayerImplementation::Configuration& config)
-    : media::PlayerSkeleton
-      {
-          media::PlayerSkeleton::Configuration
-          {
-              config.bus,
-              config.session,
-              config.identity
-          }
-      },
+template<typename Parent>
+media::PlayerImplementation<Parent>::PlayerImplementation(const media::PlayerImplementation<Parent>::Configuration& config)
+    : Parent{config.parent},
       d{std::make_shared<Private>(this, config)}
 {
     // Initialize default values for Player interface properties
-    can_play().set(true);
-    can_pause().set(true);
-    can_seek().set(true);
-    can_go_previous().set(true);
-    can_go_next().set(true);
-    is_video_source().set(false);
-    is_audio_source().set(false);
-    is_shuffle().set(true);
-    playback_rate().set(1.f);
-    playback_status().set(Player::PlaybackStatus::null);
-    loop_status().set(Player::LoopStatus::none);
-    position().set(0);
-    duration().set(0);
-    audio_stream_role().set(Player::AudioStreamRole::multimedia);
+    Parent::can_play().set(true);
+    Parent::can_pause().set(true);
+    Parent::can_seek().set(true);
+    Parent::can_go_previous().set(true);
+    Parent::can_go_next().set(true);
+    Parent::is_video_source().set(false);
+    Parent::is_audio_source().set(false);
+    Parent::is_shuffle().set(true);
+    Parent::playback_rate().set(1.f);
+    Parent::playback_status().set(Player::PlaybackStatus::null);
+    Parent::loop_status().set(Player::LoopStatus::none);
+    Parent::position().set(0);
+    Parent::duration().set(0);
+    Parent::audio_stream_role().set(Player::AudioStreamRole::multimedia);
     d->engine->audio_stream_role().set(Player::AudioStreamRole::multimedia);
-    orientation().set(Player::Orientation::rotate0);
-    lifetime().set(Player::Lifetime::normal);
+    Parent::orientation().set(Player::Orientation::rotate0);
+    Parent::lifetime().set(Player::Lifetime::normal);
     d->engine->lifetime().set(Player::Lifetime::normal);
 
     // Make sure that the Position property gets updated from the Engine
@@ -324,7 +307,7 @@
     {
         return d->engine->position().get();
     };
-    position().install(position_getter);
+    Parent::position().install(position_getter);
 
     // Make sure that the Duration property gets updated from the Engine
     // every time the client requests duration
@@ -332,23 +315,23 @@
     {
         return d->engine->duration().get();
     };
-    duration().install(duration_getter);
+    Parent::duration().install(duration_getter);
 
     std::function<bool()> video_type_getter = [this]()
     {
         return d->engine->is_video_source().get();
     };
-    is_video_source().install(video_type_getter);
+    Parent::is_video_source().install(video_type_getter);
 
     std::function<bool()> audio_type_getter = [this]()
     {
         return d->engine->is_audio_source().get();
     };
-    is_audio_source().install(audio_type_getter);
+    Parent::is_audio_source().install(audio_type_getter);
 
     // Make sure that the audio_stream_role property gets updated on the Engine side
     // whenever the client side sets the role
-    audio_stream_role().changed().connect([this](media::Player::AudioStreamRole new_role)
+    Parent::audio_stream_role().changed().connect([this](media::Player::AudioStreamRole new_role)
     {
         d->engine->audio_stream_role().set(new_role);
     });
@@ -357,16 +340,18 @@
     // update the Player's cached value
     d->engine->orientation().changed().connect([this](const Player::Orientation& o)
     {
-        orientation().set(o);
+        Parent::orientation().set(o);
     });
 
-    lifetime().changed().connect([this](media::Player::Lifetime lifetime)
+    Parent::lifetime().changed().connect([this](media::Player::Lifetime lifetime)
     {
         d->engine->lifetime().set(lifetime);
     });
 
     d->engine->about_to_finish_signal().connect([this]()
     {
+        Parent::about_to_finish()();
+
         if (d->track_list->has_next())
         {
             Track::UriType uri = d->track_list->query_uri_for_track(d->track_list->next());
@@ -386,31 +371,52 @@
 
     d->engine->seeked_to_signal().connect([this](uint64_t value)
     {
-        seeked_to()(value);
+        Parent::seeked_to()(value);
     });
 
     d->engine->end_of_stream_signal().connect([this]()
     {
-        end_of_stream()();
+        Parent::end_of_stream()();
     });
 
     d->engine->playback_status_changed_signal().connect([this](const Player::PlaybackStatus& status)
     {
-        playback_status_changed()(status);
+        Parent::playback_status_changed()(status);
     });
 
     d->engine->video_dimension_changed_signal().connect([this](const media::video::Dimensions& dimensions)
     {
-        video_dimension_changed()(dimensions);
+        Parent::video_dimension_changed()(dimensions);
     });
 
     d->engine->error_signal().connect([this](const Player::Error& e)
     {
-        error()(e);
+        Parent::error()(e);
+    });
+
+    // Everything is setup, we now subscribe to death notifications.
+    std::weak_ptr<Private> wp{d};
+
+    d->config.client_death_observer->register_for_death_notifications_with_key(config.key);
+    d->config.client_death_observer->on_client_with_key_died().connect([wp](const media::Player::PlayerKey& died)
+    {
+        if (auto sp = wp.lock())
+        {
+            if (died != sp->config.key)
+                return;
+
+            static const std::chrono::milliseconds timeout{1000};
+            media::timeout(timeout.count(), true, [wp]()
+            {
+                if (auto sp = wp.lock())
+                    sp->on_client_died();
+            });
+        }
     });
 }
 
-media::PlayerImplementation::~PlayerImplementation()
+template<typename Parent>
+media::PlayerImplementation<Parent>::~PlayerImplementation()
 {
     // Install null getters as these properties may be destroyed
     // after the engine has been destroyed since they are owned by the
@@ -419,84 +425,101 @@
     {
         return static_cast<uint64_t>(0);
     };
-    position().install(position_getter);
+    Parent::position().install(position_getter);
 
     std::function<uint64_t()> duration_getter = [this]()
     {
         return static_cast<uint64_t>(0);
     };
-    duration().install(duration_getter);
+    Parent::duration().install(duration_getter);
 
     std::function<bool()> video_type_getter = [this]()
     {
         return false;
     };
-    is_video_source().install(video_type_getter);
+    Parent::is_video_source().install(video_type_getter);
 
     std::function<bool()> audio_type_getter = [this]()
     {
         return false;
     };
-    is_audio_source().install(audio_type_getter);
+    Parent::is_audio_source().install(audio_type_getter);
 }
 
-std::shared_ptr<media::TrackList> media::PlayerImplementation::track_list()
+template<typename Parent>
+std::shared_ptr<media::TrackList> media::PlayerImplementation<Parent>::track_list()
 {
     return d->track_list;
 }
 
 // TODO: Convert this to be a property instead of sync call
-media::Player::PlayerKey media::PlayerImplementation::key() const
+template<typename Parent>
+media::Player::PlayerKey media::PlayerImplementation<Parent>::key() const
 {
     return d->config.key;
 }
 
-media::video::Sink::Ptr media::PlayerImplementation::create_gl_texture_video_sink(std::uint32_t texture_id)
+template<typename Parent>
+media::video::Sink::Ptr media::PlayerImplementation<Parent>::create_gl_texture_video_sink(std::uint32_t texture_id)
 {
     d->engine->create_video_sink(texture_id);
     return media::video::Sink::Ptr{};
 }
 
-bool media::PlayerImplementation::open_uri(const Track::UriType& uri)
+template<typename Parent>
+bool media::PlayerImplementation<Parent>::open_uri(const Track::UriType& uri)
 {
     return d->engine->open_resource_for_uri(uri);
 }
 
-bool media::PlayerImplementation::open_uri(const Track::UriType& uri, const Player::HeadersType& headers)
+template<typename Parent>
+bool media::PlayerImplementation<Parent>::open_uri(const Track::UriType& uri, const Player::HeadersType& headers)
 {
     return d->engine->open_resource_for_uri(uri, headers);
 }
 
-void media::PlayerImplementation::next()
-{
-}
-
-void media::PlayerImplementation::previous()
-{
-}
-
-void media::PlayerImplementation::play()
+template<typename Parent>
+void media::PlayerImplementation<Parent>::next()
+{
+}
+
+template<typename Parent>
+void media::PlayerImplementation<Parent>::previous()
+{
+}
+
+template<typename Parent>
+void media::PlayerImplementation<Parent>::play()
 {
     d->engine->play();
 }
 
-void media::PlayerImplementation::pause()
+template<typename Parent>
+void media::PlayerImplementation<Parent>::pause()
 {
     d->engine->pause();
 }
 
-void media::PlayerImplementation::stop()
+template<typename Parent>
+void media::PlayerImplementation<Parent>::stop()
 {
     std::cout << __PRETTY_FUNCTION__ << std::endl;
     d->engine->stop();
 }
 
-void media::PlayerImplementation::seek_to(const std::chrono::microseconds& ms)
+template<typename Parent>
+void media::PlayerImplementation<Parent>::seek_to(const std::chrono::microseconds& ms)
 {
     d->engine->seek_to(ms);
 }
 
-const core::Signal<>& media::PlayerImplementation::on_client_disconnected() const
+template<typename Parent>
+const core::Signal<>& media::PlayerImplementation<Parent>::on_client_disconnected() const
 {
     return d->on_client_disconnected;
 }
+
+#include <core/media/player_skeleton.h>
+
+// For linking purposes, we have to make sure that we have all symbols included within the dso.
+template class media::PlayerImplementation<media::PlayerSkeleton>;

=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2015-03-16 15:38:27 +0000
+++ src/core/media/player_implementation.h	2015-03-16 15:38:27 +0000
@@ -19,8 +19,9 @@
 #ifndef CORE_UBUNTU_MEDIA_PLAYER_IMPLEMENTATION_H_
 #define CORE_UBUNTU_MEDIA_PLAYER_IMPLEMENTATION_H_
 
-#include "player_skeleton.h"
+#include <core/media/player.h>
 
+#include "apparmor/ubuntu.h"
 #include "client_death_observer.h"
 #include "power/state_controller.h"
 
@@ -35,18 +36,17 @@
 class Engine;
 class Service;
 
-class PlayerImplementation : public PlayerSkeleton
+template<typename Parent>
+class PlayerImplementation : public Parent
 {
 public:
     // All creation time arguments go here
     struct Configuration
     {
-        std::string identity;
-        std::shared_ptr<core::dbus::Bus> bus;
-        std::shared_ptr<core::dbus::Object> session;
-        std::shared_ptr<Service> service;
-        PlayerKey key;
-
+        // All creation time configuration options of the Parent class.
+        typename Parent::Configuration parent;
+        // The unique key identifying the player instance.
+        Player::PlayerKey key;
         // Functional dependencies
         ClientDeathObserver::Ptr client_death_observer;
         power::StateController::Ptr power_state_controller;
@@ -56,7 +56,7 @@
     ~PlayerImplementation();
 
     virtual std::shared_ptr<TrackList> track_list();
-    virtual PlayerKey key() const;
+    virtual Player::PlayerKey key() const;
 
     virtual video::Sink::Ptr create_gl_texture_video_sink(std::uint32_t texture_id);
 

=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/player_skeleton.cpp	2015-03-16 15:38:27 +0000
@@ -17,15 +17,16 @@
  *              Jim Hodapp <[e-mail]>
  */
 
-#include "apparmor.h"
 #include "codec.h"
 #include "engine.h"
+#include "external_services.h"
 #include "player_skeleton.h"
 #include "player_traits.h"
 #include "property_stub.h"
 #include "the_session_bus.h"
 #include "xesam.h"
 
+#include "apparmor/ubuntu.h"
 #include "mpris/media_player2.h"
 #include "mpris/metadata.h"
 #include "mpris/player.h"
@@ -44,19 +45,20 @@
 struct media::PlayerSkeleton::Private
 {
     Private(media::PlayerSkeleton* player,
-            const std::string& identity,
             const std::shared_ptr<core::dbus::Bus>& bus,
-            const std::shared_ptr<core::dbus::Object>& session)
+            const std::shared_ptr<core::dbus::Object>& session,
+            const apparmor::ubuntu::RequestContextResolver::Ptr& request_context_resolver,
+            const apparmor::ubuntu::RequestAuthenticator::Ptr& request_authenticator)
         : impl(player),
-          identity(identity),
           bus(bus),
           object(session),
-          apparmor_session(nullptr),
-          dbus_stub{bus},
+          request_context_resolver{request_context_resolver},
+          request_authenticator{request_authenticator},
           skeleton{mpris::Player::Skeleton::Configuration{bus, session, mpris::Player::Skeleton::Configuration::Defaults{}}},
           signals
           {
               skeleton.signals.seeked_to,
+              skeleton.signals.about_to_finish,
               skeleton.signals.end_of_stream,
               skeleton.signals.playback_status_changed,
               skeleton.signals.video_dimension_changed,
@@ -163,82 +165,6 @@
         bus->send(reply);
     }
 
-    bool does_client_have_access(const std::string& context, const std::string& uri)
-    {
-        if (context.empty() || uri.empty())
-        {
-            std::cout << "Client denied access since context or uri are empty" << std::endl;
-            return false;
-        }
-
-        if (context == "unconfined")
-        {
-            std::cout << "Client allowed access since it's unconfined" << std::endl;
-            return true;
-        }
-
-        size_t pos = context.find_first_of('_');
-        if (pos == std::string::npos)
-        {
-            std::cout << "Client denied access since it's an invalid apparmor security context" << std::endl;
-            return false;
-        }
-
-        const std::string pkgname = context.substr(0, pos);
-        std::cout << "client pkgname: " << pkgname << std::endl;
-        std::cout << "uri: " << uri << std::endl;
-
-        // All confined apps can access their own files
-        if (uri.find(std::string(".local/share/" + pkgname + "/")) != std::string::npos
-                || uri.find(std::string(".cache/" + pkgname + "/")) != std::string::npos)
-        {
-            std::cout << "Client can access content in ~/.local/share/" << pkgname << " or ~/.cache/" << pkgname << std::endl;
-            return true;
-        }
-        else if (uri.find(std::string("opt/click.ubuntu.com/")) != std::string::npos
-                && uri.find(pkgname) != std::string::npos)
-        {
-            std::cout << "Client can access content in own opt directory" << std::endl;
-            return true;
-        }
-        else if ((uri.find(std::string("/system/media/audio/ui/")) != std::string::npos
-                || uri.find(std::string("/android/system/media/audio/ui/")) != std::string::npos)
-                && pkgname == "com.ubuntu.camera")
-        {
-            std::cout << "Camera app can access ui sounds" << std::endl;
-            return true;
-        }
-        // TODO: Check if the trust store previously allowed direct access to uri
-
-        // Check in ~/Music and ~/Videos
-        // TODO: when the trust store lands, check it to see if this app can access the dirs and
-        // then remove the explicit whitelist of the music-app, and gallery-app
-        else if ((pkgname == "com.ubuntu.music" || pkgname == "com.ubuntu.gallery") &&
-                (uri.find(std::string("Music/")) != std::string::npos
-                || uri.find(std::string("Videos/")) != std::string::npos
-                || uri.find(std::string("/media")) != std::string::npos))
-        {
-            std::cout << "Client can access content in ~/Music or ~/Videos" << std::endl;
-            return true;
-        }
-        else if (uri.find(std::string("/usr/share/sounds")) != std::string::npos)
-        {
-            std::cout << "Client can access content in /usr/share/sounds" << std::endl;
-            return true;
-        }
-        else if (uri.find(std::string("http://")) != std::string::npos
-                || uri.find(std::string("rtsp://")) != std::string::npos)
-        {
-            std::cout << "Client can access streaming content" << std::endl;
-            return true;
-        }
-        else
-        {
-            std::cout << "Client denied access to open_uri()" << std::endl;
-            return false;
-        }
-    }
-
     void handle_key(const core::dbus::Message::Ptr& in)
     {
         auto reply = dbus::Message::make_method_return(in);
@@ -248,15 +174,15 @@
 
     void handle_open_uri(const core::dbus::Message::Ptr& in)
     {
-        dbus_stub.get_connection_app_armor_security_async(in->sender(), [this, in](const std::string& profile)
+        request_context_resolver->resolve_context_for_dbus_name_async(in->sender(), [this, in](const media::apparmor::ubuntu::Context& context)
         {
             Track::UriType uri;
             in->reader() >> uri;
 
-            bool have_access = does_client_have_access(profile, uri);
+            auto result = request_authenticator->authenticate_open_uri_request(context, uri);
 
             auto reply = dbus::Message::make_method_return(in);
-            reply->writer() << (have_access ? impl->open_uri(uri) : false);
+            reply->writer() << (std::get<0>(result) ? impl->open_uri(uri) : false);
 
             bus->send(reply);
         });
@@ -264,16 +190,16 @@
 
     void handle_open_uri_extended(const core::dbus::Message::Ptr& in)
     {
-        dbus_stub.get_connection_app_armor_security_async(in->sender(), [this, in](const std::string& profile)
+        request_context_resolver->resolve_context_for_dbus_name_async(in->sender(), [this, in](const media::apparmor::ubuntu::Context& context)
         {
             Track::UriType uri;
             Player::HeadersType headers;
 
             in->reader() >> uri >> headers;
 
-            bool have_access = does_client_have_access(profile, uri);
+            auto result = request_authenticator->authenticate_open_uri_request(context, uri);
             auto reply = dbus::Message::make_method_return(in);
-            reply->writer() << (have_access ? impl->open_uri(uri, headers) : false);
+            reply->writer() << (std::get<0>(result) ? impl->open_uri(uri, headers) : false);
 
             bus->send(reply);
         });
@@ -301,12 +227,10 @@
     }
 
     media::PlayerSkeleton* impl;
-    std::string identity;
     dbus::Bus::Ptr bus;
     dbus::Object::Ptr object;
-    dbus::Object::Ptr apparmor_session;
-
-    org::freedesktop::dbus::DBus::Stub dbus_stub;
+    media::apparmor::ubuntu::RequestContextResolver::Ptr request_context_resolver;
+    media::apparmor::ubuntu::RequestAuthenticator::Ptr request_authenticator;
 
     mpris::Player::Skeleton skeleton;
 
@@ -314,11 +238,13 @@
     {
         typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::AboutToFinish, mpris::Player::Signals::AboutToFinish::ArgumentType> DBusAboutToFinishSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::PlaybackStatusChanged, mpris::Player::Signals::PlaybackStatusChanged::ArgumentType> DBusPlaybackStatusChangedSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::VideoDimensionChanged, mpris::Player::Signals::VideoDimensionChanged::ArgumentType> DBusVideoDimensionChangedSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::Error, mpris::Player::Signals::Error::ArgumentType> DBusErrorSignal;
 
         Signals(const std::shared_ptr<DBusSeekedToSignal>& remote_seeked,
+                const std::shared_ptr<DBusAboutToFinishSignal>& remote_atf,
                 const std::shared_ptr<DBusEndOfStreamSignal>& remote_eos,
                 const std::shared_ptr<DBusPlaybackStatusChangedSignal>& remote_playback_status_changed,
                 const std::shared_ptr<DBusVideoDimensionChangedSignal>& remote_video_dimension_changed,
@@ -329,6 +255,11 @@
                 remote_seeked->emit(value);
             });
 
+            about_to_finish.connect([remote_atf]()
+            {
+                remote_atf->emit();
+            });
+
             end_of_stream.connect([remote_eos]()
             {
                 remote_eos->emit();
@@ -351,6 +282,7 @@
         }
 
         core::Signal<int64_t> seeked_to;
+        core::Signal<void> about_to_finish;
         core::Signal<void> end_of_stream;
         core::Signal<media::Player::PlaybackStatus> playback_status_changed;
         core::Signal<media::video::Dimensions> video_dimension_changed;
@@ -360,7 +292,7 @@
 };
 
 media::PlayerSkeleton::PlayerSkeleton(const media::PlayerSkeleton::Configuration& config)
-        : d(new Private{this, config.identity, config.bus, config.session})
+        : d(new Private{this, config.bus, config.session, config.request_context_resolver, config.request_authenticator})
 {
     // Setup method handlers for mpris::Player methods.
     auto next = std::bind(&Private::handle_next, d, std::placeholders::_1);
@@ -635,6 +567,16 @@
     return d->signals.seeked_to;
 }
 
+const core::Signal<void>& media::PlayerSkeleton::about_to_finish() const
+{
+    return d->signals.about_to_finish;
+}
+
+core::Signal<void>& media::PlayerSkeleton::about_to_finish()
+{
+    return d->signals.about_to_finish;
+}
+
 const core::Signal<void>& media::PlayerSkeleton::end_of_stream() const
 {
     return d->signals.end_of_stream;

=== modified file 'src/core/media/player_skeleton.h'
--- src/core/media/player_skeleton.h	2015-03-16 15:38:27 +0000
+++ src/core/media/player_skeleton.h	2015-03-16 15:38:27 +0000
@@ -24,6 +24,7 @@
 
 #include "player_traits.h"
 
+#include "apparmor/ubuntu.h"
 #include "mpris/player.h"
 
 #include <core/dbus/skeleton.h>
@@ -37,11 +38,29 @@
 {
 namespace media
 {
+namespace helper
+{
+struct ExternalServices;
+}
+
 class Service;
 
 class PlayerSkeleton : public core::ubuntu::media::Player
 {
   public:
+    // All creation time arguments go here.
+    struct Configuration
+    {
+        // The bus connection we are associated with.
+        std::shared_ptr<core::dbus::Bus> bus;
+        // The session object that we want to expose the skeleton upon.
+        std::shared_ptr<core::dbus::Object> session;
+        // Our functional dependencies.
+        apparmor::ubuntu::RequestContextResolver::Ptr request_context_resolver;
+        apparmor::ubuntu::RequestAuthenticator::Ptr request_authenticator;
+    };
+
+    PlayerSkeleton(const Configuration& configuration);
     ~PlayerSkeleton();
 
     virtual const core::Property<bool>& can_play() const;
@@ -73,26 +92,11 @@
     virtual core::Property<Lifetime>& lifetime();
 
     virtual const core::Signal<int64_t>& seeked_to() const;
+    virtual const core::Signal<void>& about_to_finish() const;
     virtual const core::Signal<void>& end_of_stream() const;
-    virtual core::Signal<PlaybackStatus>& playback_status_changed();
     virtual const core::Signal<video::Dimensions>& video_dimension_changed() const;
     virtual const core::Signal<Error>& error() const;
 
-protected:
-    // All creation time arguments go here.
-    struct Configuration
-    {
-        // The bus connection we are associated with.
-        std::shared_ptr<core::dbus::Bus> bus;
-        // The session object that we want to expose the skeleton upon.
-        std::shared_ptr<core::dbus::Object> session;
-        // Our identity, an identifier we pass out to other parts of the system.
-        // Defaults to the short app id (${PKG_NAME}_${APP}).
-        std::string identity;
-    };
-
-    PlayerSkeleton(const Configuration& configuration);
-
     // These properties are not exposed to the client, but still need to be
     // able to be settable from within the Player:
     virtual core::Property<PlaybackStatus>& playback_status();
@@ -111,7 +115,9 @@
     virtual core::Property<Orientation>& orientation();
 
     virtual core::Signal<int64_t>& seeked_to();
+    virtual core::Signal<void>& about_to_finish();
     virtual core::Signal<void>& end_of_stream();
+    virtual core::Signal<PlaybackStatus>& playback_status_changed();
     virtual core::Signal<video::Dimensions>& video_dimension_changed();
     virtual core::Signal<Error>& error();
 

=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/player_stub.cpp	2015-03-16 15:38:27 +0000
@@ -76,6 +76,7 @@
                 signals
                 {
                     object->get_signal<mpris::Player::Signals::Seeked>(),
+                    object->get_signal<mpris::Player::Signals::AboutToFinish>(),
                     object->get_signal<mpris::Player::Signals::EndOfStream>(),
                     object->get_signal<mpris::Player::Signals::PlaybackStatusChanged>(),
                     object->get_signal<mpris::Player::Signals::VideoDimensionChanged>(),
@@ -122,17 +123,20 @@
     struct Signals
     {
         typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::AboutToFinish, mpris::Player::Signals::AboutToFinish::ArgumentType> DBusAboutToFinishSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::PlaybackStatusChanged, mpris::Player::Signals::PlaybackStatusChanged::ArgumentType> DBusPlaybackStatusChangedSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::VideoDimensionChanged, mpris::Player::Signals::VideoDimensionChanged::ArgumentType> DBusVideoDimensionChangedSignal;
         typedef core::dbus::Signal<mpris::Player::Signals::Error, mpris::Player::Signals::Error::ArgumentType> DBusErrorSignal;
 
         Signals(const std::shared_ptr<DBusSeekedToSignal>& seeked,
+                const std::shared_ptr<DBusAboutToFinishSignal>& atf,
                 const std::shared_ptr<DBusEndOfStreamSignal>& eos,
                 const std::shared_ptr<DBusPlaybackStatusChangedSignal>& status,
                 const std::shared_ptr<DBusVideoDimensionChangedSignal>& d,
                 const std::shared_ptr<DBusErrorSignal>& e)
             : seeked_to(),
+              about_to_finish(),
               end_of_stream(),
               playback_status_changed(),
               video_dimension_changed(),
@@ -140,6 +144,7 @@
               dbus
               {
                   seeked,
+                  atf,
                   eos,
                   status,
                   d,
@@ -152,6 +157,12 @@
                 seeked_to(value);
             });
 
+            dbus.about_to_finish->connect([this]()
+            {
+                std::cout << "AboutToFinish signal arrived via the bus." << std::endl;
+                about_to_finish();
+            });
+
             dbus.end_of_stream->connect([this]()
             {
                 std::cout << "EndOfStream signal arrived via the bus." << std::endl;
@@ -178,6 +189,7 @@
         }
 
         core::Signal<int64_t> seeked_to;
+        core::Signal<void> about_to_finish;
         core::Signal<void> end_of_stream;
         core::Signal<media::Player::PlaybackStatus> playback_status_changed;
         core::Signal<media::video::Dimensions> video_dimension_changed;
@@ -186,6 +198,7 @@
         struct DBus
         {
             std::shared_ptr<DBusSeekedToSignal> seeked_to;
+            std::shared_ptr<DBusAboutToFinishSignal> about_to_finish;
             std::shared_ptr<DBusEndOfStreamSignal> end_of_stream;
             std::shared_ptr<DBusPlaybackStatusChangedSignal> playback_status_changed;
             std::shared_ptr<DBusVideoDimensionChangedSignal> video_dimension_changed;
@@ -434,6 +447,11 @@
     return d->signals.seeked_to;
 }
 
+const core::Signal<void>& media::PlayerStub::about_to_finish() const
+{
+    return d->signals.about_to_finish;
+}
+
 const core::Signal<void>& media::PlayerStub::end_of_stream() const
 {
     return d->signals.end_of_stream;

=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2015-03-16 15:38:27 +0000
+++ src/core/media/player_stub.h	2015-03-16 15:38:27 +0000
@@ -86,6 +86,7 @@
     virtual core::Property<Lifetime>& lifetime();
 
     virtual const core::Signal<int64_t>& seeked_to() const;
+    virtual const core::Signal<void>& about_to_finish() const;
     virtual const core::Signal<void>& end_of_stream() const;
     virtual core::Signal<PlaybackStatus>& playback_status_changed();
     virtual const core::Signal<video::Dimensions>& video_dimension_changed() const;

=== modified file 'src/core/media/power/state_controller.cpp'
--- src/core/media/power/state_controller.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/power/state_controller.cpp	2015-03-16 15:38:27 +0000
@@ -128,42 +128,38 @@
         if (cookie == the_invalid_cookie)
             return;
 
-        std::weak_ptr<DisplayStateLock> wp{shared_from_this()};
+        // We make sure that we keep ourselves alive to make sure
+        // that release requests are always correctly issued.
+        auto sp = 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)
+        timeout.async_wait([sp, state, current_cookie](const boost::system::error_code& ec)
         {
             // We only return early from the timeout handler if the operation has been
             // explicitly aborted before.
             if (ec == boost::asio::error::operation_aborted)
                 return;
 
-            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)
+            sp->object->invoke_method_asynchronously_with_callback<com::canonical::Unity::Screen::removeDisplayOnRequest, void>(
+                        [sp, state, current_cookie](const core::dbus::Result<void>& result)
+                        {
+                            if (result.is_error())
                             {
-                                if (result.is_error())
-                                {
-                                    std::cerr << result.error().print() << std::endl;
-                                    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);
-            }
+                                std::cerr << result.error().print() << std::endl;
+                                return;
+                            }
+
+                            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);
         });
     }
 

=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/server/server.cpp	2015-03-16 15:38:27 +0000
@@ -20,6 +20,7 @@
 #include <core/media/player.h>
 #include <core/media/track_list.h>
 
+#include "core/media/hashed_keyed_player_store.h"
 #include "core/media/service_implementation.h"
 
 #include <core/posix/signal.h>
@@ -103,23 +104,37 @@
         }
     };
 
+    // Our common player store instance for tracking player instances.
+    auto player_store = std::make_shared<media::HashedKeyedPlayerStore>();
     // We assemble the configuration for executing the service now.
     media::ServiceImplementation::Configuration service_config
     {
+        std::make_shared<media::HashedKeyedPlayerStore>(),
         external_services
     };
 
-    auto service = std::make_shared<media::ServiceImplementation>(service_config);
+    auto impl = std::make_shared<media::ServiceImplementation>(media::ServiceImplementation::Configuration
+    {
+        player_store,
+        external_services
+    });
+
+    auto skeleton = std::make_shared<media::ServiceSkeleton>(media::ServiceSkeleton::Configuration
+    {
+        impl,
+        player_store,
+
+    });
 
     std::thread service_worker
     {
-        [&shutdown_requested, service]()
+        [&shutdown_requested, skeleton]()
         {
             while (not shutdown_requested)
             {
                 try
                 {
-                    service->run();
+                    skeleton->run();
                 }
                 catch (const std::exception& e)
                 {
@@ -142,7 +157,7 @@
     shutdown_requested = true;
 
     // And stop execution of helper and actual service.
-    service->stop();
+    skeleton->stop();
 
     if (service_worker.joinable())
         service_worker.join();

=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2015-03-16 15:38:27 +0000
+++ src/core/media/service_implementation.cpp	2015-03-16 15:38:27 +0000
@@ -22,14 +22,16 @@
 
 #include "service_implementation.h"
 
+#include "apparmor/ubuntu.h"
 #include "audio/output_observer.h"
 #include "client_death_observer.h"
-#include "call-monitor/call_monitor.h"
 #include "player_configuration.h"
+#include "player_skeleton.h"
 #include "player_implementation.h"
 #include "power/battery_observer.h"
 #include "power/state_controller.h"
 #include "recorder_observer.h"
+#include "telephony/call_monitor.h"
 
 #include <boost/asio.hpp>
 
@@ -59,8 +61,10 @@
           client_death_observer(media::platform_default_client_death_observer()),
           recorder_observer(media::make_platform_default_recorder_observer()),
           audio_output_observer(media::audio::make_platform_default_output_observer()),
+          request_context_resolver(media::apparmor::ubuntu::make_platform_default_request_context_resolver(configuration.external_services)),
+          request_authenticator(media::apparmor::ubuntu::make_platform_default_request_authenticator()),
           audio_output_state(media::audio::OutputState::Speaker),
-          call_monitor(new CallMonitor)
+          call_monitor(media::telephony::make_platform_default_call_monitor())
     {
     }
 
@@ -74,13 +78,16 @@
     media::ClientDeathObserver::Ptr client_death_observer;
     media::RecorderObserver::Ptr recorder_observer;
     media::audio::OutputObserver::Ptr audio_output_observer;
-    media::audio::OutputObserver audio_output_state;
+    media::apparmor::ubuntu::RequestContextResolver::Ptr request_context_resolver;
+    media::apparmor::ubuntu::RequestAuthenticator::Ptr request_authenticator;
+    media::audio::OutputState audio_output_state;
 
-    std::unique_ptr<CallMonitor> call_monitor;
+    media::telephony::CallMonitor::Ptr call_monitor;
     std::list<media::Player::PlayerKey> paused_sessions;
 };
 
-media::ServiceImplementation::ServiceImplementation(const Configuration& configuration) : d(new Private(configuration))
+media::ServiceImplementation::ServiceImplementation(const Configuration& configuration)
+    : d(new Private(configuration))
 {
     d->battery_observer->level().changed().connect([this](const media::power::Level& level)
     {
@@ -118,22 +125,20 @@
             break;
         case audio::OutputState::External:
             std::cout << "AudioOutputObserver reports that output is now External." << std::endl;
-            if (d->audio_output_state == audio::OutputState::Earpiece)
-                pause_all_multimedia_sessions();
             break;
         }
         d->audio_output_state = state;
     });
 
-    d->call_monitor->on_change([this](CallMonitor::State state) {
+    d->call_monitor->on_call_state_changed().connect([this](media::telephony::CallMonitor::State state)
+    {
         switch (state) {
-        case CallMonitor::OffHook:
+        case media::telephony::CallMonitor::State::OffHook:
             std::cout << "Got call started signal, pausing all multimedia sessions" << std::endl;
             pause_all_multimedia_sessions();
             break;
-        case CallMonitor::OnHook:
+        case media::telephony::CallMonitor::State::OnHook:
             std::cout << "Got call ended signal, resuming paused multimedia sessions" << std::endl;
-            // Don't auto-resume any paused video playback sessions
             resume_paused_multimedia_sessions(false);
             break;
         }
@@ -160,12 +165,15 @@
 std::shared_ptr<media::Player> media::ServiceImplementation::create_session(
         const media::Player::Configuration& conf)
 {
-    auto player = std::make_shared<media::PlayerImplementation>(media::PlayerImplementation::Configuration
+    auto player = std::make_shared<media::PlayerImplementation<media::PlayerSkeleton>>(media::PlayerImplementation<media::PlayerSkeleton>::Configuration
     {
-        conf.identity,
-        conf.bus,
-        conf.session,
-        shared_from_this(),
+        media::PlayerSkeleton::Configuration
+        {
+            conf.bus,
+            conf.session,
+            d->request_context_resolver,
+            d->request_authenticator
+        },
         conf.key,
         d->client_death_observer,
         d->power_state_controller
@@ -181,11 +189,11 @@
         // until all dispatches are done
         d->configuration.external_services.io_service.post([this, key]()
         {
-            if (!has_player_for_key(key))
+            if (!d->configuration.player_store->has_player_for_key(key))
                 return;
 
-            if (player_for_key(key)->lifetime() == Player::Lifetime::normal)
-                remove_player_for_key(key);
+            if (d->configuration.player_store->player_for_key(key)->lifetime() == Player::Lifetime::normal)
+                d->configuration.player_store->remove_player_for_key(key);
         });
     });
 
@@ -206,19 +214,19 @@
 
 void media::ServiceImplementation::pause_other_sessions(media::Player::PlayerKey key)
 {
-    if (not has_player_for_key(key))
+    if (not d->configuration.player_store->has_player_for_key(key))
     {
         cerr << "Could not find Player by key: " << key << endl;
         return;
     }
 
-    auto current_player = player_for_key(key);
+    auto current_player = d->configuration.player_store->player_for_key(key);
 
     // We immediately make the player known as new current player.
     if (current_player->audio_stream_role() == media::Player::multimedia)
-        set_current_player_for_key(key);
+        d->configuration.player_store->set_current_player_for_key(key);
 
-    enumerate_players([current_player, key](const media::Player::PlayerKey& other_key, const std::shared_ptr<media::Player>& other_player)
+    d->configuration.player_store->enumerate_players([current_player, key](const media::Player::PlayerKey& other_key, const std::shared_ptr<media::Player>& other_player)
     {
         // Only pause a Player if all of the following criteria are met:
         // 1) currently playing
@@ -238,7 +246,7 @@
 
 void media::ServiceImplementation::pause_all_multimedia_sessions()
 {
-    enumerate_players([this](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
+    d->configuration.player_store->enumerate_players([this](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
                       {
                           if (player->playback_status() == Player::playing
                               && player->audio_stream_role() == media::Player::multimedia)
@@ -253,7 +261,7 @@
 void media::ServiceImplementation::resume_paused_multimedia_sessions(bool resume_video_sessions)
 {
     std::for_each(d->paused_sessions.begin(), d->paused_sessions.end(), [this, resume_video_sessions](const media::Player::PlayerKey& key) {
-            auto player = player_for_key(key);
+            auto player = d->configuration.player_store->player_for_key(key);
             // Only resume video playback if explicitly desired
             if (resume_video_sessions || player->is_audio_source())
                 player->play();
@@ -266,10 +274,10 @@
 
 void media::ServiceImplementation::resume_multimedia_session()
 {
-    if (not has_player_for_key(d->resume_key))
+    if (not d->configuration.player_store->has_player_for_key(d->resume_key))
         return;
 
-    auto player = player_for_key(d->resume_key);
+    auto player = d->configuration.player_store->player_for_key(d->resume_key);
 
     if (player->playback_status() == Player::paused)
     {

=== modified file 'src/core/media/service_implementation.h'
--- src/core/media/service_implementation.h	2015-03-16 15:38:27 +0000
+++ src/core/media/service_implementation.h	2015-03-16 15:38:27 +0000
@@ -30,12 +30,13 @@
 {
 class Player;
 
-class ServiceImplementation : public ServiceSkeleton
+class ServiceImplementation : public Service
 {
 public:
     // All creation time arguments go here.
     struct Configuration
     {
+        KeyedPlayerStore::Ptr player_store;
         helper::ExternalServices& external_services;
     };
 

=== modified file 'src/core/media/service_skeleton.cpp'
--- src/core/media/service_skeleton.cpp	2014-11-18 20:29:26 +0000
+++ src/core/media/service_skeleton.cpp	2015-03-16 15:38:27 +0000
@@ -19,8 +19,6 @@
 
 #include "service_skeleton.h"
 
-#include "apparmor.h"
-
 #include "mpris/media_player2.h"
 #include "mpris/metadata.h"
 #include "mpris/player.h"
@@ -51,12 +49,12 @@
 
 struct media::ServiceSkeleton::Private
 {
-    Private(media::ServiceSkeleton* impl, const media::CoverArtResolver& resolver)
+    Private(media::ServiceSkeleton* impl, const ServiceSkeleton::Configuration& config)
         : impl(impl),
           object(impl->access_service()->add_object_for_path(
-                     dbus::traits::Service<media::Service>::object_path())),
-          dbus_stub(impl->access_bus()),
-          exported(impl->access_bus(), resolver)
+                     dbus::traits::Service<media::Service>::object_path())),          
+          exported(impl->access_bus(), config.cover_art_resolver),
+          configuration(config)
     {
         object->install_method_handler<mpris::Service::CreateSession>(
                     std::bind(
@@ -99,129 +97,71 @@
         dbus::types::ObjectPath op{session_info.first};
         media::Player::PlayerKey key{session_info.second};
 
-        dbus_stub.get_connection_app_armor_security_async(msg->sender(), [this, msg, op, key](const std::string& profile)
-        {
-            media::Player::Configuration config
-            {
-                profile,
-                key,
-                impl->access_bus(),
-                impl->access_service()->add_object_for_path(op)
-            };
-
-            try
-            {
+        media::Player::Configuration config
+        {
+            key,
+            impl->access_bus(),
+            impl->access_service()->add_object_for_path(op)
+        };
+
+        try
+        {
+            configuration.player_store->add_player_for_key(key, impl->create_session(config));
+            auto reply = dbus::Message::make_method_return(msg);
+            reply->writer() << op;
+
+            impl->access_bus()->send(reply);
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::CreatingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply);
+        }
+    }
+
+    void handle_create_fixed_session(const core::dbus::Message::Ptr& msg)
+    {
+        try
+        {
+            std::string name;
+            msg->reader() >> name;
+
+            if (named_player_map.count(name) == 0) {
+                // Create new session
+                auto  session_info = create_session_info();
+
+                dbus::types::ObjectPath op{session_info.first};
+                media::Player::PlayerKey key{session_info.second};
+
+                media::Player::Configuration config
+                {
+                    key,
+                    impl->access_bus(),
+                    impl->access_service()->add_object_for_path(op)
+                };
+
                 auto session = impl->create_session(config);
-
-                bool inserted = false;
-                std::tie(std::ignore, inserted)
-                        = session_store.insert(std::make_pair(key, session));
-
-                if (!inserted)
-                    throw std::runtime_error("Problem persisting session in session store.");
-
+                session->lifetime().set(media::Player::Lifetime::resumable);
+
+                configuration.player_store->add_player_for_key(key, session);
+
+
+                named_player_map.insert(std::make_pair(name, key));
 
                 auto reply = dbus::Message::make_method_return(msg);
                 reply->writer() << op;
 
                 impl->access_bus()->send(reply);
-            } catch(const std::runtime_error& e)
-            {
-                auto reply = dbus::Message::make_error(
-                            msg,
-                            mpris::Service::Errors::CreatingSession::name(),
-                            e.what());
-                impl->access_bus()->send(reply);
-            }
-        });
-    }
-
-    void handle_create_fixed_session(const core::dbus::Message::Ptr& msg)
-    {
-        dbus_stub.get_connection_app_armor_security_async(msg->sender(), [this, msg](const std::string& profile)
-        {
-            try
-            {
-                std::string name;
-                msg->reader() >> name;
-
-                if (fixed_session_store.count(name) == 0) {
-                    // Create new session
-                    auto  session_info = create_session_info();
-
-                    dbus::types::ObjectPath op{session_info.first};
-                    media::Player::PlayerKey key{session_info.second};
-
-                    media::Player::Configuration config
-                    {
-                        profile,
-                        key,
-                        impl->access_bus(),
-                        impl->access_service()->add_object_for_path(op)
-                    };
-
-                    auto session = impl->create_session(config);
-                    session->lifetime().set(media::Player::Lifetime::resumable);
-
-                    bool inserted = false;
-                    std::tie(std::ignore, inserted)
-                            = session_store.insert(std::make_pair(key, session));
-
-                    if (!inserted)
-                        throw std::runtime_error("Problem persisting session in session store.");
-
-                    fixed_session_store.insert(std::make_pair(name, key));
-
-                    auto reply = dbus::Message::make_method_return(msg);
-                    reply->writer() << op;
-
-                    impl->access_bus()->send(reply);
-                }
-                else {
-                    // Resume previous session
-                    auto key = fixed_session_store[name];
-                    if (session_store.count(key) == 0) {
-                        auto reply = dbus::Message::make_error(
-                                    msg,
-                                    mpris::Service::Errors::CreatingFixedSession::name(),
-                                    "Unable to locate player session");
-                        impl->access_bus()->send(reply);
-                        return;
-                    }
-
-                    std::stringstream ss;
-                    ss << "/core/ubuntu/media/Service/sessions/" << key;
-                    dbus::types::ObjectPath op{ss.str()};
-
-                    auto reply = dbus::Message::make_method_return(msg);
-                    reply->writer() << op;
-
-                    impl->access_bus()->send(reply);
-                }
-            } catch(const std::runtime_error& e)
-            {
-                auto reply = dbus::Message::make_error(
-                            msg,
-                            mpris::Service::Errors::CreatingSession::name(),
-                            e.what());
-                impl->access_bus()->send(reply);
-            }
-        });
-    }
-
-    void handle_resume_session(const core::dbus::Message::Ptr& msg)
-    {
-        dbus_stub.get_connection_app_armor_security_async(msg->sender(), [this, msg](const std::string&)
-        {
-            try
-            {
-                Player::PlayerKey key;
-                msg->reader() >> key;
-
-                if (session_store.count(key) == 0) {
+            }
+            else {
+                // Resume previous session
+                auto key = named_player_map.at(name);
+                if (not configuration.player_store->has_player_for_key(key)) {
                     auto reply = dbus::Message::make_error(
                                 msg,
-                                mpris::Service::Errors::ResumingSession::name(),
+                                mpris::Service::Errors::CreatingFixedSession::name(),
                                 "Unable to locate player session");
                     impl->access_bus()->send(reply);
                     return;
@@ -235,15 +175,49 @@
                 reply->writer() << op;
 
                 impl->access_bus()->send(reply);
-            } catch(const std::runtime_error& e)
-            {
+            }
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::CreatingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply);
+        }
+    }
+
+    void handle_resume_session(const core::dbus::Message::Ptr& msg)
+    {
+        try
+        {
+            Player::PlayerKey key;
+            msg->reader() >> key;
+
+            if (not configuration.player_store->has_player_for_key(key)) {
                 auto reply = dbus::Message::make_error(
                             msg,
-                            mpris::Service::Errors::CreatingSession::name(),
-                            e.what());
+                            mpris::Service::Errors::ResumingSession::name(),
+                            "Unable to locate player session");
                 impl->access_bus()->send(reply);
+                return;
             }
-        });
+
+            std::stringstream ss;
+            ss << "/core/ubuntu/media/Service/sessions/" << key;
+            dbus::types::ObjectPath op{ss.str()};
+
+            auto reply = dbus::Message::make_method_return(msg);
+            reply->writer() << op;
+
+            impl->access_bus()->send(reply);
+        } catch(const std::runtime_error& e)
+        {
+            auto reply = dbus::Message::make_error(
+                        msg,
+                        mpris::Service::Errors::CreatingSession::name(),
+                        e.what());
+            impl->access_bus()->send(reply);
+        }
     }
 
     void handle_pause_other_sessions(const core::dbus::Message::Ptr& msg)
@@ -260,11 +234,10 @@
     media::ServiceSkeleton* impl;
     dbus::Object::Ptr object;
 
-    // We query the apparmor profile to obtain an identity for players.
-    org::freedesktop::dbus::DBus::Stub dbus_stub;
-    // We track all running player instances.
-    std::map<media::Player::PlayerKey, std::shared_ptr<media::Player>> session_store;
-    std::map<std::string, media::Player::PlayerKey> fixed_session_store;
+    // We remember all our creation time arguments.
+    ServiceSkeleton::Configuration configuration;
+    // We map named/fixed player instances to their respective keys.
+    std::map<std::string, media::Player::PlayerKey> named_player_map;
     // We expose the entire service as an MPRIS player.
     struct Exported
     {
@@ -498,7 +471,7 @@
         mpris::Player::Skeleton player;
         mpris::Playlists::Skeleton playlists;
 
-        // Helper to resolve (title, artist, album) tuples to cover art.
+        // The CoverArtResolver used by the exported player.
         media::CoverArtResolver cover_art_resolver;
         // The actual player instance.
         std::weak_ptr<media::Player> current_player;
@@ -533,9 +506,9 @@
     } exported;
 };
 
-media::ServiceSkeleton::ServiceSkeleton(const media::CoverArtResolver& resolver)
+media::ServiceSkeleton::ServiceSkeleton(const Configuration& configuration)
     : dbus::Skeleton<media::Service>(the_session_bus()),
-      d(new Private(this, resolver))
+      d(new Private(this, configuration))
 {
 }
 
@@ -543,46 +516,24 @@
 {
 }
 
-bool media::ServiceSkeleton::has_player_for_key(const media::Player::PlayerKey& key) const
-{
-    return d->session_store.count(key) > 0;
-}
-
-std::shared_ptr<media::Player> media::ServiceSkeleton::player_for_key(const media::Player::PlayerKey& key) const
-{
-    return d->session_store.at(key);
-}
-
-void media::ServiceSkeleton::enumerate_players(const media::ServiceSkeleton::PlayerEnumerator& enumerator) const
-{
-    for (const auto& pair : d->session_store)
-        enumerator(pair.first, pair.second);
-}
-
-void media::ServiceSkeleton::set_current_player_for_key(const media::Player::PlayerKey& key)
-{
-    if (not has_player_for_key(key))
-        return;
-
-    d->exported.set_current_player(player_for_key(key));
-}
-
-void media::ServiceSkeleton::remove_player_for_key(const media::Player::PlayerKey& key)
-{
-    if (not has_player_for_key(key))
-        return;
-
-    auto player = player_for_key(key);
-
-    d->session_store.erase(key);
-    d->exported.unset_if_current(player);
-    // All non-durable fixed sessions are also removed
-    for (auto it: d->fixed_session_store) {
-        if (it.second == key) {
-            d->fixed_session_store.erase(it.first);
-            break;
-        }
-    }
+std::shared_ptr<media::Player> media::ServiceSkeleton::create_session(const media::Player::Configuration& config)
+{
+    return d->configuration.impl->create_session(config);
+}
+
+std::shared_ptr<media::Player> media::ServiceSkeleton::create_fixed_session(const std::string& name, const media::Player::Configuration&config)
+{
+    return d->configuration.impl->create_fixed_session(name, config);
+}
+
+std::shared_ptr<media::Player> media::ServiceSkeleton::resume_session(media::Player::PlayerKey key)
+{
+    return d->configuration.impl->resume_session(key);
+}
+
+void media::ServiceSkeleton::pause_other_sessions(media::Player::PlayerKey key)
+{
+    d->configuration.impl->pause_other_sessions(key);
 }
 
 void media::ServiceSkeleton::run()

=== modified file 'src/core/media/service_skeleton.h'
--- src/core/media/service_skeleton.h	2014-09-09 21:27:29 +0000
+++ src/core/media/service_skeleton.h	2015-03-16 15:38:27 +0000
@@ -22,6 +22,7 @@
 #include <core/media/service.h>
 
 #include "cover_art_resolver.h"
+#include "keyed_player_store.h"
 #include "service_traits.h"
 
 #include <core/dbus/skeleton.h>
@@ -37,34 +38,22 @@
 class ServiceSkeleton : public core::dbus::Skeleton<core::ubuntu::media::Service>
 {
 public:
-    // Functor for enumerating all known (key, player) pairs.
-    typedef std::function
-    <
-        void(
-            // The key of the player.
-            const core::ubuntu::media::Player::PlayerKey&,
-            // The actual player instance.
-            const std::shared_ptr<core::ubuntu::media::Player>&
-        )
-    > PlayerEnumerator;
+    // Creation time arguments go here.
+    struct Configuration
+    {
+        std::shared_ptr<Service> impl;
+        KeyedPlayerStore::Ptr player_store;
+        CoverArtResolver cover_art_resolver;
+    };
 
-    ServiceSkeleton(const CoverArtResolver& cover_art_resolver = always_missing_cover_art_resolver());
+    ServiceSkeleton(const Configuration& configuration);
     ~ServiceSkeleton();
 
-    // We keep track of all known player sessions here and render them accessible via
-    // the key. All of these functions are thread-safe but not reentrant.
-    // Returns true iff a player is known for the given key.
-    bool has_player_for_key(const Player::PlayerKey& key) const;
-    // Returns the player for the given key or throws std::out_of_range if no player is known
-    // for the given key.
-    std::shared_ptr<Player> player_for_key(const Player::PlayerKey& key) const;
-    // Enumerates all known players and invokes the given enumerator for each
-    // (key, player) pair.
-    void enumerate_players(const PlayerEnumerator& enumerator) const;
-    // Removes the player for the given key, and unsets it if it is the current one.
-    void remove_player_for_key(const Player::PlayerKey& key);
-    // Makes the player known under the given key current.
-    void set_current_player_for_key(const Player::PlayerKey& key);
+    // From media::Service
+    std::shared_ptr<Player> create_session(const Player::Configuration&);
+    std::shared_ptr<Player> create_fixed_session(const std::string& name, const Player::Configuration&);
+    std::shared_ptr<Player> resume_session(Player::PlayerKey);
+    void pause_other_sessions(Player::PlayerKey key);
 
     void run();
     void stop();

=== 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	2015-01-12 21:35:36 +0000
+++ src/core/media/telephony/call_monitor.cpp	2015-03-16 15:38:27 +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;
     }
@@ -131,19 +135,19 @@
     {
         std::lock_guard<std::mutex> l(cb_lock);
         if (cb)
-            cb(CallMonitor::OffHook);
+            cb(media::telephony::CallMonitor::State::OffHook);
     }
 
     void onHook()
     {
         std::lock_guard<std::mutex> l(cb_lock);
         if (cb)
-            cb(CallMonitor::OnHook);
+            cb(media::telephony::CallMonitor::State::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;
 
@@ -159,63 +163,78 @@
         mCallMonitors.push_back(tcm);
     }
 };
-}
 
-class CallMonitorPrivate
+struct CallMonitor : public media::telephony::CallMonitor
 {
-public:
-    CallMonitorPrivate() {
-        mBridge = nullptr;
-        try {
-            std::thread([this]() {
-                qt::core::world::build_and_run(0, nullptr, [this]() {
-                    qt::core::world::enter_with_task([this]() {
+    CallMonitor() : mBridge{nullptr}
+    {
+        try
+        {
+            qt_world = std::move(std::thread([this]()
+            {
+                qt::core::world::build_and_run(0, nullptr, [this]()
+                {
+                    qt::core::world::enter_with_task([this]()
+                    {
                         std::cout << "CallMonitor: Creating TelepathyBridge" << std::endl;
                         mBridge = new TelepathyBridge();
                         cv.notify_all();
                     });
                 });
-            }).detach();
+          }));
         } catch(const std::system_error& error) {
             std::cerr << "exception(std::system_error) in CallMonitor thread start" << error.what() << std::endl;
         } catch(...) {
             std::cerr << "exception(...) in CallMonitor thread start" << std::endl;
         }
+
         // Wait until telepathy bridge is set, so we can hook up the change signals
         std::unique_lock<std::mutex> lck(mtx);
         cv.wait_for(lck, std::chrono::seconds(3));
+
+        if (mBridge)
+        {
+            mBridge->on_change([this](CallMonitor::State state)
+            {
+                call_state_changed(state);
+            });
+        }
     }
 
-    ~CallMonitorPrivate() {
+    ~CallMonitor()
+    {
+        // We first clean up the bridge instance.
+        qt::core::world::enter_with_task([this]()
+        {
+            delete mBridge;
+        }).get();
+
+        // We then request destruction of the qt world.
         qt::core::world::destroy();
+
+        // Before we finally join the worker.
+        if (qt_world.joinable())
+            qt_world.join();
+    }
+
+    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;
 
-private:
+    std::thread qt_world;
     std::mutex mtx;
     std::condition_variable cv;
 };
-
-
-CallMonitor::CallMonitor():
-    d(new CallMonitorPrivate)
-{
-}
-
-CallMonitor::~CallMonitor()
-{
-    delete d->mBridge;
-    delete d;
-}
-
-void CallMonitor::on_change(const std::function<void(CallMonitor::State)>& func)
-{
-    if (d->mBridge != nullptr) {
-        std::cout << "CallMonitor: Setting up callback for TelepathyBridge on_change" << std::endl;
-        d->mBridge->on_change(func);
-    } else
-        std::cerr << "TelepathyBridge: Failed to hook on_change signal, bridge not yet set" << std::endl;
+}
+}
+
+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	2015-03-16 15:38:27 +0000
@@ -17,25 +17,50 @@
  */
 
 
-#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
+{
+// CallMonitor models the ability to observe and react
+// to changes of the overall call state of the system.
+struct CallMonitor
+{
+    // Save us some typing.
+    typedef std::shared_ptr<CallMonitor> Ptr;
+
+    // All known call states
+    enum class State
+    {
+        // No current call.
+        OffHook,
+        // Call in progress.
+        OnHook
+    };
+
+    CallMonitor() = default;
+    virtual ~CallMonitor() = default;
+
+    // Emitted whenever the current call state of the system changes.
+    virtual const core::Signal<State>& on_call_state_changed() const = 0;
 };
 
-#endif // CALLMONITOR_H
+// Returns a platform default implementation of CallMonitor.
+CallMonitor::Ptr make_platform_default_call_monitor();
+}
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_TELEPHONY_CALL_MONITOR_H_