Merge lp:~phablet-team/media-hub/media-hub-condensed into lp:media-hub

[Jim Hodapp]

* Merged with EOS branch from tvoss
* Added on_frame_available listener and callback
* Create a decoding session and pass it to the hybris layer
* Allow playback to work again after a client quits or dies
* Added two new properties to see if the opened media is video or audio
* Background playlist support

* Add powerd control interface

* One Engine instance per PlayerImplementation instance instead of one global Engine instance
* Pause other playing sessions when starting playback of a new foreground player
* Emit a PlaybackStatusChanged signal so that qtubuntu-media knows when PlaybackStatus changes from underneath it
* Use GST_SEEK_FLAG_KEY_UNIT instead because seeking doesn't perform well enough with GST_SEEK_FLAG_ACCURATE

* Merged with EOS branch from tvoss
* Added on_frame_available listener and callback
* Create a decoding session and pass it to the hybris layer
* Allow playback to work again after a client quits or dies
* Added two new properties to see if the opened media is video or audio
* Background playlist support

* Add powerd control interface

* One Engine instance per PlayerImplementation instance instead of one global Engine instance
* Pause other playing sessions when starting playback of a new foreground player
* Emit a PlaybackStatusChanged signal so that qtubuntu-media knows when PlaybackStatus changes from underneath it
* Use GST_SEEK_FLAG_KEY_UNIT instead because seeking doesn't perform well enough with GST_SEEK_FLAG_ACCURATE

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:30
http://jenkins.qa.ubuntu.com/job/media-hub-ci/59/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-trusty-amd64-ci/60/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-trusty-armhf-ci/59/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-trusty-i386-ci/59/console

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

review: Needs Fixing (continuous-integration)

[lp:~phablet-team/media-hub/media-hub-condensed]

31. By Jim Hodapp on 2014-04-30

Make sure media-hub respawns if it crashes

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:31
http://jenkins.qa.ubuntu.com/job/media-hub-ci/60/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-trusty-amd64-ci/61/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-trusty-armhf-ci/60/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-trusty-i386-ci/60/console

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-14 07:19:31 +0000
+++ CMakeLists.txt	2014-04-30 01:13:03 +0000
@@ -25,6 +25,8 @@
 pkg_check_modules(DBUS dbus-1 REQUIRED)
 pkg_check_modules(DBUS_CPP dbus-cpp REQUIRED)
 pkg_check_modules(PROPERTIES_CPP properties-cpp REQUIRED)
+pkg_check_modules(GIO gio-2.0 REQUIRED)
+pkg_check_modules(HYBRIS_MEDIA libmedia REQUIRED)
 
 #####################################################################
 # Enable code coverage calculation with gcov/gcovr/lcov

=== modified file 'debian/control'
--- debian/control	2014-03-26 20:18:20 +0000
+++ debian/control	2014-04-30 01:13:03 +0000
@@ -5,6 +5,7 @@
 Build-Depends: cmake,
                dbus-test-runner,
                debhelper (>= 9),
+               dh-apparmor,
                doxygen,
                gcc-4.7,
                g++-4.7,
@@ -39,6 +40,7 @@
 Depends: libmedia-hub-common0 (= ${binary:Version}),
          libmedia-hub-client0 (= ${binary:Version}),
          ${misc:Depends},
+         libproperties-cpp-dev,
 Suggests: libmedia-hub-doc
 Description: Simple and lightweight media playback service - development files
  Media Hub is a simple and lightweight service for media playback using
@@ -51,6 +53,7 @@
 Pre-Depends: dpkg (>= 1.15.6~)
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+Suggests: apparmor (>= 2.8.95~2430-0ubuntu4~)
 Description: Simple and lightweight media playback service
  Media Hub is a simple and lightweight service for media playback using
  DBus.

=== modified file 'debian/media-hub.conf'
--- debian/media-hub.conf	2014-03-07 14:38:28 +0000
+++ debian/media-hub.conf	2014-04-30 01:13:03 +0000
@@ -1,6 +1,9 @@
 description "Starts the media-hub service"
 
-start on dbus
+start on started dbus
 stop on runlevel [06]
 
+respawn
+respawn limit unlimited
+
 exec media-hub-server

=== modified file 'debian/media-hub.install'
--- debian/media-hub.install	2014-03-06 22:51:51 +0000
+++ debian/media-hub.install	2014-04-30 01:13:03 +0000
@@ -1,2 +1,3 @@
 debian/media-hub.conf /usr/share/upstart/sessions/
+debian/usr.bin.media-hub-server etc/apparmor.d
 usr/bin

=== modified file 'debian/rules'
--- debian/rules	2014-03-07 22:49:23 +0000
+++ debian/rules	2014-04-30 01:13:03 +0000
@@ -14,3 +14,7 @@
 
 override_dh_auto_test:
 	env -u LD_PRELOAD dh_auto_test
+
+override_dh_installdeb:
+	dh_apparmor --profile-name=usr.bin.media-hub-server -pmedia-hub
+	dh_installdeb

=== added file 'debian/usr.bin.media-hub-server'
--- debian/usr.bin.media-hub-server	1970-01-01 00:00:00 +0000
+++ debian/usr.bin.media-hub-server	2014-04-30 01:13:03 +0000
@@ -0,0 +1,98 @@
+#include <tunables/global>
+
+/usr/bin/media-hub-server (attach_disconnected) {
+  #include <abstractions/base>
+  #include <abstractions/audio>
+  #include <abstractions/nameservice>
+  #include <abstractions/dbus-session>
+  #include <abstractions/dbus-strict>
+  #include <abstractions/user-tmp>
+  #include "/usr/share/apparmor/hardware/audio.d"
+  #include "/usr/share/apparmor/hardware/graphics.d"
+  #include "/usr/share/apparmor/hardware/video.d"
+
+  deny /dev/cpuctl/apps/tasks w,
+  deny /dev/cpuctl/apps/bg_non_interactive/tasks w,
+
+  @{PROC}/interrupts r,
+  owner @{PROC}/cmdline r,
+  owner @{PROC}/[0-9]*/auxv r,
+  owner @{PROC}/[0-9]*/fd/ r,
+  owner @{PROC}/[0-9]*/status r,
+  owner @{PROC}/[0-9]*/task/ r,
+  owner @{PROC}/[0-9]*/task/[0-9]*/ r,
+  owner @{PROC}/[0-9]*/cmdline r,
+
+  /sys/kernel/debug/tracing/trace_marker w,
+  /dev/ashmem rw,
+
+  # Explicitly deny this-- it is not needed
+  /dev/fb0 rw,
+
+  # libhybris
+  /{,var/}run/shm/hybris_shm_data rw,
+  /usr/lib/@{multiarch}/libhybris/*.so mr,
+  /{,android/}system/build.prop r,
+  # These libraries can be in any of:
+  #  /vendor/lib
+  #  /system/lib
+  #  /system/vendor/lib
+  #  /android/vendor/lib
+  #  /android/system/lib
+  #  /android/system/vendor/lib
+  /{,android/}vendor/lib/**           r,
+  /{,android/}vendor/lib/**.so        m,
+  /{,android/}system/lib/**           r,
+  /{,android/}system/lib/**.so        m,
+  /{,android/}system/vendor/lib/**    r,
+  /{,android/}system/vendor/lib/**.so m,
+
+  # attach_disconnected path
+  /dev/socket/property_service rw,
+
+  # Android logging triggered by platform. Can safely deny
+  deny /dev/log_main w,
+  deny /dev/log_radio w,
+  deny /dev/log_events w,
+  deny /dev/log_system w,
+
+  # Allow all access to powerd for now, but we can fine-tune this if needed
+  dbus (receive, send)
+      bus=system
+      path=/com/canonical/powerd
+      interface=com.canonical.powerd,
+
+  # GStreamer binary registry - hybris pulls this in for everything now, not
+  # just audio
+  owner @{HOME}/.gstreamer*/registry.*.bin*       rw,
+  owner @{HOME}/.gstreamer*/                      rw,
+  owner @{HOME}/.cache/gstreamer*/registry.*.bin* rw,
+
+  /{,android/}system/etc/media_codecs.xml r,
+  /etc/wildmidi/wildmidi.cfg r,
+
+  audit deny owner /** m,
+
+  # Allow read on all directories
+  /**/ r,
+
+  # Allow read on click install directories, removable media and files in
+  # /usr/local/share.
+  /usr/share/** r,
+  /usr/local/share/** r,
+  /{media,mnt,opt,srv}/** r,
+
+  # Allow reading any files in non-hidden directories
+  owner @{HOME}/[^.]*    rk,
+  owner @{HOME}/[^.]*/   rk,
+  owner @{HOME}/[^.]*/** rk,
+
+  # Allow reading files in XDG directories (ie, where apps are allowed to
+  # write)
+  owner @{HOME}/.cache/**       rk,
+  owner @{HOME}/.local/share/** rk,
+  owner /{,var/}run/user/[0-9]*/** rk,
+
+  # Site-specific additions and overrides. See local/README for details.
+  #include <local/usr.bin.media-hub-server>
+}

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2014-02-18 19:27:01 +0000
+++ include/core/media/player.h	2014-04-30 01:13:03 +0000
@@ -39,6 +39,13 @@
   public:
     typedef double PlaybackRate;
     typedef double Volume;
+    typedef uint32_t PlayerKey;
+    typedef void* GLConsumerWrapperHybris;
+
+    /** Used to set a callback function to be called when a frame is ready to be rendered **/
+    typedef void (*FrameAvailableCbHybris)(GLConsumerWrapperHybris wrapper, void *context);
+    typedef void (*FrameAvailableCb)(void *context);
+    typedef void (*PlaybackCompleteCb)(void *context);
 
     struct Configuration;
 
@@ -72,8 +79,11 @@
     bool operator==(const Player&) const = delete;
 
     virtual std::shared_ptr<TrackList> track_list() = 0;
+    virtual PlayerKey key() const = 0;
 
     virtual bool open_uri(const Track::UriType& uri) = 0;
+    virtual void create_video_sink(uint32_t texture_id) = 0;
+    virtual GLConsumerWrapperHybris gl_consumer() const = 0;
     virtual void next() = 0;
     virtual void previous() = 0;
     virtual void play() = 0;
@@ -81,11 +91,17 @@
     virtual void stop() = 0;
     virtual void seek_to(const std::chrono::microseconds& offset) = 0;
 
