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

[Jim Hodapp]

Make media-hub work on the desktop. Everything except for video playback works with this commit.

Make media-hub work on the desktop. Everything except for video playback works with this commit.

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

206. By Jim Hodapp on 2016-08-11

Add simple unit test that ensures the service comes up.

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

We need to decide how to detect the platform, see comment below.

review: Needs Information

[Konrad Zapałowicz (kzapalowicz)]

LGTM except that I need an explanation if it is possible to cache get_backend_type()

review: Needs Information (code)

[Jim Hodapp (jhodapp)]

Thanks for the very timely reviews guys. See my replies inline.

[Konrad Zapałowicz (kzapalowicz)]

LGTM

review: Approve

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

207. By Jim Hodapp on 2016-08-12

Dynamically detect hybris backend instead of setting environment variable

208. By Jim Hodapp on 2016-08-12

Cleanup and make sure to unref the plugin instance

209. By Jim Hodapp on 2016-08-12

Move debug message for hybris backend detection

210. By Jim Hodapp on 2016-08-15

Expose the backend selection to the stub side

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

LGTM

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-07-19 21:16:56 +0000
+++ CMakeLists.txt	2016-08-15 19:28:06 +0000
@@ -20,7 +20,7 @@
   # we define the version to be 5.0.0
   if (${DISTRO_CODENAME} STREQUAL "vivid")
     set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 4)
-    set(UBUNTU_MEDIA_HUB_VERSION_MINOR 5)
+    set(UBUNTU_MEDIA_HUB_VERSION_MINOR 6)
     set(UBUNTU_MEDIA_HUB_VERSION_PATCH 0)
   else ()
     set(UBUNTU_MEDIA_HUB_VERSION_MAJOR 5)
@@ -53,7 +53,13 @@
 pkg_check_modules(GIO gio-2.0 REQUIRED)
 pkg_check_modules(HYBRIS_MEDIA libmedia REQUIRED)
 
-add_definitions(-DMEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER)
+include(CheckIncludeFiles)
+check_include_files("hybris/media/media_codec_layer.h" MEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER)
+if (DEFINED MEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER)
+  add_definitions(-DMEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER)
+else()
+  MESSAGE(STATUS "*libhybris not found*")
+endif()
 
 #####################################################################
 # Enable code coverage calculation with gcov/gcovr/lcov
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-07-20 21:28:28 +0000
+++ debian/changelog	2016-08-15 19:28:06 +0000
@@ -1,3 +1,9 @@
+media-hub (4.6.0+16.10.20160815-0ubuntu1) yakkety; urgency=medium
+
+  * Make media-hub work on the desktop with Unity7/Unity8 sessions.
+
+ -- Jim Hodapp <[e-mail]>  Fri, 12 Aug 2016 15:17:28 +0000
+
 media-hub (4.5.0+16.10.20160720-0ubuntu1) yakkety; urgency=medium
 
   * Emit client side signal when the dbus connection between
 
=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2016-06-01 00:43:04 +0000
+++ include/core/media/player.h	2016-08-15 19:28:06 +0000
@@ -39,6 +39,21 @@
 class Service;
 class TrackList;
 
