Merge lp:~ricmm/media-hub/keep-display-recording-1362658 into lp:media-hub

[Ricardo Mendoza]

Make use of MediaRecorderObserver interface from hybris to register as listeners for recording operations, so that we can then decide whether to hold a screen lock or not.

[Jim Hodapp (jhodapp)]

Looks good, thanks man!

review: Approve (code)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:71
http://jenkins.qa.ubuntu.com/job/media-hub-ci/144/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-utopic-amd64-ci/86/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-utopic-armhf-ci/85/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/media-hub-utopic-i386-ci/84/console

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

review: Needs Fixing (continuous-integration)

[Ricardo Salveti (rsalveti)]

LGTM, works as expected.

review: Approve

=== modified file 'debian/control'
--- debian/control	2014-08-28 07:17:42 +0000
+++ debian/control	2014-10-15 14:22:19 +0000
@@ -22,7 +22,7 @@
                libdbus-1-dev,
                libdbus-cpp-dev (>= 4.0.0),
                libgoogle-glog-dev,
-               libhybris-dev (>=0.1.0+git20131207+e452e83-0ubuntu13),
+               libhybris-dev (>=0.1.0+git20131207+e452e83-0ubuntu28),
                libprocess-cpp-dev,
                libproperties-cpp-dev,
                gstreamer1.0-libav,
 
=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2014-09-25 17:23:40 +0000
+++ src/core/media/service_implementation.cpp	2014-10-15 14:22:19 +0000
@@ -30,6 +30,10 @@
 #include <memory>
 #include <thread>
 
+#include "util/timeout.h"
+#include "unity_screen_service.h"
+#include <hybris/media/media_recorder_layer.h>
+
 namespace media = core::ubuntu::media;
 
 using namespace std;
@@ -38,7 +42,8 @@
 {
     Private()
         : resume_key(std::numeric_limits<std::uint32_t>::max()),
-          keep_alive(io_service)
+          keep_alive(io_service),
+          disp_cookie(0)
     {
         bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::session));
         bus->install_executor(dbus::asio::make_executor(bus, io_service));
@@ -53,6 +58,16 @@
         indicator_power_session = stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/indicator/power/Battery"));
         power_level = indicator_power_session->get_property<core::IndicatorPower::PowerLevel>();
         is_warning = indicator_power_session->get_property<core::IndicatorPower::IsWarning>();
+
+        // Obtain session with Unity.Screen so that we request state when doing recording
+        auto bus = std::shared_ptr<dbus::Bus>(new dbus::Bus(core::dbus::WellKnownBus::system));
+        bus->install_executor(dbus::asio::make_executor(bus));
+
+        auto uscreen_stub_service = dbus::Service::use_service(bus, dbus::traits::Service<core::UScreen>::interface_name());
+        uscreen_session = uscreen_stub_service->object_for_path(dbus::types::ObjectPath("/com/canonical/Unity/Screen"));
+
+        observer = android_media_recorder_observer_new();
+        android_media_recorder_observer_set_cb(observer, &Private::media_recording_started_callback, this);
     }
 
     ~Private()
@@ -63,6 +78,42 @@
             worker.join();
     }
 
+    void media_recording_started(bool started)
+    {
+        if (uscreen_session == nullptr)
+            return;
+
+        if (started)
+        {
+            if (disp_cookie > 0)
+                return;
+
+            auto result = uscreen_session->invoke_method_synchronously<core::UScreen::keepDisplayOn, int>();
+            if (result.is_error())
+                throw std::runtime_error(result.error().print());
+            disp_cookie = result.value();
+        }
+        else
+        {
+            if (disp_cookie != -1)
+            {
+                timeout(4000, true, [this](){
+                    this->uscreen_session->invoke_method_synchronously<core::UScreen::removeDisplayOnRequest, void>(this->disp_cookie);
+                    this->disp_cookie = -1;
+                });
+            }
+        }
+    }
+
+    static void media_recording_started_callback(bool started, void *context)
+    {
+        if (context == nullptr)
+            return;
+
+        auto p = static_cast<Private*>(context);
+        p->media_recording_started(started);
+    }
+
     // This holds the key of the multimedia role Player instance that was paused
     // when the battery level reached 10% or 5%
     media::Player::PlayerKey resume_key;
@@ -73,6 +124,9 @@
     std::shared_ptr<dbus::Object> indicator_power_session;
     std::shared_ptr<core::dbus::Property<core::IndicatorPower::PowerLevel>> power_level;
     std::shared_ptr<core::dbus::Property<core::IndicatorPower::IsWarning>> is_warning;
+    int disp_cookie;
+    std::shared_ptr<dbus::Object> uscreen_session;
+    MediaRecorderObserver *observer;
 };
 
 media::ServiceImplementation::ServiceImplementation() : d(new Private())