LockScreenAcceleratorController: use key::Grabber to handle allowed bindings

This makes U-S-D to handle key events, without having to add some extra custom code inside the lockscreen. It's all just about whitelisting the wanted values. (LP: #1438754) (bzr r4131)

11 files changed, 170 insertions, 149 deletions

diff --git a/lockscreen/LockScreenAcceleratorController.cpp b/lockscreen/LockScreenAcceleratorController.cpp
index 3ff9d2843..adc2de355 100644
--- a/lockscreen/LockScreenAcceleratorController.cpp
+++ b/lockscreen/LockScreenAcceleratorController.cpp
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2014 Canonical Ltd
+ * Copyright (C) 2014-2016 Canonical Ltd
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
@@ -15,10 +15,12 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * Authored by: William Hua <william.hua@canonical.com>
+ * Marco Trevisan <marco.trevisan@canonical.com>
 */
 
 #include "LockScreenAcceleratorController.h"
 
+#include <NuxCore/Logger.h>
 #include <UnityCore/GLibDBusProxy.h>
 
 namespace unity
@@ -28,157 +30,150 @@ namespace lockscreen
 
 namespace
 {
-const char* const MEDIA_KEYS_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys";
-const char* const MEDIA_KEYS_KEY_VOLUME_MUTE = "volume-mute";
-const char* const MEDIA_KEYS_KEY_VOLUME_DOWN = "volume-down";
-const char* const MEDIA_KEYS_KEY_VOLUME_UP = "volume-up";
-
-const char* const POWER_SCHEMA = "org.gnome.settings-daemon.plugins.power";
-const char* const SUSPEND_BUTTON_ACTION_KEY = "button-suspend";
-const char* const SLEEP_BUTTON_ACTION_KEY = "button-sleep";
-const char* const HIBERNATE_BUTTON_ACTION_KEY = "button-hibernate";
-const char* const POWER_BUTTON_ACTION_KEY = "button-power";
-const char* const POWER_KEY_SUSPEND = "XF86Suspend";
-const char* const POWER_KEY_SLEEP = "XF86Sleep";
-const char* const POWER_KEY_HIBERNATE = "XF86Hibernate";
-const char* const POWER_KEY_POWEROFF = "XF86PowerOff";
-
-const char* const INPUT_SWITCH_SCHEMA = "org.gnome.desktop.wm.keybindings";
-const char* const INPUT_SWITCH_KEY_PREVIOUS_SOURCE = "switch-input-source-backward";
-const char* const INPUT_SWITCH_KEY_NEXT_SOURCE = "switch-input-source";
-
-const char* const INDICATOR_INTERFACE_ACTIONS = "org.gtk.Actions";
-const char* const INDICATOR_METHOD_ACTIVATE = "Activate";
-const char* const INDICATOR_SOUND_BUS_NAME = "com.canonical.indicator.sound";
-const char* const INDICATOR_SOUND_OBJECT_PATH = "/com/canonical/indicator/sound";
-const char* const INDICATOR_SOUND_ACTION_MUTE = "mute";
-const char* const INDICATOR_SOUND_ACTION_SCROLL = "scroll";
-const char* const INDICATOR_KEYBOARD_BUS_NAME = "com.canonical.indicator.keyboard";
-const char* const INDICATOR_KEYBOARD_OBJECT_PATH = "/com/canonical/indicator/keyboard";
-const char* const INDICATOR_KEYBOARD_ACTION_SCROLL = "locked_scroll";
-
-void ActivateIndicator(std::string const& bus_name,
- std::string const& object_path,
- std::string const& action_name,
- glib::Variant const& parameters = glib::Variant())
+DECLARE_LOGGER(logger, "unity.lockscreen.accelerator.controller");
+
+const std::string MEDIA_KEYS_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys";
+const std::vector<std::string> ALLOWED_MEDIA_KEYS = {
+ "logout",
+ "magnifier",
+ "on-screen-keyboard",
+ "magnifier-zoom-in",
+ "screenreader",
+ "pause",
+ "stop",
+ "toggle-contrast",
+ "video-out",
+ "volume-down",
+ "volume-mute",
+ "volume-up",
+};
+
+const std::string WM_KEYS_SCHEMA = "org.gnome.desktop.wm.keybindings";
+const std::vector<std::string> ALLOWED_WM_KEYS = {
+ "switch-input-source",
+ "switch-input-source-backward",
+};
+
+const std::vector<std::string> ALLOWED_XF86_KEYS = {
+ "XF86ScreenSaver",
+ "XF86Sleep",
+ "XF86Standby",
+ "XF86Suspend",
+ "XF86Hibernate",
+ "XF86PowerOff",
+ "XF86MonBrightnessUp",
+ "XF86MonBrightnessDown",
+ "XF86KbdBrightnessUp",
+ "XF86KbdBrightnessDown",
+ "XF86KbdLightOnOff",
+ "XF86AudioMicMute",
+ "XF86Touchpad",
+};
+
+bool IsKeyBindingAllowed(std::string const& key)
 {
- GVariantBuilder builder;
+ if (std::find(begin(ALLOWED_XF86_KEYS), end(ALLOWED_XF86_KEYS), key) != end(ALLOWED_XF86_KEYS))
+ return true;
 
- g_variant_builder_init(&builder, G_VARIANT_TYPE("(sava{sv})"));
- g_variant_builder_add(&builder, "s", action_name.c_str());
+ glib::Object<GSettings> media_settings(g_settings_new(MEDIA_KEYS_SCHEMA.c_str()));
+ Accelerator key_accelerator(key);
 
- if (parameters)
- g_variant_builder_add_parsed(&builder, "[%v]", static_cast<GVariant*>(parameters));
- else
- g_variant_builder_add_parsed(&builder, "@av []");
+ for (auto const& setting : ALLOWED_MEDIA_KEYS)
+ {
+ Accelerator media_key(glib::String(g_settings_get_string(media_settings, setting.c_str())).Str());
+ if (media_key == key_accelerator)
+ return true;
+ }
 
- g_variant_builder_add_parsed(&builder, "@a{sv} []");
+ glib::Object<GSettings> wm_settings(g_settings_new(WM_KEYS_SCHEMA.c_str()));
 
- auto proxy = std::make_shared<glib::DBusProxy>(bus_name, object_path, INDICATOR_INTERFACE_ACTIONS);
- proxy->CallBegin(INDICATOR_METHOD_ACTIVATE, g_variant_builder_end(&builder), [proxy] (GVariant*, glib::Error const&) {});
-}
+ for (auto const& setting : ALLOWED_WM_KEYS)
+ {
+ glib::Variant accels(g_settings_get_value(wm_settings, setting.c_str()), glib::StealRef());
+ auto children = g_variant_n_children(accels);
 
-void MuteIndicatorSound()
-{
- ActivateIndicator(INDICATOR_SOUND_BUS_NAME,
- INDICATOR_SOUND_OBJECT_PATH,
- INDICATOR_SOUND_ACTION_MUTE);
-}
+ if (children > 0)
+ {
+ glib::String value;
 
-void ScrollIndicatorSound(int offset)
-{
- ActivateIndicator(INDICATOR_SOUND_BUS_NAME,
- INDICATOR_SOUND_OBJECT_PATH,
- INDICATOR_SOUND_ACTION_SCROLL,
- g_variant_new_int32(offset));
-}
+ for (auto i = 0u; i < children; ++i)
+ {
+ g_variant_get_child(accels, 0, "s", &value);
 
-void ScrollIndicatorKeyboard(int offset)
-{
- ActivateIndicator(INDICATOR_KEYBOARD_BUS_NAME,
- INDICATOR_KEYBOARD_OBJECT_PATH,
- INDICATOR_KEYBOARD_ACTION_SCROLL,
- g_variant_new_int32(-offset));
-}
+ if (Accelerator(value.Str()) == key_accelerator)
+ return true;
+ }
+ }
+ }
 
-void PowerAction(session::Manager::Ptr const& session, const char *action_key)
-{
- glib::Object<GSettings> settings(g_settings_new(POWER_SCHEMA));
- auto const& action = glib::String(g_settings_get_string(settings, action_key)).Str();
-
- if (action == "interactive")
- session->shutdown_requested.emit(session->HasInhibitors());
- else if (action == "shutdown")
- session->reboot_requested.emit(session->HasInhibitors());
- else if (action == "suspend")
- session->Suspend();
- else if (action == "hibernate")
- session->Hibernate();
- else if (action == "blank")
- session->ScreenSaverActivate();
+ return false;
 }
+
 } // namespace
 