+struct AVBackend
+{
+    enum Backend
+    {
+        none,
+        hybris
+    };
+
+    /**
+     * @brief Returns the type of audio/video decoding/encoding backend being used.
+     * @return Returns the current backend type.
+     */
+    static Backend get_backend_type();
+};
+
 class Player : public std::enable_shared_from_this<Player>
 {
   public:
@@ -162,6 +177,7 @@
     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<AVBackend::Backend>& backend() const = 0;
     virtual const core::Property<LoopStatus>& loop_status() const = 0;
     virtual const core::Property<PlaybackRate>& playback_rate() const = 0;
     virtual const core::Property<bool>& shuffle() const = 0;
 
=== modified file 'src/core/media/CMakeLists.txt'
--- src/core/media/CMakeLists.txt	2016-06-15 17:49:49 +0000
+++ src/core/media/CMakeLists.txt	2016-08-15 19:28:06 +0000
@@ -17,6 +17,7 @@
 add_library(
   media-hub-common SHARED
 
+  backend.cpp
   the_session_bus.cpp
   util/utils.cpp
 )
@@ -27,6 +28,7 @@
   ${Boost_LIBRARIES}
   ${DBUS_LIBRARIES}
   ${DBUS_CPP_LDFLAGS}
+  ${PC_GSTREAMER_1_0_LIBRARIES}
 )
 set_target_properties(
   media-hub-common
@@ -89,42 +91,44 @@
 )
 
 add_library(
-    media-hub-service
-
-    ${MEDIA_HUB_HEADERS}
-    ${MPRIS_HEADERS}
-
-    logger/logger.cpp
-
-    client_death_observer.cpp
-    hashed_keyed_player_store.cpp
-    hybris_client_death_observer.cpp
-    cover_art_resolver.cpp
-    engine.cpp
-    metadata.cpp
-
-    apparmor/context.cpp
-    apparmor/ubuntu.cpp
-
-    audio/pulse_audio_output_observer.cpp
-    audio/ostream_reporter.cpp
-    audio/output_observer.cpp
-
-    power/battery_observer.cpp
-    power/state_controller.cpp
-
-    recorder_observer.cpp
-    hybris_recorder_observer.cpp
-
-    gstreamer/engine.cpp
-    gstreamer/playbin.cpp
-
-    player_skeleton.cpp
-    player_implementation.cpp
-    service_skeleton.cpp
-    service_implementation.cpp
-    track_list_skeleton.cpp
-    track_list_implementation.cpp
+  media-hub-service
+
+  ${MEDIA_HUB_HEADERS}
+  ${MPRIS_HEADERS}
+
+  logger/logger.cpp
+
+  client_death_observer.cpp
+  hashed_keyed_player_store.cpp
+  hybris_client_death_observer.cpp
+  stub_client_death_observer.cpp
+  cover_art_resolver.cpp
+  engine.cpp
+  metadata.cpp
+
+  apparmor/context.cpp
+  apparmor/ubuntu.cpp
+
+  audio/pulse_audio_output_observer.cpp
+  audio/ostream_reporter.cpp
+  audio/output_observer.cpp
+
+  power/battery_observer.cpp
+  power/state_controller.cpp
+
+  recorder_observer.cpp
+  hybris_recorder_observer.cpp
+  stub_recorder_observer.cpp
+
+  gstreamer/engine.cpp
+  gstreamer/playbin.cpp
+
+  player_skeleton.cpp
+  player_implementation.cpp
+  service_skeleton.cpp
+  service_implementation.cpp
+  track_list_skeleton.cpp
+  track_list_implementation.cpp
 )
 
 target_link_libraries(
@@ -146,11 +150,12 @@
   ${PC_PULSE_AUDIO_LIBRARIES}
 )
 
-include_directories(${PROJECT_SOURCE_DIR}/src/ ${HYBRIS_MEDIA_CFLAGS})
+include_directories(${PROJECT_SOURCE_DIR}/src/ ${HYBRIS_MEDIA_CFLAGS} ${PC_GSTREAMER_1_0_INCLUDE_DIRS})
 
 add_executable(
   media-hub-server
 
+  backend.cpp
   server/server.cpp
 )
 
 
=== added file 'src/core/media/backend.cpp'
--- src/core/media/backend.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/backend.cpp	2016-08-15 19:28:06 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 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/player.h>
+#include "core/media/logger/logger.h"
+
+#include <gst/gst.h>
+
+namespace media = core::ubuntu::media;
+
+media::AVBackend::Backend media::AVBackend::get_backend_type()
+{
+    GstRegistry *registry;
+    GstPlugin *plugin;
+
+    registry = gst_registry_get();
+    if (not registry)
+        return media::AVBackend::Backend::none;
+
+    plugin = gst_registry_lookup(registry, "libgstandroidmedia.so");
+    if (plugin)
+    {
+        gst_object_unref(plugin);
+        return media::AVBackend::Backend::hybris;
+    }
+
+    return media::AVBackend::Backend::none;
+}
 
=== modified file 'src/core/media/client_death_observer.cpp'
--- src/core/media/client_death_observer.cpp	2014-11-26 09:18:33 +0000
+++ src/core/media/client_death_observer.cpp	2016-08-15 19:28:06 +0000
@@ -16,7 +16,11 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include "core/media/logger/logger.h"
+
 #include <core/media/client_death_observer.h>
+#include <core/media/hybris_client_death_observer.h>
+#include <core/media/stub_client_death_observer.h>
 
 namespace media = core::ubuntu::media;
 
@@ -26,7 +30,20 @@
 // Accesses the default client death observer implementation for the platform.
 media::ClientDeathObserver::Ptr media::platform_default_client_death_observer()
 {
-    return media::HybrisClientDeathObserver::create();
+    const media::AVBackend::Backend b {media::AVBackend::get_backend_type()};
+    switch (b)
+    {
+        case media::AVBackend::Backend::hybris:
+            return media::HybrisClientDeathObserver::create();
+        case media::AVBackend::Backend::none:
+            MH_WARNING(
+                "No video backend selected. Client disconnect functionality won't work."
+            );
+            return media::StubClientDeathObserver::create();
+        default:
+            MH_INFO("Invalid or no A/V backend specified, using \"hybris\" as a default.");
+            return media::HybrisClientDeathObserver::create();
+    }
 }
 #else  // MEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER
 // Just throws a std::logic_error as we have not yet defined a default way to
 