+    // TODO: Convert this to be a signal
+    virtual void set_frame_available_callback(FrameAvailableCb cb, void *context) = 0;
+    virtual void set_playback_complete_callback(PlaybackCompleteCb cb, void *context) = 0;
+
     virtual const core::Property<bool>& can_play() const = 0;
     virtual const core::Property<bool>& can_pause() const = 0;
     virtual const core::Property<bool>& can_seek() const = 0;
     virtual const core::Property<bool>& can_go_previous() const = 0;
     virtual const core::Property<bool>& can_go_next() const = 0;
+    virtual const core::Property<bool>& is_video_source() const = 0;
+    virtual const core::Property<bool>& is_audio_source() const = 0;
     virtual const core::Property<PlaybackStatus>& playback_status() const = 0;
     virtual const core::Property<LoopStatus>& loop_status() const = 0;
     virtual const core::Property<PlaybackRate>& playback_rate() const = 0;
@@ -97,15 +113,14 @@
     virtual const core::Property<uint64_t>& position() const = 0;
     virtual const core::Property<uint64_t>& duration() const = 0;
 
-
     virtual core::Property<LoopStatus>& loop_status() = 0;
     virtual core::Property<PlaybackRate>& playback_rate() = 0;
     virtual core::Property<bool>& is_shuffle() = 0;
     virtual core::Property<Volume>& volume() = 0;
 
-
     virtual const core::Signal<uint64_t>& seeked_to() const = 0;
-
+    virtual const core::Signal<void>& end_of_stream() const = 0;
+    virtual core::Signal<PlaybackStatus>& playback_status_changed() = 0;
   protected:
     Player();
 

=== modified file 'include/core/media/service.h'
--- include/core/media/service.h	2014-01-13 21:51:14 +0000
+++ include/core/media/service.h	2014-04-30 01:13:03 +0000
@@ -43,6 +43,7 @@
     bool operator==(const Service&) const = delete;
 
     virtual std::shared_ptr<Player> create_session(const Player::Configuration&) = 0;
+    virtual void pause_other_sessions(Player::PlayerKey) = 0;
 
   protected:
     Service() = default;

=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2014-02-26 14:58:36 +0000
+++ src/core/media/CMakeLists.txt	2014-04-30 01:13:03 +0000
@@ -1,6 +1,6 @@
 pkg_check_modules(PC_GSTREAMER_1_0 REQUIRED gstreamer-1.0)
 
-include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS})
+include_directories(${PC_GSTREAMER_1_0_INCLUDE_DIRS} ${HYBRIS_MEDIA_CFLAGS})
 
 add_library(
   media-hub-common SHARED
@@ -52,6 +52,7 @@
   ${DBUS_LIBRARIES}
   ${DBUS_CPP_LDFLAGS}
   ${GLog_LIBRARY}
+  ${HYBRIS_MEDIA_LIBRARIES}
 )
 
 install(
@@ -82,9 +83,11 @@
   ${DBUS_CPP_LDFLAGS}
   ${GLog_LIBRARY}
   ${PC_GSTREAMER_1_0_LIBRARIES}
+  ${GIO_LIBRARIES}
+  ${HYBRIS_MEDIA_LIBRARIES}
 )
 