-AcceleratorController::AcceleratorController(session::Manager::Ptr const& session)
+AcceleratorController::AcceleratorController(key::Grabber::Ptr const& key_grabber)
 : accelerators_(new Accelerators)
 {
- auto settings = glib::Object<GSettings>(g_settings_new(MEDIA_KEYS_SCHEMA));
-
- auto accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_MUTE)));
- accelerator->activated.connect(std::function<void()>(MuteIndicatorSound));
- accelerators_->Add(accelerator);
+ for (auto const& action : key_grabber->GetActions())
+ AddAction(action);
 
- accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_DOWN)));
- accelerator->activated.connect(std::bind(ScrollIndicatorSound, -1));
- accelerators_->Add(accelerator);
+ key_grabber->action_added.connect(sigc::mem_fun(this, &AcceleratorController::AddAction));
+ key_grabber->action_removed.connect(sigc::mem_fun(this, &AcceleratorController::RemoveAction));
+}
 
- accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_UP)));
- accelerator->activated.connect(std::bind(ScrollIndicatorSound, +1));
- accelerators_->Add(accelerator);
+void AcceleratorController::AddAction(CompAction const& action)
+{
+ if (action.type() != CompAction::BindingTypeKey)
+ return;
 
- accelerator = std::make_shared<Accelerator>(POWER_KEY_SUSPEND);
- accelerator->activated.connect(std::bind(PowerAction, session, SUSPEND_BUTTON_ACTION_KEY));
- accelerators_->Add(accelerator);
+ auto const& key = action.keyToString();
 
- accelerator = std::make_shared<Accelerator>(POWER_KEY_SLEEP);
- accelerator->activated.connect(std::bind(PowerAction, session, SLEEP_BUTTON_ACTION_KEY));
- accelerators_->Add(accelerator);
+ if (!IsKeyBindingAllowed(key))
+ {
+ LOG_DEBUG(logger) << "Action not allowed " << key;
+ return;
+ }
 
- accelerator = std::make_shared<Accelerator>(POWER_KEY_HIBERNATE);
- accelerator->activated.connect(std::bind(PowerAction, session, HIBERNATE_BUTTON_ACTION_KEY));
+ auto accelerator = std::make_shared<Accelerator>(key);
+ accelerator->activated.connect(sigc::bind(sigc::mem_fun(this, &AcceleratorController::OnActionActivated), action));
 accelerators_->Add(accelerator);
+ actions_accelerators_.push_back({action, accelerator});
 
- accelerator = std::make_shared<Accelerator>(POWER_KEY_POWEROFF);
- accelerator->activated.connect(std::bind(PowerAction, session, POWER_BUTTON_ACTION_KEY));
- accelerators_->Add(accelerator);
+ LOG_DEBUG(logger) << "Action added " << key;
+}
 