=== modified file 'src/core/media/codec.h'
--- src/core/media/codec.h	2016-06-14 19:41:18 +0000
+++ src/core/media/codec.h	2016-08-15 19:28:06 +0000
@@ -192,6 +192,49 @@
         in = static_cast<core::ubuntu::media::Player::PlaybackStatus>(out.pop_int16());
     }
 };
+
+namespace helper
+{
+template<>
+struct TypeMapper<core::ubuntu::media::AVBackend::Backend>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return core::dbus::ArgumentType::int16;
+    }
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+    constexpr static bool requires_signature()
+    {
+        return false;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = TypeMapper<std::int16_t>::signature();
+        return s;
+    }
+};
+}
+
+template<>
+struct Codec<core::ubuntu::media::AVBackend::Backend>
+{
+    static void encode_argument(core::dbus::Message::Writer& out,
+                const core::ubuntu::media::AVBackend::Backend& in)
+    {
+        out.push_int16(static_cast<std::int16_t>(in));
+    }
+
+    static void decode_argument(core::dbus::Message::Reader& out,
+                core::ubuntu::media::AVBackend::Backend& in)
+    {
+        in = static_cast<core::ubuntu::media::AVBackend::Backend>(out.pop_int16());
+    }
+};
+
 namespace helper
 {
 template<>
 
=== modified file 'src/core/media/engine.h'
--- src/core/media/engine.h	2016-07-11 01:21:38 +0000
+++ src/core/media/engine.h	2016-08-15 19:28:06 +0000
@@ -82,7 +82,7 @@
     // support this feature.
     virtual void create_video_sink(uint32_t texture_id) = 0;
 
-    virtual bool play() = 0;
+    virtual bool play(bool use_main_context = false) = 0;
     virtual bool stop(bool use_main_context = false)  = 0;
     virtual bool pause() = 0;
     virtual bool seek_to(const std::chrono::microseconds& ts) = 0;
 
=== modified file 'src/core/media/gstreamer/engine.cpp'
--- src/core/media/gstreamer/engine.cpp	2016-07-11 01:21:38 +0000
+++ src/core/media/gstreamer/engine.cpp	2016-08-15 19:28:06 +0000
@@ -445,9 +445,9 @@
     d->playbin.create_video_sink(texture_id);
 }
 
