Merge lp:~justinmcp/media-hub/proxy-player into lp:media-hub

[Justin McPherson]

Support for external media players managed by media-hub.

[Jim Hodapp (jhodapp)]

See suggested changes inline

review: Needs Fixing (code)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:155
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~justinmcp/media-hub/proxy-player/+merge/268862/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/media-hub-ci/377/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/217/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/217/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/217/console

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

review: Needs Fixing (continuous-integration)

[lp:~justinmcp/media-hub/proxy-player]

156. By Justin McPherson on 2016-04-06

Merge from trunk.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:156
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~justinmcp/media-hub/proxy-player/+merge/268862/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/media-hub-ci/404/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-amd64-ci/244
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/244
        deb: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-armhf-ci/244/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/media-hub-vivid-i386-ci/244

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

review: Needs Fixing (continuous-integration)

[Jim Hodapp (jhodapp)]

Several comments inline below after doing a more thorough code review. Also, this MR needs syncing with the latest media-hub branch which includes the use of a new logging facility instead of using cout/cerr.

review: Needs Fixing (code)

[lp:~justinmcp/media-hub/proxy-player]

157. By Justin McPherson on 2016-05-25

Enable variant session type through the Player Configuration structure.

[Jim Hodapp (jhodapp)]

This is definitely what I had in mind and looks great. Thanks for doing it. A couple of minor comments inline below and then you just need to double check the client_death_cb related handling. Also, make sure to rebase this branch from trunk and convert to using the Logger instead of cout/cerr.

[lp:~justinmcp/media-hub/proxy-player]

158. By Justin McPherson on 2016-05-26

Remove unneeded dbus method definition

159. By Justin McPherson on 2016-05-26

Merge from trunk.

160. By Justin McPherson on 2016-05-26

- Use new logging functionality
- Fix en/decoding of PlayerType
- Return a default player type if type arg is unknown

[Jim Hodapp (jhodapp)]

Also I was curious how you've been testing this out? Does it already link to Oxide in some way?

[Justin McPherson (justinmcp)]

Sometime ago, this branch was working with https://code.launchpad.net/~justinmcp/oxide/media-arbitration.

[lp:~justinmcp/media-hub/proxy-player]

161. By Justin McPherson on 2016-05-27

Rename PlayerType enum values.

rigged -> standard
proxy -> proxied

162. By Justin McPherson on 2016-06-10

Renable test

163. By Justin McPherson on 2016-06-10

Changelog entry

[Jim Hodapp (jhodapp)]

You don't need an explicit changelog entry here. Going through the silo process will take the commit message from LP and add a changelog entry.

review: Needs Fixing

[lp:~justinmcp/media-hub/proxy-player]

164. By Justin McPherson on 2016-06-12

Remove entry

[Robert Bruce Park (robru)]

Please don't delete debian/changelog. Just revert all your changes to debian/changelog and then everything should work fine.

[lp:~justinmcp/media-hub/proxy-player]

165. By Justin McPherson on 2016-06-13

Fix changelog

[Justin McPherson (justinmcp)]

Before my morning coffee, apologies, the latter was meant, the former was done. Fixed...

[Jim Hodapp (jhodapp)]

LGTM

review: Approve (code)

[lp:~justinmcp/media-hub/proxy-player]

166. By Justin McPherson on 2016-06-14

Support for older compilers.

167. By Justin McPherson on 2016-06-19

Bump version number

168. By Justin McPherson on 2016-06-23

Update version is VERSION* files

169. By Justin McPherson on 2016-06-30

Merge from trunk.

170. By Justin McPherson on 2016-06-30

Fix build

171. By Justin McPherson on 2016-07-07

Merge from trunk.

172. By Justin McPherson on 2016-08-03

Merge from trunk.

Unmerged revisions

172. By Justin McPherson on 2016-08-03

Merge from trunk.

171. By Justin McPherson on 2016-07-07