- settings = glib::Object<GSettings>(g_settings_new(INPUT_SWITCH_SCHEMA));
+void AcceleratorController::RemoveAction(CompAction const& action)
+{
+ if (action.type() != CompAction::BindingTypeKey)
+ return;
 
- auto variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_PREVIOUS_SOURCE), glib::StealRef());
+ LOG_DEBUG(logger) << "Removing action " << action.keyToString();
 
- if (g_variant_n_children(variant) > 0)
+ for (auto it = begin(actions_accelerators_); it != end(actions_accelerators_);)
 {
- const gchar* string;
-
- g_variant_get_child(variant, 0, "&s", &string);
-
- accelerator = std::make_shared<Accelerator>(string);
- accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, -1));
- accelerators_->Add(accelerator);
+ if (it->first == action)
+ {
+ accelerators_->Remove(it->second);
+ it = actions_accelerators_.erase(it);
+ }
+ else
+ {
+ ++it;
+ }
 }
+}
 
- variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_NEXT_SOURCE), glib::StealRef());
+void AcceleratorController::OnActionActivated(CompAction& action)
+{
+ LOG_DEBUG(logger) << "Activating action " << action.keyToString();
 
- if (g_variant_n_children(variant) > 0)
- {
- const gchar* string;
+ CompOption::Vector options;
 
- g_variant_get_child(variant, 0, "&s", &string);
+ if (action.state() & CompAction::StateInitKey)
+ action.initiate()(&action, 0, options);
 
- accelerator = std::make_shared<Accelerator>(string);
- accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, +1));
- accelerators_->Add(accelerator);
- }
+ if (action.state() & CompAction::StateTermKey)
+ action.terminate()(&action, CompAction::StateTermTapped, options);
 }
 
 Accelerators::Ptr const& AcceleratorController::GetAccelerators() const