-bool gstreamer::Engine::play()
+bool gstreamer::Engine::play(bool use_main_thread /* = false */)
 {
-    const auto result = d->playbin.set_state_and_wait(GST_STATE_PLAYING);
+    const auto result = d->playbin.set_state_and_wait(GST_STATE_PLAYING, use_main_thread);
 
     if (result)
     {
@@ -459,7 +459,7 @@
     return result;
 }
 
-bool gstreamer::Engine::stop(bool use_main_thread)
+bool gstreamer::Engine::stop(bool use_main_thread /* = false */)
 {
     // No need to wait, and we can immediately return.
     if (d->state == media::Engine::State::stopped)
 
=== modified file 'src/core/media/gstreamer/engine.h'
--- src/core/media/gstreamer/engine.h	2016-07-11 01:21:38 +0000
+++ src/core/media/gstreamer/engine.h	2016-08-15 19:28:06 +0000
@@ -37,8 +37,8 @@
     bool open_resource_for_uri(const core::ubuntu::media::Track::UriType& uri, const core::ubuntu::media::Player::HeadersType& headers);
     void create_video_sink(uint32_t texture_id);
 
-    bool play();
-    // use_main_thread will set the pipeline's new_state in the main thread context
+    // use_main_thread will set the pipeline's new state in the main thread context
+    bool play(bool use_main_thread = false);
     bool stop(bool use_main_thread = false);
     bool pause();
     bool seek_to(const std::chrono::microseconds& ts);
 
=== modified file 'src/core/media/mpris/player.h'
--- src/core/media/mpris/player.h	2016-06-16 02:34:40 +0000
+++ src/core/media/mpris/player.h	2016-08-15 19:28:06 +0000
@@ -166,7 +166,7 @@
     {
         DBUS_CPP_READABLE_PROPERTY_DEF(PlaybackStatus, Player, std::string)
         DBUS_CPP_READABLE_PROPERTY_DEF(TypedPlaybackStatus, Player, core::ubuntu::media::Player::PlaybackStatus)
-
+        DBUS_CPP_WRITABLE_PROPERTY_DEF(TypedBackend, Player, core::ubuntu::media::AVBackend::Backend)
         DBUS_CPP_WRITABLE_PROPERTY_DEF(LoopStatus, Player, std::string)
         DBUS_CPP_WRITABLE_PROPERTY_DEF(TypedLoopStatus, Player, core::ubuntu::media::Player::LoopStatus)
         DBUS_CPP_WRITABLE_PROPERTY_DEF(AudioStreamRole, Player, core::ubuntu::media::Player::AudioStreamRole)
@@ -220,6 +220,7 @@
                 Properties::IsAudioSource::ValueType is_audio_source{true};
                 Properties::PlaybackStatus::ValueType playback_status{PlaybackStatus::stopped};
                 Properties::TypedPlaybackStatus::ValueType typed_playback_status{core::ubuntu::media::Player::PlaybackStatus::null};
+                Properties::TypedBackend::ValueType typed_backend{core::ubuntu::media::AVBackend::Backend::none};
                 Properties::LoopStatus::ValueType loop_status{LoopStatus::none};
                 Properties::TypedLoopStatus::ValueType typed_loop_status{core::ubuntu::media::Player::LoopStatus::none};
                 Properties::PlaybackRate::ValueType playback_rate{1.f};
@@ -248,6 +249,7 @@
                   configuration.object->template get_property<Properties::IsAudioSource>(),
                   configuration.object->template get_property<Properties::PlaybackStatus>(),
                   configuration.object->template get_property<Properties::TypedPlaybackStatus>(),
+                  configuration.object->template get_property<Properties::TypedBackend>(),
                   configuration.object->template get_property<Properties::LoopStatus>(),
                   configuration.object->template get_property<Properties::TypedLoopStatus>(),
                   configuration.object->template get_property<Properties::AudioStreamRole>(),
@@ -284,6 +286,7 @@
             properties.is_audio_source->set(configuration.defaults.is_audio_source);
             properties.playback_status->set(configuration.defaults.playback_status);
             properties.typed_playback_status->set(configuration.defaults.typed_playback_status);
+            properties.typed_backend->set(configuration.defaults.typed_backend);
             properties.loop_status->set(configuration.defaults.loop_status);
             properties.typed_loop_status->set(configuration.defaults.typed_loop_status);
             properties.audio_stream_role->set(core::ubuntu::media::Player::AudioStreamRole::multimedia);
@@ -371,6 +374,7 @@
             dict[Properties::CanGoPrevious::name()] = dbus::types::Variant::encode(properties.can_go_previous->get());
             dict[Properties::PlaybackStatus::name()] = dbus::types::Variant::encode(properties.playback_status->get());
             dict[Properties::TypedPlaybackStatus::name()] = dbus::types::Variant::encode(properties.typed_playback_status->get());
+            dict[Properties::TypedBackend::name()] = dbus::types::Variant::encode(properties.typed_backend->get());
             dict[Properties::LoopStatus::name()] = dbus::types::Variant::encode(properties.loop_status->get());
             dict[Properties::TypedLoopStatus::name()] = dbus::types::Variant::encode(properties.typed_loop_status->get());
             dict[Properties::AudioStreamRole::name()] = dbus::types::Variant::encode(properties.audio_stream_role->get());
@@ -403,6 +407,7 @@
 
             std::shared_ptr<core::dbus::Property<Properties::PlaybackStatus>> playback_status;
             std::shared_ptr<core::dbus::Property<Properties::TypedPlaybackStatus>> typed_playback_status;
+            std::shared_ptr<core::dbus::Property<Properties::TypedBackend>> typed_backend;
             std::shared_ptr<core::dbus::Property<Properties::LoopStatus>> loop_status;
             std::shared_ptr<core::dbus::Property<Properties::TypedLoopStatus>> typed_loop_status;
             std::shared_ptr<core::dbus::Property<Properties::AudioStreamRole>> audio_stream_role;
 
=== modified file 'src/core/media/player_implementation.cpp'
--- src/core/media/player_implementation.cpp	2016-07-11 01:21:38 +0000
+++ src/core/media/player_implementation.cpp	2016-08-15 19:28:06 +0000
@@ -505,6 +505,7 @@
     Parent::shuffle().set(false);
     Parent::playback_rate().set(1.f);
     Parent::playback_status().set(Player::PlaybackStatus::null);
+    Parent::backend().set(media::AVBackend::get_backend_type());
     Parent::loop_status().set(Player::LoopStatus::none);
     Parent::position().set(0);
     Parent::duration().set(0);
 
=== modified file 'src/core/media/player_skeleton.cpp'
--- src/core/media/player_skeleton.cpp	2016-06-16 02:34:40 +0000
+++ src/core/media/player_skeleton.cpp	2016-08-15 19:28:06 +0000
@@ -471,6 +471,11 @@
     return *d->skeleton.properties.typed_playback_status;
 }
 
+const core::Property<media::AVBackend::Backend>& media::PlayerSkeleton::backend() const
+{
+    return *d->skeleton.properties.typed_backend;
+}
+
 const core::Property<media::Player::LoopStatus>& media::PlayerSkeleton::loop_status() const
 {
     return *d->skeleton.properties.typed_loop_status;
@@ -581,6 +586,11 @@
     return *d->skeleton.properties.typed_playback_status;
 }
 
+core::Property<media::AVBackend::Backend>& media::PlayerSkeleton::backend()
+{
+    return *d->skeleton.properties.typed_backend;
+}
+
 core::Property<bool>& media::PlayerSkeleton::can_play()
 {
     return *d->skeleton.properties.can_play;
 
=== modified file 'src/core/media/player_skeleton.h'
--- src/core/media/player_skeleton.h	2016-06-01 00:43:04 +0000
+++ src/core/media/player_skeleton.h	2016-08-15 19:28:06 +0000
@@ -75,6 +75,7 @@
     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<AVBackend::Backend>& backend() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
     virtual const core::Property<bool>& shuffle() const;
@@ -105,6 +106,7 @@
     // These properties are not exposed to the client, but still need to be
     // able to be settable from within the Player:
     virtual core::Property<PlaybackStatus>& playback_status();
+    virtual core::Property<AVBackend::Backend>& backend();
     virtual core::Property<bool>& can_play();
     virtual core::Property<bool>& can_pause();
     virtual core::Property<bool>& can_seek();
 
=== modified file 'src/core/media/player_stub.cpp'
--- src/core/media/player_stub.cpp	2016-07-19 21:22:18 +0000
+++ src/core/media/player_stub.cpp	2016-08-15 19:28:06 +0000
@@ -54,7 +54,6 @@
                 object(object),
                 key(object->invoke_method_synchronously<mpris::Player::Key, media::Player::PlayerKey>().value()),
                 uuid(uuid),
-                sink_factory(media::video::make_platform_default_sink_factory(key)),
                 properties
                 {
                     // Link the properties from the server side to the client side over the bus
@@ -67,6 +66,7 @@
                     object->get_property<mpris::Player::Properties::IsVideoSource>(),
                     object->get_property<mpris::Player::Properties::IsAudioSource>(),
                     object->get_property<mpris::Player::Properties::TypedPlaybackStatus>(),
+                    object->get_property<mpris::Player::Properties::TypedBackend>(),
                     object->get_property<mpris::Player::Properties::TypedLoopStatus>(),
                     object->get_property<mpris::Player::Properties::PlaybackRate>(),
                     object->get_property<mpris::Player::Properties::Shuffle>(),
@@ -91,6 +91,8 @@
                     object->get_signal<mpris::Player::Signals::Error>()
                 }
     {
+        sink_factory = media::video::make_platform_default_sink_factory(key,
+                                properties.backend->get());
     }
 
     ~Private()
@@ -116,6 +118,7 @@
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::IsAudioSource>> is_audio_source;
 
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::TypedPlaybackStatus>> playback_status;
+        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::TypedBackend>> backend;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::TypedLoopStatus>> loop_status;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackRate>> playback_rate;
         std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Shuffle>> shuffle;
@@ -237,10 +240,12 @@
     const std::string& uuid)
         : d(new Private{parent, service, object, uuid})
 {
+    MH_TRACE("");
 }
 
 media::PlayerStub::~PlayerStub()
 {
+    MH_TRACE("");
 }
 
 std::string media::PlayerStub::uuid() const
@@ -412,6 +417,11 @@
     return *d->properties.playback_status;
 }
 
+const core::Property<media::AVBackend::Backend>& media::PlayerStub::backend() const
+{
+    return *d->properties.backend;
+}
+
 const core::Property<media::Player::LoopStatus>& media::PlayerStub::loop_status() const
 {
     return *d->properties.loop_status;
 
=== modified file 'src/core/media/player_stub.h'
--- src/core/media/player_stub.h	2016-06-01 00:43:04 +0000
+++ src/core/media/player_stub.h	2016-08-15 19:28:06 +0000
@@ -71,6 +71,7 @@
     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<AVBackend::Backend>& backend() const;
     virtual const core::Property<LoopStatus>& loop_status() const;
     virtual const core::Property<PlaybackRate>& playback_rate() const;
     virtual const core::Property<bool>& shuffle() const;
 
=== modified file 'src/core/media/recorder_observer.cpp'
--- src/core/media/recorder_observer.cpp	2014-11-26 09:36:44 +0000
+++ src/core/media/recorder_observer.cpp	2016-08-15 19:28:06 +0000
@@ -16,13 +16,30 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include "core/media/logger/logger.h"
+
+#include <core/media/player.h>
 #include <core/media/recorder_observer.h>
 
 #include <core/media/hybris_recorder_observer.h>
+#include <core/media/stub_recorder_observer.h>
 
 namespace media = core::ubuntu::media;
 
 media::RecorderObserver::Ptr media::make_platform_default_recorder_observer()
 {
-    return media::HybrisRecorderObserver::create();
+    const media::AVBackend::Backend b {media::AVBackend::get_backend_type()};
+    switch (b)
+    {
+        case media::AVBackend::Backend::hybris:
+            return media::HybrisRecorderObserver::create();
+        case media::AVBackend::Backend::none:
+            MH_WARNING(
+                "No video backend selected. Video recording functionality won't work."
+            );
+            return media::StubRecorderObserver::create();
+        default:
+            MH_INFO("Invalid or no A/V backend specified, using \"hybris\" as a default.");
+            return media::HybrisRecorderObserver::create();
+    }
 }
 
=== modified file 'src/core/media/server/server.cpp'
--- src/core/media/server/server.cpp	2016-04-05 19:34:22 +0000
+++ src/core/media/server/server.cpp	2016-08-15 19:28:06 +0000
@@ -58,7 +58,7 @@
             severity = media::Logger::Severity::kFatal;
         else
             std::cerr << "Invalid log level \"" << level
-                << "\", setting to info. Valid options: [trace, debug, info, warning, error, fatal]. "
+                << "\", setting to info. Valid options: [trace, debug, info, warning, error, fatal]."
                 << std::endl;
     }
     else
@@ -71,7 +71,20 @@
 // All platform-specific initialization routines go here.
 void platform_init()
 {
-    decoding_service_init();
+    const media::AVBackend::Backend b {media::AVBackend::get_backend_type()};
+    switch (b)
+    {
+        case media::AVBackend::Backend::hybris:
+            MH_DEBUG("Found hybris backend");
+            decoding_service_init();
+            break;
+        case media::AVBackend::Backend::none:
+            MH_WARNING("No video backend selected. Video functionality won't work.");
+            break;
+        default:
+            MH_INFO("Invalid or no A/V backend specified, using \"hybris\" as a default.");
+            decoding_service_init();
+    }
 }
 }
 #else  // MEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER
 