Merge from trunk.

170. By Justin McPherson on 2016-06-30

Fix build

169. By Justin McPherson on 2016-06-30

Merge from trunk.

168. By Justin McPherson on 2016-06-23

Update version is VERSION* files

167. By Justin McPherson on 2016-06-19

Bump version number

166. By Justin McPherson on 2016-06-14

Support for older compilers.

165. By Justin McPherson on 2016-06-13

Fix changelog

164. By Justin McPherson on 2016-06-12

Remove entry

163. By Justin McPherson on 2016-06-10

Changelog entry

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-07-19 21:16:56 +0000
+++ CMakeLists.txt	2016-08-03 01:04:26 +0000
@@ -20,7 +20,7 @@
   # we define the version to be 5.0.0
   if (${DISTRO_CODENAME} STREQUAL "vivid")
     set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 4)
-    set(UBUNTU_MEDIA_HUB_VERSION_MINOR 5)
+    set(UBUNTU_MEDIA_HUB_VERSION_MINOR 6)
     set(UBUNTU_MEDIA_HUB_VERSION_PATCH 0)
   else ()
     set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 5)

=== modified file 'debian/VERSION'
--- debian/VERSION	2015-12-16 16:50:37 +0000
+++ debian/VERSION	2016-08-03 01:04:26 +0000
@@ -1,1 +1,1 @@
-5.0.0
\ No newline at end of file
+5.2.0

=== modified file 'debian/VERSION.vivid'
--- debian/VERSION.vivid	2015-12-16 16:50:37 +0000
+++ debian/VERSION.vivid	2016-08-03 01:04:26 +0000
@@ -1,1 +1,1 @@
-4.1.0
\ No newline at end of file
+4.6.0

=== modified file 'debian/changelog'
--- debian/changelog	2016-07-20 21:28:28 +0000
+++ debian/changelog	2016-08-03 01:04:26 +0000
@@ -1,3 +1,9 @@
+media-hub (4.6.0+16.10.20160720-0ubuntu1) yakkety; urgency=medium
+
+  * Add support for external players managed by media-hub.
+
+ -- Justin McPherson <[e-mail]>  Mon, 20 Jun 2016 08:58:18 +1000
+
 media-hub (4.5.0+16.10.20160720-0ubuntu1) yakkety; urgency=medium
 
   * Emit client side signal when the dbus connection between

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2016-06-01 00:43:04 +0000
+++ include/core/media/player.h	2016-08-03 01:04:26 +0000
@@ -75,6 +75,7 @@
         Client() = delete;
 
         static const Configuration& default_configuration();
+        static const Configuration& proxy_configuration();
     };
 
     enum PlaybackStatus
@@ -130,6 +131,12 @@
         service_missing_error
     };
 
+    enum PlayerType
+    {
+        standard,
+        proxied
+    };
+
     Player(const Player&) = delete;
     virtual ~Player();
 
@@ -142,6 +149,7 @@
 
     virtual std::shared_ptr<TrackList> track_list() = 0;
     virtual PlayerKey key() const = 0;
+    virtual PlayerType type() const = 0;
 
     virtual video::Sink::Ptr create_gl_texture_video_sink(std::uint32_t texture_id) = 0;
 

=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2016-06-15 17:49:49 +0000
+++ src/core/media/CMakeLists.txt	2016-08-03 01:04:26 +0000
@@ -121,6 +121,7 @@
 
     player_skeleton.cpp
     player_implementation.cpp
+    proxy_player_implementation.cpp
     service_skeleton.cpp
     service_implementation.cpp
     track_list_skeleton.cpp