-include_directories(${PROJECT_SOURCE_DIR}/src/)
+include_directories(${PROJECT_SOURCE_DIR}/src/ ${HYBRIS_MEDIA_CFLAGS})
 
 add_executable(
   media-hub-server
@@ -102,6 +105,7 @@
   ${DBUS_CPP_LDFLAGS}
   ${GLog_LIBRARY}
   ${PC_GSTREAMER_1_0_LIBRARIES}
+  ${HYBRIS_MEDIA_LIBRARIES}
 )
 
 install(

=== added file 'src/core/media/apparmor.h'
--- src/core/media/apparmor.h	1970-01-01 00:00:00 +0000
+++ src/core/media/apparmor.h	2014-04-30 01:13:03 +0000
@@ -0,0 +1,51 @@
+/*
+ * 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_H_DBUS_
+#define APPARMOR_H_DBUS_
+
+#include <string>
+#include <chrono>
+
+namespace core
+{
+
+struct Apparmor
+{
+    static std::string& name()
+    {
+        static std::string s = "org.freedesktop.DBus";
+        return s;
+    }
+
+    struct getConnectionAppArmorSecurityContext
+    {
+        static std::string name()
+        {
+            static std::string s = "GetConnectionAppArmorSecurityContext";
+            return s;
+        }
+
+        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+
+        typedef Apparmor Interface;
+    };
+};
+}
+
+#endif

=== modified file 'src/core/media/engine.h'
--- src/core/media/engine.h	2014-02-18 19:27:01 +0000
+++ src/core/media/engine.h	2014-04-30 01:13:03 +0000
@@ -18,6 +18,7 @@
 #ifndef CORE_UBUNTU_MEDIA_ENGINE_H_
 #define CORE_UBUNTU_MEDIA_ENGINE_H_
 
+#include <core/media/player.h>
 #include <core/media/track.h>
 
 #include <core/property.h>
@@ -97,12 +98,16 @@
     virtual const core::Property<State>& state() const = 0;
 
     virtual bool open_resource_for_uri(const Track::UriType& uri) = 0;
+    virtual void create_video_sink(uint32_t texture_id) = 0;
 
     virtual bool play() = 0;
     virtual bool stop()  = 0;
     virtual bool pause() = 0;
     virtual bool seek_to(const std::chrono::microseconds& ts) = 0;
 
+    virtual const core::Property<bool>& is_video_source() const = 0;
+    virtual const core::Property<bool>& is_audio_source() const = 0;
+
     virtual const core::Property<uint64_t>& position() const = 0;
     virtual const core::Property<uint64_t>& duration() const = 0;
 
@@ -110,6 +115,11 @@
     virtual core::Property<Volume>& volume() = 0;
 
     virtual const core::Property<std::tuple<Track::UriType, Track::MetaData>>& track_meta_data() const = 0;
+
+    virtual const core::Signal<void>& about_to_finish_signal() const = 0;
+    virtual const core::Signal<uint64_t>& seeked_to_signal() const = 0;
+    virtual const core::Signal<void>& end_of_stream_signal() const = 0;
+    virtual const core::Signal<core::ubuntu::media::Player::PlaybackStatus>& playback_status_changed_signal() const = 0;
 };
 }
 }

=== modified file 'src/core/media/gstreamer/engine.cpp'
--- src/core/media/gstreamer/engine.cpp	2014-02-20 19:05:17 +0000
+++ src/core/media/gstreamer/engine.cpp	2014-04-30 01:13:03 +0000
@@ -16,6 +16,9 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include <stdio.h>
+#include <stdlib.h>
+
 #include "bus.h"
 #include "engine.h"
 #include "meta_data_extractor.h"
@@ -25,6 +28,8 @@
 
 namespace media = core::ubuntu::media;
 
+using namespace std;
+
 namespace gstreamer
 {
 struct Init
@@ -43,14 +48,10 @@
 
 struct gstreamer::Engine::Private
 {
-    void about_to_finish()
-    {
-        state = Engine::State::ready;
-    }
-
     void on_playbin_state_changed(
-            const gstreamer::Bus::Message::Detail::StateChanged&)
+            const gstreamer::Bus::Message::Detail::StateChanged& state_change)
     {
+        (void) state_change;
     }
 
     void on_tag_available(const gstreamer::Bus::Message::Detail::Tag& tag)
@@ -163,13 +164,31 @@
         playbin.set_volume(new_volume.value);
     }
 
+    void on_about_to_finish()
+    {
+        state = Engine::State::ready;
+        about_to_finish();
+    }
+
+    void on_seeked_to(uint64_t value)
+    {
+        seeked_to(value);
+    }
+
+    void on_end_of_stream()
+    {
+        end_of_stream();
+    }
+
     Private()
         : meta_data_extractor(new gstreamer::MetaDataExtractor()),
           volume(media::Engine::Volume(1.)),
+          is_video_source(false),
+          is_audio_source(false),
           about_to_finish_connection(
               playbin.signals.about_to_finish.connect(
                   std::bind(
-                      &Private::about_to_finish,
+                      &Private::on_about_to_finish,
                       this))),
           on_state_changed_connection(
               playbin.signals.on_state_changed.connect(
@@ -188,7 +207,18 @@
                   std::bind(
                       &Private::on_volume_changed,
                       this,
-                      std::placeholders::_1)))
+                      std::placeholders::_1))),
+          on_seeked_to_connection(
+              playbin.signals.on_seeked_to.connect(
+                  std::bind(
+                      &Private::on_seeked_to,
+                      this,
+                      std::placeholders::_1))),
+          on_end_of_stream_connection(
+              playbin.signals.on_end_of_stream.connect(
+                  std::bind(
+                      &Private::on_end_of_stream,
+                      this)))
     {
     }
 
@@ -198,15 +228,25 @@
     core::Property<uint64_t> position;
     core::Property<uint64_t> duration;
     core::Property<media::Engine::Volume> volume;
+    core::Property<bool> is_video_source;
+    core::Property<bool> is_audio_source;
     gstreamer::Playbin playbin;
     core::ScopedConnection about_to_finish_connection;
     core::ScopedConnection on_state_changed_connection;
     core::ScopedConnection on_tag_available_connection;
     core::ScopedConnection on_volume_changed_connection;
+    core::ScopedConnection on_seeked_to_connection;
+    core::ScopedConnection on_end_of_stream_connection;
+
+    core::Signal<void> about_to_finish;
+    core::Signal<uint64_t> seeked_to;
+    core::Signal<void> end_of_stream;
+    core::Signal<media::Player::PlaybackStatus> playback_status_changed;
 };
 
 gstreamer::Engine::Engine() : d(new Private{})
 {
+    cout << "Creating a new Engine instance in " << __PRETTY_FUNCTION__ << endl;
     d->state = media::Engine::State::ready;
 }
 
@@ -231,6 +271,11 @@
     return true;
 }
 
+void gstreamer::Engine::create_video_sink(uint32_t texture_id)
+{
+    d->playbin.create_video_sink(texture_id);
+}
+
 bool gstreamer::Engine::play()
 {
     auto result = d->playbin.set_state_and_wait(GST_STATE_PLAYING);
@@ -238,8 +283,11 @@
     if (result)
     {
         d->state = media::Engine::State::playing;
+        d->playback_status_changed(media::Player::PlaybackStatus::playing);
     }
 
+    cout << "Engine: " << this << endl;
+
     return result;
 }
 
@@ -248,7 +296,10 @@
     auto result = d->playbin.set_state_and_wait(GST_STATE_NULL);
 
     if (result)
+    {
         d->state = media::Engine::State::stopped;
+        d->playback_status_changed(media::Player::PlaybackStatus::stopped);
+    }
 
     return result;
 }
@@ -258,7 +309,11 @@
     auto result = d->playbin.set_state_and_wait(GST_STATE_PAUSED);
 
     if (result)
+    {
         d->state = media::Engine::State::paused;
+        cout << "pause" << endl;
+        d->playback_status_changed(media::Player::PlaybackStatus::paused);
+    }
 
     return result;
 }
@@ -268,6 +323,28 @@
     return d->playbin.seek(ts);
 }
 
+const core::Property<bool>& gstreamer::Engine::is_video_source() const
+{
+    gstreamer::Playbin::MediaFileType type = d->playbin.media_file_type();
+    if (type == gstreamer::Playbin::MediaFileType::MEDIA_FILE_TYPE_VIDEO)
+        d->is_video_source.set(true);
+    else
+        d->is_video_source.set(false);
+
+    return d->is_video_source;
+}
+
+const core::Property<bool>& gstreamer::Engine::is_audio_source() const
+{
+    gstreamer::Playbin::MediaFileType type = d->playbin.media_file_type();
+    if (type == gstreamer::Playbin::MediaFileType::MEDIA_FILE_TYPE_AUDIO)
+        d->is_audio_source.set(true);
+    else
+        d->is_audio_source.set(false);
+
+    return d->is_audio_source;
+}
+
 const core::Property<uint64_t>& gstreamer::Engine::position() const
 {
     d->position.set(d->playbin.position());
@@ -295,3 +372,23 @@
 {
     return d->track_meta_data;
 }
+
+const core::Signal<void>& gstreamer::Engine::about_to_finish_signal() const
+{
+    return d->about_to_finish;
+}
+
+const core::Signal<uint64_t>& gstreamer::Engine::seeked_to_signal() const
+{
+    return d->seeked_to;
+}
+
+const core::Signal<void>& gstreamer::Engine::end_of_stream_signal() const
+{
+    return d->end_of_stream;
+}
+
+const core::Signal<media::Player::PlaybackStatus>& gstreamer::Engine::playback_status_changed_signal() const
+{
+    return d->playback_status_changed;
+}

=== modified file 'src/core/media/gstreamer/engine.h'
--- src/core/media/gstreamer/engine.h	2014-02-18 19:27:01 +0000
+++ src/core/media/gstreamer/engine.h	2014-04-30 01:13:03 +0000
@@ -33,12 +33,16 @@
     const core::Property<State>& state() const;
 
     bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri);
+    void create_video_sink(uint32_t texture_id);
 
     bool play();
     bool stop();
     bool pause();
     bool seek_to(const std::chrono::microseconds& ts);
 
+    const core::Property<bool>& is_video_source() const;
+    const core::Property<bool>& is_audio_source() const;
+
     const core::Property<uint64_t>& position() const;
     const core::Property<uint64_t>& duration() const;
 
@@ -47,6 +51,11 @@
 
     const core::Property<std::tuple<core::ubuntu::media::Track::UriType, core::ubuntu::media::Track::MetaData>>& track_meta_data() const;
 
+    const core::Signal<void>& about_to_finish_signal() const;
+    const core::Signal<uint64_t>& seeked_to_signal() const;
+    const core::Signal<void>& end_of_stream_signal() const;
+    const core::Signal<core::ubuntu::media::Player::PlaybackStatus>& playback_status_changed_signal() const;
+
 private:
     struct Private;
     std::unique_ptr<Private> d;

=== modified file 'src/core/media/gstreamer/playbin.h'
--- src/core/media/gstreamer/playbin.h	2014-02-20 19:05:17 +0000
+++ src/core/media/gstreamer/playbin.h	2014-04-30 01:13:03 +0000
@@ -20,12 +20,19 @@
 #define GSTREAMER_PLAYBIN_H_
 
 #include "bus.h"
-
+#include "../mpris/player.h"
+
+#include <hybris/media/media_codec_layer.h>
+#include <hybris/media/surface_texture_client_hybris.h>
+
+#include <gio/gio.h>
 #include <gst/gst.h>
 
 #include <chrono>
 #include <string>
 
+namespace media = core::ubuntu::media;
+
 namespace gstreamer
 {
 struct Playbin
@@ -37,6 +44,13 @@
         GST_PLAY_FLAG_TEXT = (1 << 2)
     };
 
+    enum MediaFileType
+    {
+        MEDIA_FILE_TYPE_NONE,
+        MEDIA_FILE_TYPE_AUDIO,
+        MEDIA_FILE_TYPE_VIDEO
+    };
+
     static const std::string& pipeline_name()
     {
         static const std::string s{"playbin"};
@@ -45,20 +59,22 @@
 
     static void about_to_finish(GstElement*,
                                 gpointer user_data)
-    {        auto thiz = static_cast<Playbin*>(user_data);
-
+    {
+        auto thiz = static_cast<Playbin*>(user_data);
         thiz->signals.about_to_finish();
     }
 
     Playbin()
         : pipeline(gst_element_factory_make("playbin", pipeline_name().c_str())),
           bus{gst_element_get_bus(pipeline)},
+          file_type(MEDIA_FILE_TYPE_NONE),
           on_new_message_connection(
               bus.on_new_message.connect(
                   std::bind(
                       &Playbin::on_new_message,
                       this,
-                      std::placeholders::_1)))
+                      std::placeholders::_1))),
+          is_seeking(false)
     {
         if (!pipeline)
             throw std::runtime_error("Could not create pipeline for playbin.");
@@ -74,6 +90,8 @@
                     this
                     );
 
+        // When a client of media-hub dies, call on_client_died
+        decoding_service_set_client_death_cb(&Playbin::on_client_died_cb, static_cast<void*>(this));
     }
 
     ~Playbin()
@@ -82,6 +100,43 @@
             gst_object_unref(pipeline);
     }
 
+    static void on_client_died_cb(void *context)
+    {
+        if (context)
+        {
+            Playbin *pb = static_cast<Playbin*>(context);
+            pb->on_client_died();
+        }
+    }
+
+    void on_client_died()
+    {
+        std::cout << "Client died, resetting pipeline" << std::endl;
+        // When the client dies, tear down the current pipeline and get it
+        // in a state that is ready for the next client that connects to the
+        // service
+        reset_pipeline();
+    }
+
+    void reset_pipeline()
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        auto ret = gst_element_set_state(pipeline, GST_STATE_NULL);
+        switch(ret)
+        {
+        case GST_STATE_CHANGE_FAILURE:
+            std::cout << "Failed to reset the pipeline state. Client reconnect may not function properly." << std::endl;
+            break;
+        case GST_STATE_CHANGE_NO_PREROLL:
+        case GST_STATE_CHANGE_SUCCESS:
+        case GST_STATE_CHANGE_ASYNC:
+            break;
+        default:
+            std::cout << "Failed to reset the pipeline state. Client reconnect may not function properly." << std::endl;
+        }
+        file_type = MEDIA_FILE_TYPE_NONE;
+    }
+
     void on_new_message(const Bus::Message& message)
     {
         switch(message.type)
@@ -101,6 +156,16 @@
         case GST_MESSAGE_STATE_CHANGED:
             signals.on_state_changed(message.detail.state_changed);
             break;
+        case GST_MESSAGE_ASYNC_DONE:
+            if (is_seeking)
+            {
+                // FIXME: Pass the actual playback time position to the signal call
+                signals.on_seeked_to(0);
+                is_seeking = false;
+            }
+            break;
+        case GST_MESSAGE_EOS:
+            signals.on_end_of_stream();
         default:
             break;
         }
@@ -126,6 +191,8 @@
                         ::getenv("CORE_UBUNTU_MEDIA_SERVICE_AUDIO_SINK_NAME"),
                         "audio-sink");
 
+            std::cout << "audio_sink: " << ::getenv("CORE_UBUNTU_MEDIA_SERVICE_AUDIO_SINK_NAME") << std::endl;
+
             g_object_set (
                         pipeline,
                         "audio-sink",
@@ -136,26 +203,41 @@
         if (::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME") != nullptr)
         {
             auto video_sink = gst_element_factory_make (
-                        ::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME"),
-                        "video-sink");
+                    ::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME"),
+                    "video-sink");
 
             std::cout << "video_sink: " << ::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME") << std::endl;
 
             g_object_set (
-                        pipeline,
-                        "video-sink",
-                        video_sink,
-                        NULL);
+                    pipeline,
+                    "video-sink",
+                    video_sink,
+                    NULL);
+        }
+    }
+
+    void create_video_sink(uint32_t texture_id)
+    {
+        std::cout << "Creating video sink for texture_id: " << texture_id << std::endl;
+
+        if (::getenv("CORE_UBUNTU_MEDIA_SERVICE_VIDEO_SINK_NAME") != nullptr)
+        {
+            GstElement *video_sink = NULL;
+            g_object_get (pipeline, "video_sink", &video_sink, NULL);
+
+            // Get the service-side BufferQueue (IGraphicBufferProducer) and associate it with
+            // the SurfaceTextureClientHybris instance
+            IGBPWrapperHybris igbp = decoding_service_get_igraphicbufferproducer();
+            SurfaceTextureClientHybris stc = surface_texture_client_create_by_igbp(igbp);
+            // Because mirsink is being loaded, we are definitely doing * hardware rendering.
+            surface_texture_client_set_hardware_rendering (stc, TRUE);
+            g_object_set (G_OBJECT (video_sink), "surface", static_cast<gpointer>(stc), static_cast<char*>(NULL));
         }
     }
 
     void set_volume(double new_volume)
     {
-        g_object_set(
-                    pipeline,
-                    "volume",
-                    new_volume,
-                    NULL);
+        g_object_set(pipeline, "volume", new_volume, NULL);
     }
 
     uint64_t position() const
@@ -178,11 +260,11 @@
 
     void set_uri(const std::string& uri)
     {
-        g_object_set(
-                    pipeline,
-                    "uri",
-                    uri.c_str(),
-                    NULL);
+        g_object_set(pipeline, "uri", uri.c_str(), NULL);
+        if (is_video_file(uri))
+            file_type = MEDIA_FILE_TYPE_VIDEO;
+        else if (is_audio_file(uri))
+            file_type = MEDIA_FILE_TYPE_AUDIO;
     }
 
     std::string uri() const
@@ -229,6 +311,7 @@
 
     bool seek(const std::chrono::microseconds& ms)
     {
+        is_seeking = true;
         return gst_element_seek_simple(
                     pipeline,
                     GST_FORMAT_TIME,
@@ -236,9 +319,87 @@
                     ms.count() * 1000);
     }
 
+    std::string get_file_content_type(const std::string& uri) const
+    {
+        if (uri.empty())
+            return std::string();
+
+        std::string filename(uri);
+        std::cout << "filename: " << filename << std::endl;
+        size_t pos = uri.find("file://");
+        if (pos != std::string::npos)
+            filename = uri.substr(pos + 7, std::string::npos);
+        else
+            // Anything other than a file, for now claim that the type
+            // is both audio and video.
+            // FIXME: implement true net stream sampling and get the type from GstCaps
+            return std::string("audio/video/");
+
+
+        GError *error = nullptr;
+        std::unique_ptr<GFile, void(*)(void *)> file(
+                g_file_new_for_path(filename.c_str()), g_object_unref);
+        std::unique_ptr<GFileInfo, void(*)(void *)> info(
+                g_file_query_info(
+                    file.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE ","
+                    G_FILE_ATTRIBUTE_ETAG_VALUE, G_FILE_QUERY_INFO_NONE,
+                    /* cancellable */ NULL, &error),
+                g_object_unref);
+        if (!info)
+        {
+            std::string error_str(error->message);
+            g_error_free(error);
+
+            std::cout << "Failed to query the URI for the presence of video content: "
+                << error_str << std::endl;
+            return std::string();
+        }
+
+        std::string content_type(g_file_info_get_attribute_string(
+                    info.get(), G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE));
+
+        return content_type;
+    }
+
+    bool is_audio_file(const std::string& uri) const
+    {
+        if (uri.empty())
+            return false;
+
+        if (get_file_content_type(uri).find("audio/") == 0)
+        {
+            std::cout << "Found audio content" << std::endl;
+            return true;
+        }
+
+        return false;
+    }
+
+    bool is_video_file(const std::string& uri) const
+    {
+        if (uri.empty())
+            return false;
+
+        if (get_file_content_type(uri).find("video/") == 0)
+        {
+            std::cout << "Found video content" << std::endl;
+            return true;
+        }
+
+        return false;
+    }
+
+    MediaFileType media_file_type() const
+    {
+        return file_type;
+    }
+
     GstElement* pipeline;
     gstreamer::Bus bus;