diff --git a/lockscreen/LockScreenAcceleratorController.h b/lockscreen/LockScreenAcceleratorController.h
index 1bc63f8d0..c4c5a54f1 100644
--- a/lockscreen/LockScreenAcceleratorController.h
+++ b/lockscreen/LockScreenAcceleratorController.h
@@ -20,7 +20,7 @@
 #ifndef UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
 #define UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
 
-#include "UnityCore/SessionManager.h"
+#include "unity-shared/KeyGrabber.h"
 #include "LockScreenAccelerators.h"
 
 namespace unity
@@ -28,16 +28,21 @@ namespace unity
 namespace lockscreen
 {
 
-class AcceleratorController
+class AcceleratorController : public sigc::trackable
 {
 public:
 typedef std::shared_ptr<AcceleratorController> Ptr;
 
- AcceleratorController(session::Manager::Ptr const&);
+ AcceleratorController(key::Grabber::Ptr const&);
 
 Accelerators::Ptr const& GetAccelerators() const;
 
 private:
+ void AddAction(CompAction const&);
+ void RemoveAction(CompAction const&);
+ void OnActionActivated(CompAction&);
+
+ std::vector<std::pair<CompAction, Accelerator::Ptr>> actions_accelerators_;
 Accelerators::Ptr accelerators_;
 };
 
diff --git a/lockscreen/LockScreenAccelerators.cpp b/lockscreen/LockScreenAccelerators.cpp
index f3f4a4bc7..5fd2a3af0 100644
--- a/lockscreen/LockScreenAccelerators.cpp
+++ b/lockscreen/LockScreenAccelerators.cpp
@@ -417,6 +417,11 @@ Accelerators::Accelerators()
 {
 }
 
+Accelerators::Vector Accelerators::GetAccelerators() const
+{
+ return accelerators_;
+}
+
 void Accelerators::Clear()
 {
 accelerators_.clear();
diff --git a/lockscreen/LockScreenAccelerators.h b/lockscreen/LockScreenAccelerators.h
index 7e8408252..dbb142a87 100644
--- a/lockscreen/LockScreenAccelerators.h
+++ b/lockscreen/LockScreenAccelerators.h
@@ -69,9 +69,11 @@ class Accelerators
 {
 public:
 typedef std::shared_ptr<Accelerators> Ptr;
+ typedef std::vector<Accelerator::Ptr> Vector;
 
 Accelerators();
 
+ Accelerators::Vector GetAccelerators() const;
 void Clear();
 
 void Add(Accelerator::Ptr const& accelerator);
@@ -83,7 +85,7 @@ public:
 unsigned int modifiers);
 
 private:
- std::vector<Accelerator::Ptr> accelerators_;
+ Accelerators::Vector accelerators_;
 
 PressedState pressed_state_;
 };
diff --git a/lockscreen/LockScreenController.cpp b/lockscreen/LockScreenController.cpp
index 68c847ec8..b4a288eb9 100644
--- a/lockscreen/LockScreenController.cpp
+++ b/lockscreen/LockScreenController.cpp
@@ -54,12 +54,14 @@ DECLARE_LOGGER(logger, "unity.lockscreen");
 
 Controller::Controller(DBusManager::Ptr const& dbus_manager,
 session::Manager::Ptr const& session_manager,
+ key::Grabber::Ptr const& key_grabber,
 UpstartWrapper::Ptr const& upstart_wrapper,
 ShieldFactoryInterface::Ptr const& shield_factory,
 bool test_mode)
 : opacity([this] { return fade_animator_.GetCurrentValue(); })
 , dbus_manager_(dbus_manager)
 , session_manager_(session_manager)
+ , key_grabber_(key_grabber)
 , upstart_wrapper_(upstart_wrapper)
 , shield_factory_(shield_factory)
 , suspend_inhibitor_manager_(std::make_shared<SuspendInhibitorManager>())
@@ -459,7 +461,7 @@ void Controller::LockScreen()
 indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
 upstart_wrapper_->Emit("desktop-lock");
 
- accelerator_controller_ = std::make_shared<AcceleratorController>(session_manager_);
+ accelerator_controller_ = std::make_shared<AcceleratorController>(key_grabber_);
 auto activate_key = WindowManager::Default().activate_indicators_key();
 auto accelerator = std::make_shared<Accelerator>(activate_key.second, 0, activate_key.first);
 accelerator->activated.connect(std::bind(std::mem_fn(&Controller::ActivatePanel), this));
diff --git a/lockscreen/LockScreenController.h b/lockscreen/LockScreenController.h
index 054b90d65..c5f47ef13 100644
--- a/lockscreen/LockScreenController.h
+++ b/lockscreen/LockScreenController.h
@@ -30,6 +30,7 @@
 #include "SuspendInhibitorManager.h"
 #include "ScreenSaverDBusManager.h"
 #include "unity-shared/BackgroundEffectHelper.h"
+#include "unity-shared/KeyGrabber.h"
 #include "unity-shared/UpstartWrapper.h"
 
 namespace unity
@@ -44,7 +45,7 @@ class Controller : public sigc::trackable
 public:
 typedef std::shared_ptr<Controller> Ptr;
 
- Controller(DBusManager::Ptr const&, session::Manager::Ptr const&,
+ Controller(DBusManager::Ptr const&, session::Manager::Ptr const&, key::Grabber::Ptr const&,
 UpstartWrapper::Ptr const& upstart_wrapper = std::make_shared<UpstartWrapper>(),
 ShieldFactoryInterface::Ptr const& shield_factory = std::make_shared<ShieldFactory>(),
 bool test_mode = false);
@@ -84,6 +85,7 @@ private:
 
 DBusManager::Ptr dbus_manager_;
 session::Manager::Ptr session_manager_;
+ key::Grabber::Ptr key_grabber_;
 indicator::Indicators::Ptr indicators_;
 AcceleratorController::Ptr accelerator_controller_;
 UpstartWrapper::Ptr upstart_wrapper_;
diff --git a/plugins/unityshell/src/unityshell.cpp b/plugins/unityshell/src/unityshell.cpp
index 70bf12937..9aa9cdad0 100644
--- a/plugins/unityshell/src/unityshell.cpp
+++ b/plugins/unityshell/src/unityshell.cpp
@@ -4081,24 +4081,24 @@ void UnityScreen::InitUnityComponents()
 ShowFirstRunHints();
 
 // Setup Session Controller
- auto manager = std::make_shared<session::GnomeManager>();
- manager->lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
- manager->prompt_lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
- manager->locked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenLocked));
- manager->unlocked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenUnlocked));
- session_dbus_manager_ = std::make_shared<session::DBusManager>(manager);
- session_controller_ = std::make_shared<session::Controller>(manager);
+ auto session = std::make_shared<session::GnomeManager>();
+ session->lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
+ session->prompt_lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
+ session->locked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenLocked));
+ session->unlocked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenUnlocked));
+ session_dbus_manager_ = std::make_shared<session::DBusManager>(session);
+ session_controller_ = std::make_shared<session::Controller>(session);
 LOG_INFO(logger) << "InitUnityComponents-Session " << timer.ElapsedSeconds() << "s";
 Introspectable::AddChild(session_controller_.get());
 
 // Setup Lockscreen Controller