=== modified file 'src/core/media/codec.h'
--- src/core/media/codec.h	2016-06-14 19:41:18 +0000
+++ src/core/media/codec.h	2016-08-03 01:04:26 +0000
@@ -235,6 +235,46 @@
 namespace helper
 {
 template<>
+struct TypeMapper<core::ubuntu::media::Player::PlayerType>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return core::dbus::ArgumentType::int16;
+    }
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+    constexpr static bool requires_signature()
+    {
+        return false;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = TypeMapper<std::int16_t>::signature();
+        return s;
+    }
+};
+}
+
+template<>
+struct Codec<core::ubuntu::media::Player::PlayerType>
+{
+    static void encode_argument(core::dbus::Message::Writer& out, const core::ubuntu::media::Player::PlayerType& in)
+    {
+        out.push_int16(static_cast<std::int16_t>(in));
+    }
+
+    static void decode_argument(core::dbus::Message::Reader& out, core::ubuntu::media::Player::PlayerType& in)
+    {
+        in = static_cast<core::ubuntu::media::Player::PlayerType>(out.pop_int16());
+    }
+};
+
+namespace helper
+{
+template<>
 struct TypeMapper<core::ubuntu::media::Player::AudioStreamRole>
 {
     constexpr static ArgumentType type_value()

=== modified file 'src/core/media/player.cpp'
--- src/core/media/player.cpp	2016-02-19 16:14:42 +0000
+++ src/core/media/player.cpp	2016-08-03 01:04:26 +0000
@@ -43,6 +43,19 @@
 {
     static const media::Player::Configuration config
     {
+        Player::standard,
+        0,
+        nullptr,
+        nullptr
+    };
+    return config;
+}
+
+const media::Player::Configuration& media::Player::Client::proxy_configuration()
+{
+    static const media::Player::Configuration config
+    {
+        Player::proxied,
         0,
         nullptr,
         nullptr

=== modified file 'src/core/media/player_configuration.h'
--- src/core/media/player_configuration.h	2016-04-20 14:42:41 +0000
+++ src/core/media/player_configuration.h	2016-08-03 01:04:26 +0000
@@ -28,6 +28,8 @@
 // to the implementation in a way that is opaque to the client.
 struct core::ubuntu::media::Player::Configuration
 {
+    // Type of player backing this session
+    core::ubuntu::media::Player::PlayerType type;
     // Unique key for identifying the session path.
     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	2016-07-11 01:21:38 +0000
+++ src/core/media/player_implementation.cpp	2016-08-03 01:04:26 +0000
@@ -844,6 +844,12 @@
 }
 
 template<typename Parent>
+media::Player::PlayerType media::PlayerImplementation<Parent>::type() const
+{
+    return Player::standard;
+}
+
+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);

=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2015-04-17 16:37:02 +0000
+++ src/core/media/player_implementation.h	2016-08-03 01:04:26 +0000
@@ -61,6 +61,7 @@
 
     virtual std::shared_ptr<TrackList> track_list();
     virtual Player::PlayerKey key() const;
+    virtual Player::PlayerType type() const;
 
     virtual video::Sink::Ptr create_gl_texture_video_sink(std::uint32_t texture_id);
 

=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2016-07-19 21:22:18 +0000
+++ src/core/media/player_stub.cpp	2016-08-03 01:04:26 +0000
@@ -48,11 +48,13 @@
     Private(const std::shared_ptr<Service>& parent,
             const std::shared_ptr<core::dbus::Service>& service,
             const std::shared_ptr<core::dbus::Object>& object,
-            const std::string& uuid
+            const std::string& uuid,
+            PlayerType type
             ) : parent(parent),
                 service(service),
                 object(object),
                 key(object->invoke_method_synchronously<mpris::Player::Key, media::Player::PlayerKey>().value()),
+                type(type),
                 uuid(uuid),
                 sink_factory(media::video::make_platform_default_sink_factory(key)),
                 properties
@@ -102,6 +104,7 @@
     dbus::Service::Ptr service;
     dbus::Object::Ptr object;
     media::Player::PlayerKey key;
+    media::Player::PlayerType type;
     std::string uuid;
     media::video::SinkFactory sink_factory;
     struct
@@ -234,8 +237,9 @@
     const std::shared_ptr<Service>& parent,
     const std::shared_ptr<core::dbus::Service>& service,
     const std::shared_ptr<core::dbus::Object>& object,
-    const std::string& uuid)
-        : d(new Private{parent, service, object, uuid})
+    const std::string& uuid,
+    media::Player::PlayerType type)
+        : d(new Private{parent, service, object, uuid, type})
 {
 }
 
@@ -278,6 +282,11 @@
     return d->key;
 }
 