=== added file 'src/core/media/stub_client_death_observer.cpp'
--- src/core/media/stub_client_death_observer.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/stub_client_death_observer.cpp	2016-08-15 19:28:06 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#include <core/media/stub_client_death_observer.h>
+
+namespace media = core::ubuntu::media;
+
+namespace
+{
+typedef std::pair<media::Player::PlayerKey, std::weak_ptr<media::StubClientDeathObserver>> Holder;
+}
+
+void media::StubClientDeathObserver::on_client_died_cb(void* context)
+{
+    auto holder = static_cast<Holder*>(context);
+
+    if (not holder)
+        return;
+
+    // We check if we are still alive or if we already got killed.
+    if (auto sp = holder->second.lock())
+    {
+        sp->client_with_key_died(holder->first);
+    }
+
+    // And with that, we have reached end of life for our holder object.
+    delete holder;
+}
+
+// Creates an instance of the StubClientDeathObserver.
+media::ClientDeathObserver::Ptr media::StubClientDeathObserver::create()
+{
+    return media::ClientDeathObserver::Ptr{new media::StubClientDeathObserver{}};
+}
+
+media::StubClientDeathObserver::StubClientDeathObserver()
+{
+}
+
+media::StubClientDeathObserver::~StubClientDeathObserver()
+{
+}
+
+void media::StubClientDeathObserver::register_for_death_notifications_with_key(const media::Player::PlayerKey&)
+{
+}
+
+const core::Signal<media::Player::PlayerKey>& media::StubClientDeathObserver::on_client_with_key_died() const
+{
+    return client_with_key_died;
+}
 