- screensaver_dbus_manager_ = std::make_shared<lockscreen::DBusManager>(manager);
- lockscreen_controller_ = std::make_shared<lockscreen::Controller>(screensaver_dbus_manager_, manager);
+ screensaver_dbus_manager_ = std::make_shared<lockscreen::DBusManager>(session);
+ lockscreen_controller_ = std::make_shared<lockscreen::Controller>(screensaver_dbus_manager_, session, menus_->KeyGrabber());
 UpdateActivateIndicatorsKey();
 LOG_INFO(logger) << "InitUnityComponents-Lockscreen " << timer.ElapsedSeconds() << "s";
 
 if (g_file_test((DesktopUtilities::GetUserRuntimeDirectory()+local::LOCKED_STAMP).c_str(), G_FILE_TEST_EXISTS))
- manager->PromptLockScreen();
+ session->PromptLockScreen();
 
 auto on_launcher_size_changed = [this] (nux::Area* area, int w, int h) {
 /* The launcher geometry includes 1px used to draw the right/top margin
diff --git a/tests/test_lockscreen_controller.cpp b/tests/test_lockscreen_controller.cpp
index 3fcdf520b..d1c5af5fa 100644
--- a/tests/test_lockscreen_controller.cpp
+++ b/tests/test_lockscreen_controller.cpp
@@ -33,6 +33,7 @@ using namespace testing;
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UScreen.h"
+#include "mock_key_grabber.h"
 #include "test_mock_session_manager.h"
 #include "test_uscreen_mock.h"
 #include "test_utils.h"
@@ -80,19 +81,21 @@ struct TestLockScreenController : Test
 TestLockScreenController()
 : animation_controller(tick_source)
 , session_manager(std::make_shared<NiceMock<session::MockManager>>())
+ , key_grabber(std::make_shared<key::MockGrabber::Nice>())
 , dbus_manager(std::make_shared<DBusManager>(session_manager))
 , upstart_wrapper(std::make_shared<UpstartWrapper>())
 , shield_factory(std::make_shared<ShieldFactoryMock>())
- , controller(dbus_manager, session_manager, upstart_wrapper, shield_factory)
+ , controller(dbus_manager, session_manager, key_grabber, upstart_wrapper, shield_factory)
 {}
 
 struct ControllerWrap : Controller
 {
 ControllerWrap(DBusManager::Ptr const& dbus_manager,
 session::Manager::Ptr const& session_manager,
+ key::Grabber::Ptr const& key_grabber,
 UpstartWrapper::Ptr const& upstart_wrapper,
 ShieldFactoryInterface::Ptr const& shield_factory)
- : Controller(dbus_manager, session_manager, upstart_wrapper, shield_factory, /* test_mode */ true)
+ : Controller(dbus_manager, session_manager, key_grabber, upstart_wrapper, shield_factory, /* test_mode */ true)
 {}
 
 using Controller::shields_;