+    MediaFileType file_type;
+    SurfaceTextureClientHybris stc_hybris;
     core::Connection on_new_message_connection;
+    bool is_seeking;
     struct
     {
         core::Signal<void> about_to_finish;
@@ -247,6 +408,9 @@
         core::Signal<Bus::Message::Detail::ErrorWarningInfo> on_info;
         core::Signal<Bus::Message::Detail::Tag> on_tag_available;
         core::Signal<Bus::Message::Detail::StateChanged> on_state_changed;
+        core::Signal<uint64_t> on_seeked_to;
+        core::Signal<void> on_end_of_stream;
+        core::Signal<media::Player::PlaybackStatus> on_playback_status_changed;
     } signals;
 };
 }

=== modified file 'src/core/media/mpris/player.h'
--- src/core/media/mpris/player.h	2014-02-18 19:27:01 +0000
+++ src/core/media/mpris/player.h	2014-04-30 01:13:03 +0000
@@ -54,11 +54,15 @@
     METHOD(Play, Player, std::chrono::seconds(1))
     METHOD(Seek, Player, std::chrono::seconds(1))
     METHOD(SetPosition, Player, std::chrono::seconds(1))
+    METHOD(CreateVideoSink, Player, std::chrono::seconds(1))
+    METHOD(Key, Player, std::chrono::seconds(1))
     METHOD(OpenUri, Player, std::chrono::seconds(1))
 
     struct Signals
     {
         SIGNAL(Seeked, Player, uint64_t)
+        SIGNAL(EndOfStream, Player, void)
+        SIGNAL(PlaybackStatusChanged, Player, core::ubuntu::media::Player::PlaybackStatus)
     };
 
     struct Properties
@@ -74,6 +78,8 @@
         READABLE_PROPERTY(Duration, Player, uint64_t)
         READABLE_PROPERTY(MinimumRate, Player, double)
         READABLE_PROPERTY(MaximumRate, Player, double)
+        READABLE_PROPERTY(IsVideoSource, Player, bool)
+        READABLE_PROPERTY(IsAudioSource, Player, bool)
         READABLE_PROPERTY(CanGoNext, Player, bool)
         READABLE_PROPERTY(CanGoPrevious, Player, bool)
         READABLE_PROPERTY(CanPlay, Player, bool)

=== modified file 'src/core/media/mpris/service.h'
--- src/core/media/mpris/service.h	2014-01-13 21:51:14 +0000
+++ src/core/media/mpris/service.h	2014-04-30 01:13:03 +0000
@@ -50,6 +50,7 @@
     };
 
     METHOD(CreateSession, Service, std::chrono::seconds(1))
+    METHOD(PauseOtherSessions, Service, std::chrono::seconds(1))
 };
 }
 

=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2014-02-18 20:25:21 +0000
+++ src/core/media/player_implementation.cpp	2014-04-30 01:13:03 +0000
@@ -17,39 +17,125 @@
 
 #include "player_implementation.h"
 
+#include <unistd.h>
+
 #include "engine.h"
 #include "track_list_implementation.h"
 
+#include "powerd_service.h"
+#include "gstreamer/engine.h"
+
+#define UNUSED __attribute__((unused))
+
 namespace media = core::ubuntu::media;
+namespace dbus = core::dbus;
+
+using namespace std;
 
 struct media::PlayerImplementation::Private
 {
     Private(PlayerImplementation* parent,
             const dbus::types::ObjectPath& session_path,
             const std::shared_ptr<media::Service>& service,
-            const std::shared_ptr<media::Engine>& engine)
+            PlayerImplementation::PlayerKey key)
         : parent(parent),
           service(service),
-          engine(engine),
+          engine(std::make_shared<gstreamer::Engine>()),
           session_path(session_path),
           track_list(
               new media::TrackListImplementation(
                   session_path.as_string() + "/TrackList",
-                  engine->meta_data_extractor()))
+                  engine->meta_data_extractor())),
+          disp_lock_name("media-hub-video-playback"),
+          sys_lock_name("media-hub-music-playback"),
+          key(key)
     {
+        auto bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::system));
+        bus->install_executor(dbus::asio::make_executor(bus));
+
+        auto stub_service = dbus::Service::use_service(bus, dbus::traits::Service<core::Powerd>::interface_name());
+        powerd_session = stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/powerd"));
+
         engine->state().changed().connect(
-                    [parent](const Engine::State& state)
-                    {
+                    [parent, this](const Engine::State& state)
+        {
             switch(state)
             {
-            case Engine::State::ready: parent->playback_status().set(media::Player::ready); break;
-            case Engine::State::playing: parent->playback_status().set(media::Player::playing); break;
-            case Engine::State::stopped: parent->playback_status().set(media::Player::stopped); break;
-            case Engine::State::paused: parent->playback_status().set(media::Player::paused); break;
+            case Engine::State::ready:
+            {
+                parent->playback_status().set(media::Player::ready);
+                clear_power_state();
+                break;
+            }
+            case Engine::State::playing:
+            {
+                parent->playback_status().set(media::Player::playing);
+                request_power_state();
+                break;
+            }
+            case Engine::State::stopped:
+            {
+                parent->playback_status().set(media::Player::stopped);
+                clear_power_state();
+                break;
+            }
+            case Engine::State::paused:
+            {
+                parent->playback_status().set(media::Player::paused);
+                clear_power_state();
+                break;
+            }
             default:
                 break;
             };
-                    });
+        });
+
+    }
+
+    void request_power_state()
+    {
+        if (parent->is_video_source())
+        {
+            if (disp_cookie.empty())
+            {
+                auto result = powerd_session->invoke_method_synchronously<core::Powerd::requestDisplayState, std::string>(disp_lock_name, static_cast<int>(1), static_cast<unsigned int>(4));
+                if (result.is_error())
+                    throw std::runtime_error(result.error().print());
+
+                disp_cookie = result.value();
+            }
+        }
+        else
+        {
+            if (sys_cookie.empty())
+            {
+                auto result = powerd_session->invoke_method_synchronously<core::Powerd::requestSysState, std::string>(sys_lock_name, static_cast<int>(1));
+                if (result.is_error())
+                    throw std::runtime_error(result.error().print());
+
+                sys_cookie = result.value();
+            }
+        }
+    }
+
+    void clear_power_state()
+    {
+        if (parent->is_video_source())
+        {
+            if (!disp_cookie.empty())
+            {
+                powerd_session->invoke_method_synchronously<core::Powerd::clearDisplayState, void>(disp_cookie);
+                disp_cookie.clear();
+            }
+        }
+        else
+        {
+            if (!sys_cookie.empty())
+            {
+                powerd_session->invoke_method_synchronously<core::Powerd::clearSysState, void>(sys_cookie);
+                sys_cookie.clear();
+            }
+        }
     }
 
     PlayerImplementation* parent;
@@ -57,18 +143,24 @@
     std::shared_ptr<Engine> engine;
     dbus::types::ObjectPath session_path;
     std::shared_ptr<TrackListImplementation> track_list;
+    std::shared_ptr<dbus::Object> powerd_session;
+    std::string disp_lock_name;
+    std::string sys_lock_name;
+    std::string disp_cookie;
+    std::string sys_cookie;
+    PlayerImplementation::PlayerKey key;
 };
 
 media::PlayerImplementation::PlayerImplementation(
         const dbus::types::ObjectPath& session_path,
         const std::shared_ptr<Service>& service,
-        const std::shared_ptr<Engine>& engine)
+        PlayerKey key)
     : media::PlayerSkeleton(session_path),
       d(new Private(
             this,
             session_path,
             service,
-            engine))
+            key))
 {
     // Initializing default values for properties
     can_play().set(true);
@@ -76,6 +168,8 @@
     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);
@@ -98,6 +192,43 @@
         return d->engine->duration().get();
     };
     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);
+
+    std::function<bool()> audio_type_getter = [this]()
+    {
+        return d->engine->is_audio_source().get();
+    };
+    is_audio_source().install(audio_type_getter);
+
+    d->engine->about_to_finish_signal().connect([this]()
+    {
+        if (d->track_list->has_next())
+        {
+            Track::UriType uri = d->track_list->query_uri_for_track(d->track_list->next());
+            if (!uri.empty())
+                d->parent->open_uri(uri);
+        }
+    });
+
+    d->engine->seeked_to_signal().connect([this](uint64_t value)
+    {
+        seeked_to()(value);
+    });
+
+    d->engine->end_of_stream_signal().connect([this]()
+    {
+        end_of_stream()();
+    });
+
+    d->engine->playback_status_changed_signal().connect([this](const Player::PlaybackStatus& status)
+    {
+        playback_status_changed()(status);
+    });
 }
 
 media::PlayerImplementation::~PlayerImplementation()