=== added file 'src/core/media/stub_client_death_observer.h'
--- src/core/media/stub_client_death_observer.h	1970-01-01 00:00:00 +0000
+++ src/core/media/stub_client_death_observer.h	2016-08-15 19:28:06 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#ifndef CORE_UBUNTU_MEDIA_STUB_CLIENT_DEATH_OBSERVER_H_
+#define CORE_UBUNTU_MEDIA_STUB_CLIENT_DEATH_OBSERVER_H_
+
+#include <core/media/client_death_observer.h>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+// Models functionality to be notified whenever a client
+// of the service goes away, and thus allows us to clean
+// up in that case.
+// Generic empty implementation.
+class StubClientDeathObserver : public ClientDeathObserver,
+                                public std::enable_shared_from_this<StubClientDeathObserver>
+{
+public:
+    // Our static callback that we inject to the hybris world.
+    static void on_client_died_cb(void* context);
+
+    // Creates an instance of the StubClientDeathObserver or throws
+    // if the underlying platform does not support it.
+    static ClientDeathObserver::Ptr create();
+
+    // Make std::unique_ptr happy for forward declared Private internals.
+    ~StubClientDeathObserver();
+
+    // Registers the client with the given key for death notifications.
+    void register_for_death_notifications_with_key(const Player::PlayerKey&) override;
+
+    // Emitted whenever a client dies, reporting the key under which the
+    // respective client was known.
+    const core::Signal<Player::PlayerKey>& on_client_with_key_died() const override;
+
+private:
+    StubClientDeathObserver();
+
+    core::Signal<media::Player::PlayerKey> client_with_key_died;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_STUB_CLIENT_DEATH_OBSERVER_H_
 
=== added file 'src/core/media/stub_recorder_observer.cpp'
--- src/core/media/stub_recorder_observer.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/stub_recorder_observer.cpp	2016-08-15 19:28:06 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#include <core/media/stub_recorder_observer.h>
+
+namespace media = core::ubuntu::media;
+
+media::StubRecorderObserver::StubRecorderObserver()
+ : current_recording_state(media::RecordingState::stopped)
+{
+}
+
+media::StubRecorderObserver::~StubRecorderObserver()
+{
+}
+
+const core::Property<media::RecordingState>& media::StubRecorderObserver::recording_state() const
+{
+    return current_recording_state;
+}
+
+media::RecorderObserver::Ptr media::StubRecorderObserver::create()
+{
+    return media::RecorderObserver::Ptr{new media::StubRecorderObserver{}};
+}
 
=== added file 'src/core/media/stub_recorder_observer.h'
--- src/core/media/stub_recorder_observer.h	1970-01-01 00:00:00 +0000
+++ src/core/media/stub_recorder_observer.h	2016-08-15 19:28:06 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#ifndef CORE_UBUNTU_MEDIA_STUB_RECORDER_OBSERVER_H_
+#define CORE_UBUNTU_MEDIA_STUB_RECORDER_OBSERVER_H_
+
+#include <core/media/recorder_observer.h>
+
+namespace core
+{
+namespace ubuntu
+{
+namespace media
+{
+class StubRecorderObserver : public RecorderObserver
+{
+public:
+    // Creates a new instance of the StubRecorderObserver
+    static RecorderObserver::Ptr create();
+
+    ~StubRecorderObserver();
+
+    // Getable/observable property describing the recording state of the system.
+    const core::Property<RecordingState>& recording_state() const override;
+
+private:
+    StubRecorderObserver();
+
+    core::Property<media::RecordingState> current_recording_state;
+};
+}
+}
+}
+
+#endif // CORE_UBUNTU_MEDIA_STUB_RECORDER_OBSERVER_H_
 
=== modified file 'src/core/media/video/hybris_gl_sink.h'
--- src/core/media/video/hybris_gl_sink.h	2015-01-29 12:12:43 +0000
+++ src/core/media/video/hybris_gl_sink.h	2016-08-15 19:28:06 +0000
@@ -34,7 +34,7 @@
 {
 class HybrisGlSink : public video::Sink
 {
-public:    
+public:
     // Returns a factory functor that allows for creating actual sink instances.
     static std::function<video::Sink::Ptr(std::uint32_t)> factory_for_key(const media::Player::PlayerKey&);
 
 
=== modified file 'src/core/media/video/platform_default_sink.cpp'
--- src/core/media/video/platform_default_sink.cpp	2016-04-05 14:40:47 +0000
+++ src/core/media/video/platform_default_sink.cpp	2016-08-15 19:28:06 +0000
@@ -16,6 +16,8 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+#include "core/media/logger/logger.h"
+
 #include <core/media/video/platform_default_sink.h>
 
 namespace media = core::ubuntu::media;
@@ -56,9 +58,23 @@
 #if defined(MEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER)
 #include <core/media/video/hybris_gl_sink.h>
 
-video::SinkFactory video::make_platform_default_sink_factory(const media::Player::PlayerKey& key)
+video::SinkFactory video::make_platform_default_sink_factory(const media::Player::PlayerKey& key,
+                                                             const media::AVBackend::Backend b)
 {
-    return video::HybrisGlSink::factory_for_key(key);
+    switch (b)
+    {
+        case media::AVBackend::Backend::hybris:
+            MH_DEBUG("Using hybris video sink");
+            return video::HybrisGlSink::factory_for_key(key);
+        case media::AVBackend::Backend::none:
+            MH_WARNING(
+                "No video backend selected. Video rendering functionality won't work."
+            );
+            return [](std::uint32_t) { return video::Sink::Ptr{}; };
+        default:
+            MH_INFO("Invalid or no A/V backend specified, using \"hybris\" as a default.");
+            return video::HybrisGlSink::factory_for_key(key);
+    }
 }
 #else  // MEDIA_HUB_HAVE_HYBRIS_MEDIA_COMPAT_LAYER
 video::SinkFactory video::make_platform_default_sink_factory(const media::Player::PlayerKey&)
 
=== modified file 'src/core/media/video/platform_default_sink.h'
--- src/core/media/video/platform_default_sink.h	2015-01-29 12:12:43 +0000
+++ src/core/media/video/platform_default_sink.h	2016-08-15 19:28:06 +0000
@@ -35,7 +35,8 @@
 // A functor that allows for creating actual sinks given a texture id.
 typedef std::function<Sink::Ptr(std::uint32_t)> SinkFactory;
 // Returns the platform default sink factory for the player instance identified by the given key.
-SinkFactory make_platform_default_sink_factory(const Player::PlayerKey& key);
+SinkFactory make_platform_default_sink_factory(const Player::PlayerKey& key,
+                                               const AVBackend::Backend b);
 }
 }
 }
 