@@ -107,6 +110,7 @@ struct TestLockScreenController : Test
 unity::panel::Style panel_style;
 unity::lockscreen::Settings lockscreen_settings;
 session::MockManager::Ptr session_manager;
+ key::MockGrabber::Ptr key_grabber;
 DBusManager::Ptr dbus_manager;
 unity::UpstartWrapper::Ptr upstart_wrapper;
 
@@ -123,7 +127,7 @@ TEST_F(TestLockScreenController, DisconnectUScreenSignalsOnDestruction)
 {
 size_t before = uscreen.changed.size();
 {
- Controller dummy(dbus_manager, session_manager);
+ Controller dummy(dbus_manager, session_manager, key_grabber);
 }
 ASSERT_EQ(before, uscreen.changed.size());
 
@@ -135,7 +139,7 @@ TEST_F(TestLockScreenController, DisconnectSessionManagerSignalsOnDestruction)
 {
 size_t before = session_manager->unlock_requested.size();
 {
- Controller dummy(dbus_manager, session_manager);
+ Controller dummy(dbus_manager, session_manager, key_grabber);
 }
 ASSERT_EQ(before, session_manager->unlock_requested.size());
 
diff --git a/unity-shared/GnomeKeyGrabber.cpp b/unity-shared/GnomeKeyGrabber.cpp
index 0bb8c2d0e..a9f82842e 100644
--- a/unity-shared/GnomeKeyGrabber.cpp
+++ b/unity-shared/GnomeKeyGrabber.cpp
@@ -70,8 +70,9 @@ namespace testing
 std::string const DBUS_NAME = "com.canonical.Unity.Test.GnomeKeyGrabber";
 }
 
-GnomeGrabber::Impl::Impl(bool test_mode)
- : screen_(screen)
+GnomeGrabber::Impl::Impl(Grabber* parent, bool test_mode)
+ : parent_(parent)
+ , screen_(screen)
 , shell_server_(test_mode ? testing::DBUS_NAME : shell::DBUS_NAME)
 , settings_(g_settings_new(SETTINGS_NAME.c_str()))
 , current_action_id_(0)
@@ -123,6 +124,7 @@ bool GnomeGrabber::Impl::AddAction(CompAction const& action, uint32_t& action_id
 actions_ids_.push_back(action_id);
 actions_.push_back(action);
 actions_customers_.push_back(1);
+ parent_->action_added.emit(action);
 return true;
 }
 
@@ -178,6 +180,7 @@ bool GnomeGrabber::Impl::RemoveActionByIndex(size_t index)
 LOG_DEBUG(logger) << "RemoveAction (\"" << action->keyToString() << "\")";
 
 screen_->removeAction(action);
+ parent_->action_removed.emit(*action);
 actions_.erase(actions_.begin() + index);
 actions_ids_.erase(actions_ids_.begin() + index);
 actions_customers_.erase(actions_customers_.begin() + index);
@@ -259,7 +262,6 @@ uint32_t GnomeGrabber::Impl::GrabDBusAccelerator(std::string const& owner, std::
 action.setState(CompAction::StateInitKey | CompAction::StateTermKey);
 action.setTerminate([this, action_id](CompAction* action, CompAction::State state, CompOption::Vector& options) {
 auto key = action->keyToString();
-
 LOG_DEBUG(logger) << "released \"" << key << "\"";
 
 if (state & CompAction::StateTermTapped)
@@ -353,11 +355,11 @@ void GnomeGrabber::Impl::UpdateWhitelist()
 // Public implementation
 
 GnomeGrabber::GnomeGrabber()
- : impl_(new Impl())
+ : impl_(new Impl(this))
 {}
 
 GnomeGrabber::GnomeGrabber(TestMode const& dummy)
- : impl_(new Impl(true))
+ : impl_(new Impl(this, true))
 {}
 
 GnomeGrabber::~GnomeGrabber()
diff --git a/unity-shared/GnomeKeyGrabberImpl.h b/unity-shared/GnomeKeyGrabberImpl.h
index b75b33738..650d1eb63 100644
--- a/unity-shared/GnomeKeyGrabberImpl.h
+++ b/unity-shared/GnomeKeyGrabberImpl.h
@@ -37,7 +37,7 @@ namespace key
 
 struct GnomeGrabber::Impl
 {
- Impl(bool test_mode = false);
+ Impl(Grabber*, bool test_mode = false);
 ~Impl();
 
 uint32_t NextActionID();
@@ -55,9 +55,9 @@ struct GnomeGrabber::Impl
 void ActivateDBusAction(CompAction const& action, uint32_t id, uint32_t device, uint32_t timestamp) const;
 
 bool IsActionPostponed(CompAction const& action) const;
-
 void UpdateWhitelist();
 
+ Grabber* parent_;
 CompScreen* screen_;
 
 glib::DBusServer shell_server_;
diff --git a/unity-shared/KeyGrabber.h b/unity-shared/KeyGrabber.h
index 0688a9c4f..cce75f578 100644
--- a/unity-shared/KeyGrabber.h
+++ b/unity-shared/KeyGrabber.h
@@ -21,6 +21,7 @@
 #define __UNITY_KEY_GRABBER__
 
 #include <core/core.h>
+#include <sigc++/signal.h>
 
 namespace unity
 {
@@ -36,6 +37,9 @@ public:
 virtual bool RemoveAction(CompAction const&) = 0;
 virtual bool RemoveAction(uint32_t id) = 0;
 
+ sigc::signal<void, CompAction const&> action_added;
+ sigc::signal<void, CompAction const&> action_removed;
+
 virtual CompAction::Vector& GetActions() = 0;
 };