@@ -109,11 +240,28 @@
     return d->track_list;
 }
 
+// TODO: Convert this to be a property instead of sync call
+media::Player::PlayerKey media::PlayerImplementation::key() const
+{
+    return d->key;
+}
+
 bool media::PlayerImplementation::open_uri(const Track::UriType& uri)
 {
     return d->engine->open_resource_for_uri(uri);
 }
 
+void media::PlayerImplementation::create_video_sink(uint32_t texture_id)
+{
+    d->engine->create_video_sink(texture_id);
+}
+
+media::Player::GLConsumerWrapperHybris media::PlayerImplementation::gl_consumer() const
+{
+    // This method is client-side only and is simply a no-op for the service side
+    return NULL;
+}
+
 void media::PlayerImplementation::next()
 {
 }
@@ -124,11 +272,6 @@
 
 void media::PlayerImplementation::play()
 {
-    /*if (playback_status() == media::Player::null)
-    {
-        if (d->track_list->has_next())
-            if (open_uri(d->track_list->next()->))
-    }*/
     d->engine->play();
 }
 
@@ -142,6 +285,18 @@
     d->engine->stop();
 }
 
+void media::PlayerImplementation::set_frame_available_callback(
+    UNUSED FrameAvailableCb cb, UNUSED void *context)
+{
+    // This method is client-side only and is simply a no-op for the service side
+}
+
+void media::PlayerImplementation::set_playback_complete_callback(
+    UNUSED PlaybackCompleteCb cb, UNUSED void *context)
+{
+    // This method is client-side only and is simply a no-op for the service side
+}
+
 void media::PlayerImplementation::seek_to(const std::chrono::microseconds& ms)
 {
     d->engine->seek_to(ms);

=== modified file 'src/core/media/player_implementation.h'
--- src/core/media/player_implementation.h	2014-02-18 20:25:21 +0000
+++ src/core/media/player_implementation.h	2014-04-30 01:13:03 +0000
@@ -1,4 +1,5 @@
 /*
+ * Copyright © 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,
@@ -37,17 +38,22 @@
     PlayerImplementation(
             const core::dbus::types::ObjectPath& session_path,
             const std::shared_ptr<Service>& service,
-            const std::shared_ptr<Engine>& engine);
+            PlayerKey key);
     ~PlayerImplementation();
 
     virtual std::shared_ptr<TrackList> track_list();
+    virtual PlayerKey key() const;
 
     virtual bool open_uri(const Track::UriType& uri);
+    virtual void create_video_sink(uint32_t texture_id);
+    virtual GLConsumerWrapperHybris gl_consumer() const;
     virtual void next();
     virtual void previous();
     virtual void play();
     virtual void pause();
     virtual void stop();
+    virtual void set_frame_available_callback(FrameAvailableCb cb, void *context);
+    virtual void set_playback_complete_callback(PlaybackCompleteCb cb, void *context);
     virtual void seek_to(const std::chrono::microseconds& offset);
 
 private:

=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2014-02-20 19:05:17 +0000
+++ src/core/media/player_skeleton.cpp	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,
@@ -16,6 +16,7 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include "apparmor.h"
 #include "codec.h"
 #include "player_skeleton.h"
 #include "player_traits.h"
@@ -27,6 +28,7 @@
 #include <core/dbus/object.h>
 #include <core/dbus/property.h>
 #include <core/dbus/stub.h>
+#include <core/dbus/asio/executor.h>
 
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
@@ -36,6 +38,7 @@
     Private(media::PlayerSkeleton* player, const dbus::types::ObjectPath& session)
         : impl(player),
           object(impl->access_service()->add_object_for_path(session)),
+          apparmor_session(nullptr),
           properties
           {
               object->get_property<mpris::Player::Properties::CanPlay>(),
@@ -44,6 +47,8 @@
               object->get_property<mpris::Player::Properties::CanControl>(),
               object->get_property<mpris::Player::Properties::CanGoNext>(),
               object->get_property<mpris::Player::Properties::CanGoPrevious>(),
+              object->get_property<mpris::Player::Properties::IsVideoSource>(),
+              object->get_property<mpris::Player::Properties::IsAudioSource>(),
               object->get_property<mpris::Player::Properties::PlaybackStatus>(),
               object->get_property<mpris::Player::Properties::LoopStatus>(),
               object->get_property<mpris::Player::Properties::PlaybackRate>(),
@@ -54,6 +59,12 @@
               object->get_property<mpris::Player::Properties::Duration>(),
               object->get_property<mpris::Player::Properties::MinimumRate>(),
               object->get_property<mpris::Player::Properties::MaximumRate>()
+          },
+          signals
+          {
+              object->get_signal<mpris::Player::Signals::Seeked>(),
+              object->get_signal<mpris::Player::Signals::EndOfStream>(),
+              object->get_signal<mpris::Player::Signals::PlaybackStatusChanged>()
           }
     {
     }
@@ -111,18 +122,130 @@
     {
     }
 
+    void handle_create_video_sink(const core::dbus::Message::Ptr& in)
+    {
+        uint32_t texture_id;
+        in->reader() >> texture_id;
+        impl->create_video_sink(texture_id);
+
+        auto reply = dbus::Message::make_method_return(in);
+        impl->access_bus()->send(reply);
+    }
+
+    std::string get_client_apparmor_context(const core::dbus::Message::Ptr& msg)
+    {
+        auto bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::session));
+        bus->install_executor(dbus::asio::make_executor(bus));
+
+        auto stub_service = dbus::Service::use_service(bus, dbus::traits::Service<core::Apparmor>::interface_name());
+        apparmor_session = stub_service->object_for_path(dbus::types::ObjectPath("/org/freedesktop/DBus"));
+        // Get the AppArmor security context for the client
+        auto result = apparmor_session->invoke_method_synchronously<core::Apparmor::getConnectionAppArmorSecurityContext, std::string>(msg->sender());
+        if (result.is_error())
+        {
+            std::cout << "Error getting apparmor profile: " << result.error().print() << std::endl;
+            return std::string();
+        }
+
+        return result.value();
+    }
+
+    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
+        else if (pkgname == "com.ubuntu.music" &&
+                (uri.find(std::string("Music/")) != std::string::npos
+                || uri.find(std::string("Videos/")) != std::string::npos))
+        {
+            std::cout << "Client can access content in ~/Music or ~/Videos" << 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);
+        reply->writer() << impl->key();
+        impl->access_bus()->send(reply);
+    }
+
     void handle_open_uri(const core::dbus::Message::Ptr& in)
     {
         Track::UriType uri;
         in->reader() >> uri;
 
+        std::string context = get_client_apparmor_context(in);
+        bool have_access = does_client_have_access(context, uri);
+
         auto reply = dbus::Message::make_method_return(in);
-        reply->writer() << impl->open_uri(uri);
+        if (have_access)
+            reply->writer() << impl->open_uri(uri);
+        else
+            reply->writer() << false;
         impl->access_bus()->send(reply);
     }
 
     media::PlayerSkeleton* impl;
     dbus::Object::Ptr object;
+    dbus::Object::Ptr apparmor_session;
     struct
     {
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanPlay>> can_play;
@@ -131,6 +254,8 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanControl>> can_control;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoNext>> can_go_next;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoPrevious>> can_go_previous;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsVideoSource>> is_video_source;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsAudioSource>> is_audio_source;
 
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackStatus>> playback_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::LoopStatus>> loop_status;
@@ -144,10 +269,51 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MaximumRate>> maximum_playback_rate;
     } properties;
 
-    /*struct
+    struct Signals
     {
-        std::shared_ptr<dbus::Signal<mpris::Player::Signals::Seeked, uint64_t>> seeked;
-        } signals;*/
+        typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::PlaybackStatusChanged, mpris::Player::Signals::PlaybackStatusChanged::ArgumentType> DBusPlaybackStatusChangedSignal;
+
+        Signals(const std::shared_ptr<DBusSeekedToSignal>& seeked,
+                const std::shared_ptr<DBusEndOfStreamSignal>& eos,
+                const std::shared_ptr<DBusPlaybackStatusChangedSignal>& status)
+            : dbus
+              {
+                  seeked,
+                  eos,
+                  status
+              },
+              seeked_to(),
+              end_of_stream(),
+              playback_status_changed()
+        {
+            seeked_to.connect([this](std::uint64_t value)
+            {
+                dbus.seeked_to->emit(value);
+            });
+
+            end_of_stream.connect([this]()
+            {
+                dbus.end_of_stream->emit();
+            });
+
+            playback_status_changed.connect([this](const media::Player::PlaybackStatus& status)
+            {
+                dbus.playback_status_changed->emit(status);
+            });
+        }
+
+        struct DBus
+        {
+            std::shared_ptr<DBusSeekedToSignal> seeked_to;
+            std::shared_ptr<DBusEndOfStreamSignal> end_of_stream;
+            std::shared_ptr<DBusPlaybackStatusChangedSignal> playback_status_changed;
+        } dbus;
+        core::Signal<uint64_t> seeked_to;
+        core::Signal<void> end_of_stream;
+        core::Signal<media::Player::PlaybackStatus> playback_status_changed;
+    } signals;
 
 };
 