=== modified file 'tests/acceptance-tests/service.cpp'
--- tests/acceptance-tests/service.cpp	2015-11-02 21:14:29 +0000
+++ tests/acceptance-tests/service.cpp	2016-08-15 19:28:06 +0000
@@ -68,6 +68,14 @@
 }
 }
 
+TEST(MediaService, service_is_running)
+{
+    auto service = media::Service::Client::instance();
+    auto session = service->create_session(media::Player::Client::default_configuration());
+    EXPECT_TRUE(service != nullptr);
+    EXPECT_TRUE(session != nullptr);
+}
+
 TEST(MediaService, move_track_in_tracklist_works)
 {
     auto service = media::Service::Client::instance();
 
=== modified file 'tests/unit-tests/test-gstreamer-engine.cpp'
--- tests/unit-tests/test-gstreamer-engine.cpp	2016-06-30 23:23:50 +0000
+++ tests/unit-tests/test-gstreamer-engine.cpp	2016-08-15 19:28:06 +0000
@@ -103,9 +103,10 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    static const bool do_pipeline_reset = true;
+    static const bool do_pipeline_reset = false;
     EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
-    EXPECT_TRUE(engine.play());
+    static const bool use_main_context = true;
+    EXPECT_TRUE(engine.play(use_main_context));
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
                     std::chrono::seconds{4}));
@@ -145,15 +146,16 @@
                     std::ref(wst),
                     std::placeholders::_1));
 
-    static const bool do_pipeline_reset = true;
+    static const bool do_pipeline_reset = false;
     EXPECT_TRUE(engine.open_resource_for_uri(test_file_uri, do_pipeline_reset));
-    EXPECT_TRUE(engine.play());
+    static const bool use_main_context = true;
+    EXPECT_TRUE(engine.play(use_main_context));
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
                     std::chrono::milliseconds{4000}));
 
     EXPECT_TRUE(wst.wait_for_state_for(
-                    core::ubuntu::media::Engine::State::ready,
+                    core::ubuntu::media::Engine::State::stopped,
                     std::chrono::seconds{10}));
 }
 
@@ -207,7 +209,8 @@
                     std::placeholders::_1));
 
     EXPECT_TRUE(engine.open_resource_for_uri(test_audio_uri, headers));
-    EXPECT_TRUE(engine.play());
+    static const bool use_main_context = true;
+    EXPECT_TRUE(engine.play(use_main_context));
     EXPECT_TRUE(wst.wait_for_state_for(
                     core::ubuntu::media::Engine::State::playing,
                     std::chrono::seconds{10}));