+media::Player::PlayerType media::PlayerStub::type() const
+{
+    return d->type;
+}
+
 bool media::PlayerStub::open_uri(const media::Track::UriType& uri)
 {
     const auto op = d->object->transact_method<mpris::Player::OpenUri, bool>(uri);

=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2016-06-01 00:43:04 +0000
+++ src/core/media/player_stub.h	2016-08-03 01:04:26 +0000
@@ -41,7 +41,8 @@
         const std::shared_ptr<Service>& parent,
         const std::shared_ptr<core::dbus::Service>& service,
         const std::shared_ptr<core::dbus::Object>& object,
-        const std::string& uuid = std::string{});
+        const std::string& uuid = std::string{},
+        PlayerType type = PlayerType::standard);
 
     ~PlayerStub();
 
@@ -51,6 +52,7 @@
 
     virtual std::shared_ptr<TrackList> track_list();
     virtual PlayerKey key() const;
+    virtual PlayerType type() const;
 
     virtual video::Sink::Ptr create_gl_texture_video_sink(std::uint32_t texture_id);
 

=== added file 'src/core/media/proxy_player_implementation.cpp'
--- src/core/media/proxy_player_implementation.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/proxy_player_implementation.cpp	2016-08-03 01:04:26 +0000
@@ -0,0 +1,404 @@
+/*
+ * Copyright © 2016 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]>
+ *              Jim Hodapp <[e-mail]>
+ *              Justin McPherson <[e-mail]>
+ */
+
+#include "proxy_player_implementation.h"
+#include "util/timeout.h"
+
+#include <unistd.h>
+
+#include "client_death_observer.h"
+#include "track_list_implementation.h"
+
+#include "core/media/logger/logger.h"
+
+#include <memory>
+#include <exception>
+#include <iostream>
+#include <mutex>
+
+namespace media = core::ubuntu::media;
+namespace dbus = core::dbus;
+
+using namespace std;
+
+template<typename Parent>
+struct media::ProxyPlayerImplementation<Parent>::Private :
+        public std::enable_shared_from_this<Private>
+{
+    enum class wakelock_clear_t
+    {
+        WAKELOCK_CLEAR_INACTIVE,
+        WAKELOCK_CLEAR_DISPLAY,
+        WAKELOCK_CLEAR_SYSTEM,
+        WAKELOCK_CLEAR_INVALID
+    };
+
+    Private(ProxyPlayerImplementation* parent, const media::ProxyPlayerImplementation<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()),
+          system_wakelock_count(0),
+          display_wakelock_count(0),
+          previous_state(media::Player::stopped),
+          state(media::Player::null)
+    {
+        // Poor man's logging of release/acquire events.
+        display_state_lock->acquired().connect([](media::power::DisplayState state)
+        {
+            MH_INFO("Acquired new display state: %s", state);
+        });
+
+        display_state_lock->released().connect([](media::power::DisplayState state)
+        {
+            MH_INFO("Released display state: %s", state);
+        });
+
+        system_state_lock->acquired().connect([](media::power::SystemState state)
+        {
+            MH_INFO("Acquired new system state: %s", state);
+        });
+
+        system_state_lock->released().connect([](media::power::SystemState state)
+        {
+            MH_INFO("Released system state: %s", state);
+        });
+    }
+
+    ~Private()
+    {
+        // Make sure that we don't hold on to the wakelocks if media-hub-server
+        // ever gets restarted manually or automatically
+        clear_wakelocks();
+    }
+
+    void request_power_state()
+    {
+        MH_TRACE("");
+        try
+        {
+            if (parent->is_video_source())
+            {
+                if (++display_wakelock_count == 1)
+                {
+                    MH_INFO("Requesting new display wakelock.");
+                    display_state_lock->request_acquire(media::power::DisplayState::on);
+                    MH_INFO("Requested new display wakelock.");
+                }
+            }
+            else
+            {
+                if (++system_wakelock_count == 1)
+                {
+                    MH_INFO("Requesting new system wakelock.");
+                    system_state_lock->request_acquire(media::power::SystemState::active);
+                    MH_INFO("Requested new system wakelock.");
+                }
+            }
+        }
+        catch(const std::exception& e)
+        {
+            MH_WARNING("Failed to request power state: %s", e.what());
+        }
+    }
+
+    void clear_wakelock(const wakelock_clear_t &wakelock)
+    {
+        MH_TRACE("");
+        try
+        {
+            switch (wakelock)
+            {
+                case wakelock_clear_t::WAKELOCK_CLEAR_INACTIVE:
+                    break;
+                case wakelock_clear_t::WAKELOCK_CLEAR_SYSTEM:
+                    // Only actually clear the system wakelock once the count reaches zero
+                    if (--system_wakelock_count == 0)
+                    {
+                        MH_INFO("Clearing system wakelock.");
+                        system_state_lock->request_release(media::power::SystemState::active);
+                    }
+                    break;
+                case wakelock_clear_t::WAKELOCK_CLEAR_DISPLAY:
+                    // Only actually clear the display wakelock once the count reaches zero
+                    if (--display_wakelock_count == 0)
+                    {
+                        MH_INFO("Clearing display wakelock.");
+                        display_state_lock->request_release(media::power::DisplayState::on);
+                    }
+                    break;
+                case wakelock_clear_t::WAKELOCK_CLEAR_INVALID:
+                default:
+                    MH_WARNING("Can't clear invalid wakelock type");
+            }
+        }
+        catch(const std::exception& e)
+        {
+            MH_WARNING("Failed to request clear power state: %s", e.what());
+        }
+    }
+
+    wakelock_clear_t current_wakelock_type() const
+    {
+        return (parent->is_video_source()) ?
+            wakelock_clear_t::WAKELOCK_CLEAR_DISPLAY : wakelock_clear_t::WAKELOCK_CLEAR_SYSTEM;
+    }
+
+    void clear_wakelocks()
+    {
+        // Clear both types of wakelocks (display and system)
+        if (system_wakelock_count.load() > 0)
+        {
+            system_wakelock_count = 1;
+            clear_wakelock(wakelock_clear_t::WAKELOCK_CLEAR_SYSTEM);
+        }
+        if (display_wakelock_count.load() > 0)
+        {
+            display_wakelock_count = 1;
+            clear_wakelock(wakelock_clear_t::WAKELOCK_CLEAR_DISPLAY);
+        }
+    }
+
+    std::function<void()> make_clear_wakelock_functor()
+    {
+        // Since this functor will be executed on a separate detached thread
+        // 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{this->shared_from_this()};
+        auto wakelock_type = current_wakelock_type();
+        return [weak_self, wakelock_type] {
+            if (auto self = weak_self.lock())
+                self->clear_wakelock(wakelock_type);
+        };
+    }
+
+    void on_client_died()
+    {
+    }
+
+    void change_state(media::Player::PlaybackStatus state)
+    {
+        switch(state)
+        {
+        case media::Player::playing:
+        {
+            // And update our playback status.
+            parent->playback_status().set(media::Player::playing);
+
+            request_power_state();
+            break;
+        }
+        case media::Player::stopped:
+        {
+            parent->playback_status().set(media::Player::stopped);
+            if (previous_state == media::Player::playing)
+            {
+                timeout(4000, true, make_clear_wakelock_functor());
+            }
+            break;
+        }
+        case media::Player::paused:
+        {
+            parent->playback_status().set(media::Player::paused);
+            if (previous_state == media::Player::playing)
+            {
+                timeout(4000, true, make_clear_wakelock_functor());
+            }
+            break;
+        }
+        default:
+            break;
+        };
+
+        parent->emit_playback_status_changed(state);
+
+        // Keep track of the previous Engine playback state:
+        previous_state = state;
+    }
+
+    // Our link back to our parent.
+    media::ProxyPlayerImplementation<Parent>* parent;
+    // We just store the parameters passed on construction.
+    media::ProxyPlayerImplementation<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<media::TrackListImplementation> track_list;
+    std::atomic<int> system_wakelock_count;
+    std::atomic<int> display_wakelock_count;
+    media::Player::PlaybackStatus previous_state;
+    media::Player::PlaybackStatus state;
+    core::Signal<> on_client_disconnected;
+};
+
+template<typename Parent>
+media::ProxyPlayerImplementation<Parent>::ProxyPlayerImplementation(const media::ProxyPlayerImplementation<Parent>::Configuration& config)
+    : Parent{config.parent},
+      d{std::make_shared<Private>(this, config)}
+{
+    // Initialize default values for Player interface properties
+    Parent::can_play().set(true);
+    Parent::can_pause().set(true);
+    Parent::can_seek().set(true);
+    Parent::can_go_previous().set(false);
+    Parent::can_go_next().set(false);
+    Parent::is_video_source().set(true);
+    Parent::is_audio_source().set(false);
+    Parent::shuffle().set(false);
+    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);
+    Parent::orientation().set(Player::Orientation::rotate0);
+    Parent::lifetime().set(Player::Lifetime::normal);
+
+    // 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();
+            });
+        }
+    });
+}
+
+template<typename Parent>
+media::ProxyPlayerImplementation<Parent>::~ProxyPlayerImplementation()
+{
+}
+
+template<typename Parent>
+std::string media::ProxyPlayerImplementation<Parent>::uuid() const
+{
+    return std::string{};
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::reconnect()
+{
+    d->config.client_death_observer->register_for_death_notifications_with_key(d->config.key);
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::abandon()
+{
+    // Signal client disconnection due to abandonment of player
+    d->on_client_died();
+}
+
+template<typename Parent>
+std::shared_ptr<media::TrackList> media::ProxyPlayerImplementation<Parent>::track_list()
+{
+    return std::shared_ptr<media::TrackList>();
+}
+
+template<typename Parent>
+media::Player::PlayerKey media::ProxyPlayerImplementation<Parent>::key() const
+{
+    return d->config.key;
+}
+
+template<typename Parent>
+media::Player::PlayerType media::ProxyPlayerImplementation<Parent>::type() const
+{
+    return Player::proxied;
+}
+
+template<typename Parent>
+media::video::Sink::Ptr media::ProxyPlayerImplementation<Parent>::create_gl_texture_video_sink(std::uint32_t /*texture_id*/)
+{
+    return media::video::Sink::Ptr{};
+}
+
+template<typename Parent>
+bool media::ProxyPlayerImplementation<Parent>::open_uri(const Track::UriType& /*uri*/)
+{
+    return false;
+}
+
+template<typename Parent>
+bool media::ProxyPlayerImplementation<Parent>::open_uri(const Track::UriType& /*uri*/, const Player::HeadersType& /*headers*/)
+{
+    return false;
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::next()
+{
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::previous()
+{
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::play()
+{
+  d->change_state(media::Player::playing);
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::pause()
+{
+  d->change_state(media::Player::paused);
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::stop()
+{
+  d->change_state(media::Player::stopped);
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::seek_to(const std::chrono::microseconds& /*ms*/)
+{
+}
+
+template<typename Parent>
+const core::Signal<>& media::ProxyPlayerImplementation<Parent>::on_client_disconnected() const
+{
+    return d->on_client_disconnected;
+}
+
+template<typename Parent>
+void media::ProxyPlayerImplementation<Parent>::emit_playback_status_changed(const media::Player::PlaybackStatus &status)
+{
+    Parent::playback_status_changed()(status);
+}
+
+#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::ProxyPlayerImplementation<media::PlayerSkeleton>;

=== added file 'src/core/media/proxy_player_implementation.h'
--- src/core/media/proxy_player_implementation.h	1970-01-01 00:00:00 +0000
+++ src/core/media/proxy_player_implementation.h	2016-08-03 01:04:26 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2013-2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * 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: Justin McPherson <[e-mail]>
+ */
+
+#ifndef CORE_UBUNTU_MANAGED_MEDIA_PLAYER_IMPLEMENTATION_H_
+#define CORE_UBUNTU_MANAGED_MEDIA_PLAYER_IMPLEMENTATION_H_
+
+#include <core/media/player.h>
+
+#include "apparmor/ubuntu.h"
+#include "client_death_observer.h"
+#include "power/state_controller.h"
+
+#include <memory>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+class Engine;
+class Service;
+
+template<typename Parent>
+class ProxyPlayerImplementation : public Parent
+{
+public:
+    // All creation time arguments go here
+    struct Configuration
+    {
+        // 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;
+    };
+
+    ProxyPlayerImplementation(const Configuration& configuration);
+    ~ProxyPlayerImplementation();
+
+    virtual std::string uuid() const;
+    virtual void reconnect();
+    virtual void abandon();
+
+    virtual std::shared_ptr<TrackList> track_list();
+    virtual Player::PlayerKey key() const;
+    virtual Player::PlayerType type() const;
+
+    virtual video::Sink::Ptr create_gl_texture_video_sink(std::uint32_t texture_id);
+
+    virtual bool open_uri(const Track::UriType& uri);
+    virtual bool open_uri(const Track::UriType& uri, const Player::HeadersType& headers);
+    virtual void next();
+    virtual void previous();
+    virtual void play();
+    virtual void pause();
+    virtual void stop();
+    virtual void seek_to(const std::chrono::microseconds& offset);
+
+    const core::Signal<>& on_client_disconnected() const;
+
+protected:
+    void emit_playback_status_changed(const Player::PlaybackStatus &status);
+
+private:
+    struct Private;
+    std::shared_ptr<Private> d;
+};
+
+}
+}
+}
+#endif // CORE_UBUNTU_MANAGED_MEDIA_PLAYER_IMPLEMENTATION_H_

=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2016-07-19 21:22:18 +0000
+++ src/core/media/service_implementation.cpp	2016-08-03 01:04:26 +0000
@@ -28,6 +28,7 @@
 #include "player_configuration.h"
 #include "player_skeleton.h"
 #include "player_implementation.h"
+#include "proxy_player_implementation.h"
 #include "power/battery_observer.h"
 #include "power/state_controller.h"
 #include "recorder_observer.h"
@@ -180,12 +181,10 @@
 {
 }
 
-std::shared_ptr<media::Player> media::ServiceImplementation::create_session(
-        const media::Player::Configuration& conf)
+template<template <typename> class ImplementationType>
+std::shared_ptr<media::Player> media::ServiceImplementation::configure_player(const media::Player::Configuration& conf)
 {
-    // Create a new Player
-    auto player = std::make_shared<media::PlayerImplementation<media::PlayerSkeleton>>
-                    (media::PlayerImplementation<media::PlayerSkeleton>::Configuration
+    typename ImplementationType<media::PlayerSkeleton>::Configuration mixed_config
     {
         // Derive a PlayerSkeleton-specific Configuration based on Player::Configuration
         media::PlayerSkeleton::Configuration
@@ -200,7 +199,9 @@
         conf.key,
         d->client_death_observer,
         d->power_state_controller
-    });
+    };
+
+    auto player = std::make_shared<ImplementationType<media::PlayerSkeleton>>(mixed_config);
 
     auto key = conf.key;
     // *Note: on_client_disconnected() is called from a Binder thread context
@@ -233,6 +234,20 @@
     return player;
 }
 
+std::shared_ptr<media::Player> media::ServiceImplementation::create_session(
+        const media::Player::Configuration& conf)
+{
+    switch (conf.type) {
+    case media::Player::standard:
+        return configure_player<media::PlayerImplementation>(conf);
+    case media::Player::proxied:
+        return configure_player<media::ProxyPlayerImplementation>(conf);
+    }
+
+    MH_WARNING("Unrecognized player type - creating standard type");
+    return configure_player<media::PlayerImplementation>(conf);
+}
+
 void media::ServiceImplementation::detach_session(const std::string&, const media::Player::Configuration&)
 {
     // no impl

=== modified file 'src/core/media/service_implementation.h'
--- src/core/media/service_implementation.h	2016-07-14 19:36:51 +0000
+++ src/core/media/service_implementation.h	2016-08-03 01:04:26 +0000
@@ -59,6 +59,9 @@
     void resume_paused_multimedia_sessions(bool resume_video_sessions = true);
     void resume_multimedia_session();
 
+    template<template <typename> class ImplementationType>
+    std::shared_ptr<media::Player> configure_player(const Player::Configuration& conf);
+
     struct Private;
     std::shared_ptr<Private> d;
 };

=== modified file 'src/core/media/service_skeleton.cpp'
--- src/core/media/service_skeleton.cpp	2016-07-19 21:22:18 +0000
+++ src/core/media/service_skeleton.cpp	2016-08-03 01:04:26 +0000
@@ -123,8 +123,12 @@
         media::Player::PlayerKey key{std::get<1>(session_info)};
         std::string uuid{std::get<2>(session_info)};
 
+        media::Player::PlayerType type;
+        msg->reader() >> type;
+
         media::Player::Configuration config
         {
+            type,
             key,
             impl->access_bus(),
             impl->access_service(),
@@ -356,6 +360,7 @@
 
                 media::Player::Configuration config
                 {
+                    Player::standard,
                     key,
                     impl->access_bus(),
                     impl->access_service(),

=== modified file 'src/core/media/service_stub.cpp'
--- src/core/media/service_stub.cpp	2016-07-19 21:06:59 +0000
+++ src/core/media/service_stub.cpp	2016-08-03 01:04:26 +0000
@@ -19,7 +19,9 @@
 #include "service_stub.h"
 #include "service_traits.h"
 
+#include "codec.h"
 #include "player_stub.h"
+#include "player_configuration.h"
 #include "the_session_bus.h"
 
 #include "mpris/service.h"
@@ -75,10 +77,10 @@
         worker.join();
 }
 
-std::shared_ptr<media::Player> media::ServiceStub::create_session(const media::Player::Configuration&)
+std::shared_ptr<media::Player> media::ServiceStub::create_session(const media::Player::Configuration& config)
 {
-    const auto op = object->invoke_method_synchronously<mpris::Service::CreateSession,
-         std::tuple<dbus::types::ObjectPath, std::string>>();
+    const auto op = d->object->invoke_method_synchronously<mpris::Service::CreateSession,
+         std::tuple<dbus::types::ObjectPath, std::string>>(config.type);
 
     if (op.is_error())
         throw std::runtime_error("Problem creating session: " + op.error());
@@ -88,7 +90,8 @@
         shared_from_this(),
         access_service(),
         access_service()->object_for_path(std::get<0>(op.value())),
-        std::get<1>(op.value())
+        std::get<1>(op.value()),
+        config.type
     });
 }