@@ -184,6 +350,14 @@
         std::bind(&Private::handle_set_position,
                   std::ref(d),
                   std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::CreateVideoSink>(
+        std::bind(&Private::handle_create_video_sink,
+                  std::ref(d),
+                  std::placeholders::_1));
+    d->object->install_method_handler<mpris::Player::Key>(
+        std::bind(&Private::handle_key,
+                  std::ref(d),
+                  std::placeholders::_1));
     d->object->install_method_handler<mpris::Player::OpenUri>(
         std::bind(&Private::handle_open_uri,
                   std::ref(d),
@@ -219,6 +393,16 @@
     return *d->properties.can_go_next;
 }
 
+const core::Property<bool>& media::PlayerSkeleton::is_video_source() const
+{
+    return *d->properties.is_video_source;
+}
+
+const core::Property<bool>& media::PlayerSkeleton::is_audio_source() const
+{
+    return *d->properties.is_audio_source;
+}
+
 const core::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status() const
 {
     return *d->properties.playback_status;
@@ -329,6 +513,17 @@
     return *d->properties.can_go_next;
 }
 
+core::Property<bool>& media::PlayerSkeleton::is_video_source()
+{
+    return *d->properties.is_video_source;
+}
+
+core::Property<bool>& media::PlayerSkeleton::is_audio_source()
+{
+    return *d->properties.is_audio_source;
+}
+
+
 core::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track()
 {
     return *d->properties.meta_data_for_current_track;
@@ -346,6 +541,25 @@
 
 const core::Signal<uint64_t>& media::PlayerSkeleton::seeked_to() const
 {
-    static const core::Signal<uint64_t> signal;
-    return signal;
+    return d->signals.seeked_to;
+}
+
+core::Signal<uint64_t>& media::PlayerSkeleton::seeked_to()
+{
+    return d->signals.seeked_to;
+}
+
+const core::Signal<void>& media::PlayerSkeleton::end_of_stream() const
+{
+    return d->signals.end_of_stream;
+}
+
+core::Signal<void>& media::PlayerSkeleton::end_of_stream()
+{
+    return d->signals.end_of_stream;
+}
+
+core::Signal<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status_changed()
+{
+    return d->signals.playback_status_changed;
 }

=== modified file 'src/core/media/player_skeleton.h'
--- src/core/media/player_skeleton.h	2014-02-18 19:27:01 +0000
+++ src/core/media/player_skeleton.h	2014-04-30 01:13:03 +0000
@@ -1,4 +1,6 @@
 /**
+ * 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.
@@ -46,6 +48,8 @@
     virtual const core::Property<bool>& can_seek() const;
     virtual const core::Property<bool>& can_go_previous() const;
     virtual const core::Property<bool>& can_go_next() const;
+    virtual const core::Property<bool>& is_video_source() const;
+    virtual const core::Property<bool>& is_audio_source() const;
     virtual const core::Property<PlaybackStatus>& playback_status() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
@@ -63,6 +67,8 @@
     virtual core::Property<Volume>& volume();
 
     virtual const core::Signal<uint64_t>& seeked_to() const;
+    virtual const core::Signal<void>& end_of_stream() const;
+    virtual core::Signal<PlaybackStatus>& playback_status_changed();
 
   protected:
     PlayerSkeleton(const core::dbus::types::ObjectPath& session_path);
@@ -73,12 +79,17 @@
     virtual core::Property<bool>& can_seek();
     virtual core::Property<bool>& can_go_previous();
     virtual core::Property<bool>& can_go_next();
+    virtual core::Property<bool>& is_video_source();
+    virtual core::Property<bool>& is_audio_source();
     virtual core::Property<Track::MetaData>& meta_data_for_current_track();
     virtual core::Property<PlaybackRate>& minimum_playback_rate();
     virtual core::Property<PlaybackRate>& maximum_playback_rate();
     virtual core::Property<uint64_t>& position();
     virtual core::Property<uint64_t>& duration();
 
+    virtual core::Signal<uint64_t>& seeked_to();
+    virtual core::Signal<void>& end_of_stream();
+
   private:
     struct Private;
     std::unique_ptr<Private> d;

=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2014-02-20 19:05:17 +0000
+++ src/core/media/player_stub.cpp	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,
@@ -31,8 +31,14 @@
 #include <core/dbus/property.h>
 #include <core/dbus/types/object_path.h>
 
+// Hybris
+#include <hybris/media/media_codec_layer.h>
+#include <hybris/media/surface_texture_client_hybris.h>
+
 #include <limits>
 
+#define UNUSED __attribute__((unused))
+
 namespace dbus = core::dbus;
 namespace media = core::ubuntu::media;
 
@@ -42,6 +48,12 @@
             const std::shared_ptr<dbus::Service>& remote,
             const dbus::types::ObjectPath& path
             ) : parent(parent),
+                texture_id(0),
+                igbc_wrapper(nullptr),
+                glc_wrapper(nullptr),
+                decoding_session(decoding_service_create_session()),
+                frame_available_cb(nullptr),
+                frame_available_context(nullptr),
                 path(path),
                 object(remote->object_for_path(path)),
                 properties
@@ -52,6 +64,8 @@
                     object->get_property<mpris::Player::Properties::CanControl>(),
                     object->get_property<mpris::Player::Properties::CanGoNext>(),
                     object->get_property<mpris::Player::Properties::CanGoPrevious>(),
+                    object->get_property<mpris::Player::Properties::IsVideoSource>(),
+                    object->get_property<mpris::Player::Properties::IsAudioSource>(),
                     object->get_property<mpris::Player::Properties::PlaybackStatus>(),
                     object->get_property<mpris::Player::Properties::LoopStatus>(),
                     object->get_property<mpris::Player::Properties::PlaybackRate>(),
@@ -62,13 +76,68 @@
                     object->get_property<mpris::Player::Properties::Duration>(),
                     object->get_property<mpris::Player::Properties::MinimumRate>(),
                     object->get_property<mpris::Player::Properties::MaximumRate>()
+                },
+                signals
+                {
+                    object->get_signal<mpris::Player::Signals::Seeked>(),
+                    object->get_signal<mpris::Player::Signals::EndOfStream>(),
+                    object->get_signal<mpris::Player::Signals::PlaybackStatusChanged>()
                 }
     {
     }
 
+    ~Private()
+    {
+    }
+
+    static void on_frame_available_cb(UNUSED GLConsumerWrapperHybris wrapper, void *context)
+    {
+        if (context != nullptr) {
+            Private *p = static_cast<Private*>(context);
+            p->on_frame_available();
+        }
+        else
+            std::cout << "context is nullptr, can't call on_frame_available()" << std::endl;
+    }
+
+    void on_frame_available()
+    {
+        if (frame_available_cb != nullptr) {
+            frame_available_cb(frame_available_context);
+        }
+        else
+            std::cout << "frame_available_cb is nullptr, can't call frame_available_cb()" << std::endl;
+    }
+
+    void set_frame_available_cb(FrameAvailableCb cb, void *context)
+    {
+        frame_available_cb = cb;
+        frame_available_context = context;
+
+        gl_consumer_set_frame_available_cb(glc_wrapper, &Private::on_frame_available_cb, static_cast<void*>(this));
+    }
+
+    /** We need a GLConsumerHybris instance for doing texture streaming over the
+     * process boundary **/
+    void get_gl_consumer()
+    {
+        igbc_wrapper = decoding_service_get_igraphicbufferconsumer();
+        glc_wrapper = gl_consumer_create_by_id_with_igbc(texture_id, igbc_wrapper);
+
+    }
+
     std::shared_ptr<Service> parent;
     std::shared_ptr<TrackList> track_list;
 
+    uint32_t texture_id;
+    IGBCWrapperHybris igbc_wrapper;
+    GLConsumerWrapperHybris glc_wrapper;
+
+    DSSessionWrapperHybris decoding_session;
+
+    FrameAvailableCb frame_available_cb;
+    void *frame_available_context;
+
     dbus::Bus::Ptr bus;
     dbus::types::ObjectPath path;
     dbus::Object::Ptr object;
@@ -81,6 +150,8 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanControl>> can_control;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoNext>> can_go_next;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoPrevious>> can_go_previous;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsVideoSource>> is_video_source;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsAudioSource>> is_audio_source;
 
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackStatus>> playback_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::LoopStatus>> loop_status;
@@ -93,6 +164,68 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MinimumRate>> minimum_playback_rate;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MaximumRate>> maximum_playback_rate;
     } properties;
+
+    struct Signals
+    {
+        typedef core::dbus::Signal<mpris::Player::Signals::Seeked, mpris::Player::Signals::Seeked::ArgumentType> DBusSeekedToSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::EndOfStream, mpris::Player::Signals::EndOfStream::ArgumentType> DBusEndOfStreamSignal;
+        typedef core::dbus::Signal<mpris::Player::Signals::PlaybackStatusChanged, mpris::Player::Signals::PlaybackStatusChanged::ArgumentType> DBusPlaybackStatusChangedSignal;
+
+        Signals(const std::shared_ptr<DBusSeekedToSignal>& seeked,
+                const std::shared_ptr<DBusEndOfStreamSignal>& eos,
+                const std::shared_ptr<DBusPlaybackStatusChangedSignal>& status)
+            : dbus
+              {
+                  seeked,
+                  eos,
+                  status
+              },
+              playback_complete_cb(nullptr),
+              playback_complete_context(nullptr),
+              seeked_to(),
+              end_of_stream(),
+              playback_status_changed()
+        {
+            dbus.seeked_to->connect([this](std::uint64_t value)
+            {
+                std::cout << "seeked_to signal arrived via the bus." << std::endl;
+                seeked_to(value);
+            });
+
+            dbus.end_of_stream->connect([this]()
+            {
+                std::cout << "EndOfStream signal arrived via the bus." << std::endl;
+                if (playback_complete_cb)
+                    playback_complete_cb(playback_complete_context);
+                end_of_stream();
+            });
+
+            dbus.playback_status_changed->connect([this](const media::Player::PlaybackStatus& status)
+            {
+                std::cout << "PlaybackStatusChanged signal arrived via the bus." << std::endl;
+                playback_status_changed(status);
+            });
+        }
+
+        struct DBus
+        {
+            std::shared_ptr<DBusSeekedToSignal> seeked_to;
+            std::shared_ptr<DBusEndOfStreamSignal> end_of_stream;
+            std::shared_ptr<DBusPlaybackStatusChangedSignal> playback_status_changed;
+        } dbus;
+
+        void set_playback_complete_cb(PlaybackCompleteCb cb, void *context)
+        {
+            playback_complete_cb = cb;
+            playback_complete_context = context;
+        }
+
+        PlaybackCompleteCb playback_complete_cb;
+        void *playback_complete_context;
+        core::Signal<uint64_t> seeked_to;
+        core::Signal<void> end_of_stream;
+        core::Signal<media::Player::PlaybackStatus> playback_status_changed;
+    } signals;
 };
 
 media::PlayerStub::PlayerStub(
@@ -101,10 +234,20 @@
         : dbus::Stub<Player>(the_session_bus()),
           d(new Private{parent, access_service(), object_path})
 {
+    auto bus = the_session_bus();
+    worker = std::move(std::thread([bus]()
+    {
+        bus->run();
+    }));
 }
 
 media::PlayerStub::~PlayerStub()
 {
+    auto bus = the_session_bus();
+    bus->stop();
+
+    if (worker.joinable())
+        worker.join();
 }
 
 std::shared_ptr<media::TrackList> media::PlayerStub::track_list()
@@ -118,6 +261,13 @@
     return d->track_list;
 }
 
+media::Player::PlayerKey media::PlayerStub::key() const
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::Key, media::Player::PlayerKey>();
+
+    return op.value();
+}
+
 bool media::PlayerStub::open_uri(const media::Track::UriType& uri)
 {
     auto op = d->object->invoke_method_synchronously<mpris::Player::OpenUri, bool>(uri);
@@ -125,6 +275,21 @@
     return op.value();
 }
 
+void media::PlayerStub::create_video_sink(uint32_t texture_id)
+{
+    auto op = d->object->invoke_method_synchronously<mpris::Player::CreateVideoSink, void>(texture_id);
+    d->texture_id = texture_id;
+    d->get_gl_consumer();
+
+    if (op.is_error())
+        throw std::runtime_error("Problem creating new video sink instance on remote object");
+}
+
+GLConsumerWrapperHybris media::PlayerStub::gl_consumer() const
+{
+    return d->glc_wrapper;
+}
+
 void media::PlayerStub::next()
 {
     auto op = d->object->invoke_method_synchronously<mpris::Player::Next, void>();
@@ -173,6 +338,16 @@
         throw std::runtime_error("Problem stopping playback on remote object");
 }
 
+void media::PlayerStub::set_frame_available_callback(FrameAvailableCb cb, void *context)
+{
+    d->set_frame_available_cb(cb, context);
+}
+
+void media::PlayerStub::set_playback_complete_callback(PlaybackCompleteCb cb, void *context)
+{
+    d->signals.set_playback_complete_cb(cb, context);
+}
+
 const core::Property<bool>& media::PlayerStub::can_play() const
 {
     return *d->properties.can_play;
@@ -198,6 +373,16 @@
     return *d->properties.can_go_next;
 }
 
+const core::Property<bool>& media::PlayerStub::is_video_source() const
+{
+    return *d->properties.is_video_source;
+}
+
+const core::Property<bool>& media::PlayerStub::is_audio_source() const
+{
+    return *d->properties.is_audio_source;
+}
+
 const core::Property<media::Player::PlaybackStatus>& media::PlayerStub::playback_status() const
 {
     return *d->properties.playback_status;
@@ -270,6 +455,15 @@
 
 const core::Signal<uint64_t>& media::PlayerStub::seeked_to() const
 {
-    static core::Signal<uint64_t> signal;
-    return signal;
+    return d->signals.seeked_to;
+}
+
+const core::Signal<void>& media::PlayerStub::end_of_stream() const
+{
+    return d->signals.end_of_stream;
+}
+
+core::Signal<media::Player::PlaybackStatus>& media::PlayerStub::playback_status_changed()
+{
+    return d->signals.playback_status_changed;
 }

=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2014-02-18 19:27:01 +0000
+++ src/core/media/player_stub.h	2014-04-30 01:13:03 +0000
@@ -43,8 +43,11 @@
     ~PlayerStub();
 
     virtual std::shared_ptr<TrackList> track_list();
+    virtual PlayerKey key() const;
 
     virtual bool open_uri(const Track::UriType& uri);
+    virtual void create_video_sink(uint32_t texture_id);
+    virtual GLConsumerWrapperHybris gl_consumer() const;
     virtual void next();
     virtual void previous();
     virtual void play();
@@ -52,11 +55,16 @@
     virtual void seek_to(const std::chrono::microseconds& offset);
     virtual void stop();
 
+    virtual void set_frame_available_callback(FrameAvailableCb cb, void *context);
+    virtual void set_playback_complete_callback(PlaybackCompleteCb cb, void *context);
+
     virtual const core::Property<bool>& can_play() const;
     virtual const core::Property<bool>& can_pause() const;
     virtual const core::Property<bool>& can_seek() const;
     virtual const core::Property<bool>& can_go_previous() const;
     virtual const core::Property<bool>& can_go_next() const;
+    virtual const core::Property<bool>& is_video_source() const;
+    virtual const core::Property<bool>& is_audio_source() const;
     virtual const core::Property<PlaybackStatus>& playback_status() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
@@ -74,10 +82,13 @@
     virtual core::Property<Volume>& volume();
 
     virtual const core::Signal<uint64_t>& seeked_to() const;
+    virtual const core::Signal<void>& end_of_stream() const;
+    virtual core::Signal<PlaybackStatus>& playback_status_changed();
 
   private:
     struct Private;
     std::unique_ptr<Private> d;
+    std::thread worker;
 };
 }
 }

=== added file 'src/core/media/powerd_service.h'
--- src/core/media/powerd_service.h	1970-01-01 00:00:00 +0000
+++ src/core/media/powerd_service.h	2014-04-30 01:13:03 +0000
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *      Author: Ricardo Mendoza <[e-mail]>
+ */
+
+#include <core/dbus/dbus.h>
+#include <core/dbus/fixture.h>
+#include <core/dbus/object.h>
+#include <core/dbus/property.h>
+#include <core/dbus/service.h>
+#include <core/dbus/interfaces/properties.h>
+#include <core/dbus/types/stl/tuple.h>
+#include <core/dbus/types/stl/vector.h>
+
+#include <core/dbus/asio/executor.h>
+
+#include <string>
+#include <vector>
+#include <chrono>
+
+namespace core
+{
+
+struct Powerd
+{
+    static std::string& name()
+    {
+        static std::string s = "com.canonical.powerd";
+        return s;
+    }
+
+    struct requestDisplayState
+    {
+        static std::string name()
+        {
+            static std::string s = "requestDisplayState";
+            return s;
+        }
+
+        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+
+        typedef Powerd Interface;
+    };
+
+    struct clearDisplayState
+    {
+        static std::string name()
+        {
+            static std::string s = "clearDisplayState";
+            return s;
+        }
+ 
+        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+
+        typedef Powerd Interface;
+    };
+
+    struct requestSysState
+    {
+        static std::string name()
+        {
+            static std::string s = "requestSysState";
+            return s;
+        }
+
+        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+
+        typedef Powerd Interface;
+    };
+
+    struct clearSysState
+    {
+        static std::string name()
+        {
+            static std::string s = "clearSysState";
+            return s;
+        }
+ 
+        static const std::chrono::milliseconds default_timeout() { return std::chrono::seconds{1}; }
+
+        typedef Powerd Interface;
+    };
+
+};
+
+}

=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/server/server.cpp	2014-04-30 01:13:03 +0000
@@ -1,13 +1,41 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
 #include <core/media/service.h>
 #include <core/media/player.h>
 #include <core/media/track_list.h>
 
+#include <hybris/media/media_codec_layer.h>
+
 #include "core/media/service_implementation.h"
 
+#include <iostream>
+
 namespace media = core::ubuntu::media;
 
+using namespace std;
+
 int main()
 {
+    // Init hybris-level DecodingService
+    decoding_service_init();
+    cout << "Starting DecodingService..." << endl;
+
     auto service = std::make_shared<media::ServiceImplementation>();
     service->run();
 

=== modified file 'src/core/media/service.cpp'
--- src/core/media/service.cpp	2014-01-17 20:58:31 +0000
+++ src/core/media/service.cpp	2014-04-30 01:13:03 +0000
@@ -24,7 +24,7 @@
 
 const std::shared_ptr<media::Service> media::Service::Client::instance()
 {
-    std::cout << "Creating a new Service instance" << std::endl;
+    std::cout << "Creating a new static Service instance" << std::endl;
     static std::shared_ptr<media::Service> instance{new media::ServiceStub()};
     return instance;
 }

=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2014-01-13 21:51:14 +0000
+++ src/core/media/service_implementation.cpp	2014-04-30 01:13:03 +0000
@@ -21,21 +21,63 @@
 #include "player_configuration.h"
 #include "player_implementation.h"
 
-#include "gstreamer/engine.h"
+#include <map>
 
 namespace media = core::ubuntu::media;
 
+using namespace std;
+
 struct media::ServiceImplementation::Private
 {
-    Private() : engine(std::make_shared<gstreamer::Engine>())
-    {
-    }
-    std::shared_ptr<media::Engine> engine;
+    Private()
+        : key_(0)
+    {
+    }
+
+    void track_player(const std::shared_ptr<media::Player>& player)
+    {
+        cout << __PRETTY_FUNCTION__ << endl;
+        cout << "key: " << key_ << endl;
+        player_map.insert(
+                std::pair<media::Player::PlayerKey,
+                std::shared_ptr<media::Player>>(key_, player));
+
+        ++key_;
+    }
+
+    inline media::Player::PlayerKey key() const
+    {
+        return key_;
+    }
+
+    void pause_other_sessions(media::Player::PlayerKey key)
+    {
+        cout << __PRETTY_FUNCTION__ << endl;
+        cout << "key: " << key << endl;
+
+        // TODO: Add a field to Player that is the type of player so that certain
+        // types of playback aren't paused below. E.g. a camera click sound shouldn't
+        // pause, nor should it pause background music sessions
+        for (auto& player_pair : player_map)
+        {
+            if (player_pair.second->playback_status() == Player::playing
+                    && player_pair.first != key)
+            {
+                cout << "Pausing player with key: " << player_pair.first << endl;
+                player_pair.second->pause();
+            }
+        }
+    }
+
+    // Used for Player instance management
+    std::map<media::Player::PlayerKey, std::shared_ptr<media::Player>> player_map;
+    media::Player::PlayerKey key_;
+
 };
 
 media::ServiceImplementation::ServiceImplementation() : d(new Private())
 {
-
+    cout << __PRETTY_FUNCTION__ << endl;
 }
 
 media::ServiceImplementation::~ServiceImplementation()
@@ -45,8 +87,13 @@
 std::shared_ptr<media::Player> media::ServiceImplementation::create_session(
         const media::Player::Configuration& conf)
 {
-    return std::make_shared<media::PlayerImplementation>(
-                conf.object_path,
-                shared_from_this(),
-                d->engine);
+    std::shared_ptr<media::Player> player = std::make_shared<media::PlayerImplementation>(
+            conf.object_path, shared_from_this(), d->key());
+    d->track_player(player);
+    return player;
+}
+
+void media::ServiceImplementation::pause_other_sessions(media::Player::PlayerKey key)
+{
+    d->pause_other_sessions(key);
 }

=== modified file 'src/core/media/service_implementation.h'
--- src/core/media/service_implementation.h	2014-01-13 21:51:14 +0000
+++ src/core/media/service_implementation.h	2014-04-30 01:13:03 +0000
@@ -27,6 +27,9 @@
 {
 namespace media
 {
+
+class Player;
+
 class ServiceImplementation : public ServiceSkeleton
 {
   public:
@@ -35,6 +38,8 @@
 
     std::shared_ptr<Player> create_session(const Player::Configuration&);
 
+    void pause_other_sessions(Player::PlayerKey key);
+
   private:
     struct Private;
     std::shared_ptr<Private> d;

=== modified file 'src/core/media/service_skeleton.cpp'
--- src/core/media/service_skeleton.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/service_skeleton.cpp	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,
@@ -49,6 +49,11 @@
                         &Private::handle_create_session,
                         this,
                         std::placeholders::_1));
+        object->install_method_handler<mpris::Service::PauseOtherSessions>(
+                    std::bind(
+                        &Private::handle_pause_other_sessions,
+                        this,
+                        std::placeholders::_1));
     }
 
     void handle_create_session(const core::dbus::Message::Ptr& msg)
@@ -86,6 +91,17 @@
         }
     }
 
+    void handle_pause_other_sessions(const core::dbus::Message::Ptr& msg)
+    {
+        std::cout << __PRETTY_FUNCTION__ << std::endl;
+        Player::PlayerKey key;
+        msg->reader() >> key;
+        impl->pause_other_sessions(key);
+
+        auto reply = dbus::Message::make_method_return(msg);
+        impl->access_bus()->send(reply);
+    }
+
     media::ServiceSkeleton* impl;
     dbus::Object::Ptr object;
 

=== modified file 'src/core/media/service_skeleton.h'
--- src/core/media/service_skeleton.h	2014-02-12 15:53:57 +0000
+++ src/core/media/service_skeleton.h	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,

=== modified file 'src/core/media/service_stub.cpp'
--- src/core/media/service_stub.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/service_stub.cpp	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,
@@ -47,13 +47,21 @@
 
 std::shared_ptr<media::Player> media::ServiceStub::create_session(const media::Player::Configuration&)
 {
-    auto op
-            = d->object->invoke_method_synchronously<
-                mpris::Service::CreateSession,
-                dbus::types::ObjectPath>();
+    auto op = d->object->invoke_method_synchronously<mpris::Service::CreateSession,
+         dbus::types::ObjectPath>();
 
     if (op.is_error())
         throw std::runtime_error("Problem creating session: " + op.error());
 
     return std::shared_ptr<media::Player>(new media::PlayerStub(shared_from_this(), op.value()));
 }
+
+void media::ServiceStub::pause_other_sessions(media::Player::PlayerKey key)
+{
+    std::cout << __PRETTY_FUNCTION__ << std::endl;
+    auto op = d->object->invoke_method_synchronously<mpris::Service::PauseOtherSessions,
+         void>(key);
+
+    if (op.is_error())
+        throw std::runtime_error("Problem pausing other sessions: " + op.error());
+}

=== modified file 'src/core/media/service_stub.h'
--- src/core/media/service_stub.h	2014-02-12 15:53:57 +0000
+++ src/core/media/service_stub.h	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,
@@ -40,6 +40,7 @@
     ~ServiceStub();
 
     std::shared_ptr<Player> create_session(const Player::Configuration&);
+    void pause_other_sessions(Player::PlayerKey key);
 
   private:
     struct Private;

=== modified file 'src/core/media/track_list_implementation.cpp'
--- src/core/media/track_list_implementation.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_implementation.cpp	2014-04-30 01:13:03 +0000
@@ -16,6 +16,9 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include <stdio.h>
+#include <stdlib.h>
+
 #include "track_list_implementation.h"
 
 #include "engine.h"
@@ -45,6 +48,16 @@
 {
 }
 
+media::Track::UriType media::TrackListImplementation::query_uri_for_track(const media::Track::Id& id)
+{
+    auto it = d->meta_data_cache.find(id);
+
+    if (it == d->meta_data_cache.end())
+        return Track::UriType{};
+
+    return std::get<0>(it->second);
+}
+
 media::Track::MetaData media::TrackListImplementation::query_meta_data_for_track(const media::Track::Id& id)
 {
     auto it = d->meta_data_cache.find(id);

=== modified file 'src/core/media/track_list_implementation.h'
--- src/core/media/track_list_implementation.h	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_implementation.h	2014-04-30 01:13:03 +0000
@@ -36,6 +36,7 @@
             const std::shared_ptr<Engine::MetaDataExtractor>& extractor);
     ~TrackListImplementation();
 
+    Track::UriType query_uri_for_track(const Track::Id& id);
     Track::MetaData query_meta_data_for_track(const Track::Id& id);
 
     void add_track_with_uri_at(const Track::UriType& uri, const Track::Id& position, bool make_current);

=== modified file 'src/core/media/track_list_skeleton.cpp'
--- src/core/media/track_list_skeleton.cpp	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_skeleton.cpp	2014-04-30 01:13:03 +0000
@@ -48,7 +48,8 @@
           object(object),
           can_edit_tracks(object->get_property<mpris::TrackList::Properties::CanEditTracks>()),
           tracks(object->get_property<mpris::TrackList::Properties::Tracks>()),
-          current_track(tracks->get().begin())
+          current_track(tracks->get().begin()),
+          empty_iterator(tracks->get().begin())
     {
     }
 
@@ -103,6 +104,7 @@
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::CanEditTracks>> can_edit_tracks;
     std::shared_ptr<core::dbus::Property<mpris::TrackList::Properties::Tracks>> tracks;
     TrackList::ConstIterator current_track;
+    TrackList::ConstIterator empty_iterator;
 
     core::Signal<void> on_track_list_replaced;
     core::Signal<Track::Id> on_track_added;
@@ -142,12 +144,22 @@
 
 bool media::TrackListSkeleton::has_next() const
 {
-    return std::next(d->current_track) != d->tracks->get().end();
+    return d->current_track != d->tracks->get().end();
 }
 
 const media::Track::Id& media::TrackListSkeleton::next()
 {
-    return *(d->current_track = std::next(d->current_track));
+    if (d->tracks->get().empty())
+        return *(d->current_track);
+
+    if (d->tracks->get().size() && (d->current_track == d->empty_iterator))
+    {        
+        d->current_track = d->tracks->get().begin();
+        return *(d->current_track = std::next(d->current_track));
+    }
+
+    d->current_track = std::next(d->current_track);
+    return *(d->current_track);
 }
 
 const core::Property<bool>& media::TrackListSkeleton::can_edit_tracks() const

=== modified file 'src/core/media/track_list_skeleton.h'
--- src/core/media/track_list_skeleton.h	2014-02-12 15:53:57 +0000
+++ src/core/media/track_list_skeleton.h	2014-04-30 01:13:03 +0000
@@ -48,9 +48,10 @@
     const core::Signal<Track::Id>& on_track_removed() const;
     const core::Signal<Track::Id>& on_track_changed() const;
 
+    core::Property<Container>& tracks();
+
 protected:
     core::Property<bool>& can_edit_tracks();
-    core::Property<Container>& tracks();
 
     core::Signal<void>& on_track_list_replaced();
     core::Signal<Track::Id>& on_track_added();

=== modified file 'tests/acceptance-tests/service.cpp'
--- tests/acceptance-tests/service.cpp	2014-03-06 19:23:19 +0000
+++ tests/acceptance-tests/service.cpp	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-01-17 20:58:31 +0000
+++ tests/unit-tests/CMakeLists.txt	2014-04-30 01:13:03 +0000
@@ -1,10 +1,21 @@
 include_directories(
     .
     ${CMAKE_SOURCE_DIR}/src
+    ${PC_GSTREAMER_1_0_INCLUDE_DIRS}
 )
 
 add_executable(
     test-gstreamer-engine
+
+    libmedia-mock.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/engine.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/gstreamer/engine.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/player_skeleton.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/player_implementation.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/service_skeleton.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/service_implementation.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/track_list_skeleton.cpp
+    ${CMAKE_SOURCE_DIR}/src/core/media/track_list_implementation.cpp
     test-gstreamer-engine.cpp
 )
 
@@ -13,12 +24,15 @@
 
     media-hub-common
     media-hub-client
-    media-hub-service
     media-hub-test-framework
 
     ${CMAKE_THREAD_LIBS_INIT}
     ${Boost_LIBRARIES}
     ${DBUS_LIBRARIES}
+    ${DBUS_CPP_LDFLAGS}
+    ${GLog_LIBRARY}
+    ${PC_GSTREAMER_1_0_LIBRARIES}
+    ${GIO_LIBRARIES}
 
     gmock
     gmock_main

=== added file 'tests/unit-tests/libmedia-mock.cpp'
--- tests/unit-tests/libmedia-mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/libmedia-mock.cpp	2014-04-30 01:13:03 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 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/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#include <hybris/media/media_codec_layer.h>
+#include <hybris/media/surface_texture_client_hybris.h>
+
+#define UNUSED __attribute__((unused))
+
+void decoding_service_set_client_death_cb(UNUSED DecodingClientDeathCbHybris callback, UNUSED void *context)
+{
+}

=== modified file 'tests/unit-tests/test-gstreamer-engine.cpp'
--- tests/unit-tests/test-gstreamer-engine.cpp	2014-02-26 14:58:36 +0000
+++ tests/unit-tests/test-gstreamer-engine.cpp	2014-04-30 01:13:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 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,
@@ -198,7 +198,7 @@
                     std::chrono::seconds{40}));
 }
 
-TEST(GStreamerEngine, DISABLED_stop_pause_play_seek_video_works)
+TEST(GStreamerEngine, stop_pause_play_seek_video_works)
 {
     const std::string test_file{"/tmp/h264.avi"};
     const std::string test_file_uri{"file:///tmp/h264.avi"};
@@ -248,8 +248,8 @@
 
 TEST(GStreamerEngine, get_position_duration_work)
 {
-    const std::string test_file{"/tmp/test.ogg"};
-    const std::string test_file_uri{"file:///tmp/test.ogg"};
+    const std::string test_file{"/tmp/h264.avi"};
+    const std::string test_file_uri{"file:///tmp/h264.avi"};
     std::remove(test_file.c_str());
     ASSERT_TRUE(test::copy_test_ogg_file_to(test_file));
 
@@ -269,10 +269,18 @@
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
                     std::chrono::milliseconds{4000}));
-    sleep(1);
-
-    // FIXME: Ideally we want to seek_to and measure the position there, but seek_to seems
-    // broken from within this unit test
+
+    EXPECT_TRUE(engine.seek_to(std::chrono::seconds{10}));
+    EXPECT_TRUE(engine.play());
+    EXPECT_TRUE(wst.wait_for_state_for(
+                    core::ubuntu::media::Engine::State::playing,
+                    std::chrono::milliseconds{4000}));
+
+    std::cout << "position: " << engine.position() << std::endl;
+    std::cout << "duration: " << engine.duration() << std::endl;
+
+    // FIXME: This should be 10e9, but seek_to seems to be broken from within this unit test
+    // and I haven't been able to figure out why
     EXPECT_TRUE(engine.position() > 1e9);
 
     EXPECT_TRUE(engine.duration() > 1e9);