Merge lp:~andreas-pokorny/mir/store-device-config into lp:mir

[Andreas Pokorny]

Store device configurations and device ids

With this change previous configurations of input devices are restored when they reappear.

Store device ids of removed devices to restore them after a vt-switch.

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:4070
https://mir-jenkins.ubuntu.com/job/mir-ci/3121/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/4189/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4276
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4266
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4266
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4266
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4216/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4216
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4216/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4216
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4216/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4216
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4216/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4216
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4216/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4216
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4216/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3121/rebuild

review: Needs Fixing (continuous-integration)

[Mir CI Bot (mir-ci-bot)]

PASSED: Continuous integration, rev:4072
https://mir-jenkins.ubuntu.com/job/mir-ci/3162/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/4243
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4330
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4320
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4320
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4320
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4270
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=zesty/4270/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4270
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/4270/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4270
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=zesty/4270/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4270
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/4270/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4270
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/4270/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4270
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/4270/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3162/rebuild

review: Approve (continuous-integration)

=== modified file 'src/include/server/mir/default_server_configuration.h'
--- src/include/server/mir/default_server_configuration.h	2017-03-13 08:12:52 +0000
+++ src/include/server/mir/default_server_configuration.h	2017-03-14 20:52:46 +0000
@@ -384,6 +384,7 @@
     CachedPtr<input::InputManager>    input_manager;
     CachedPtr<input::SurfaceInputDispatcher>    surface_input_dispatcher;
     CachedPtr<input::DefaultInputDeviceHub>    default_input_device_hub;
+    CachedPtr<input::InputDeviceHub>    input_device_hub;
     CachedPtr<dispatch::MultiplexingDispatchable> input_reading_multiplexer;
     CachedPtr<input::InputDispatcher> input_dispatcher;
     CachedPtr<shell::InputTargeter> input_targeter;

=== modified file 'src/server/graphics/nested/input_platform.cpp'
--- src/server/graphics/nested/input_platform.cpp	2017-03-14 20:52:46 +0000
+++ src/server/graphics/nested/input_platform.cpp	2017-03-14 02:26:28 +0000
@@ -338,9 +338,34 @@
             {
                 std::lock_guard<std::mutex> lock(devices_guard);
                 if (!devices.empty())
-                    handle_device_state(event);
-                else
-                    early_device_states.push_back(mir::events::clone_event(event));
+                {
+                    auto const* device_state = mir_event_get_input_device_state_event(&event);
+                    for (size_t index = 0, end_index = mir_input_device_state_event_device_count(device_state);
+                         index != end_index; ++index)
+                    {
+                        auto it = devices.find(mir_input_device_state_event_device_id(device_state, index));
+                        if (it != end(devices) && it->second->destination)
+                        {
+                            auto dest = it->second->destination;
+                            auto key_count = mir_input_device_state_event_device_pressed_keys_count(device_state, index);
+                            std::vector<uint32_t> scan_codes;
+                            for (uint32_t i = 0; i < key_count; i++)
+                            {
+                                scan_codes.push_back(mir_input_device_state_event_device_pressed_keys_for_index(device_state, index, i));
+                            }
+
+                            dest->key_state(scan_codes);
+                            dest->pointer_state(
+                                mir_input_device_state_event_device_pointer_buttons(device_state, index));
+                        }
+                    }
+
+                    auto& front = begin(devices)->second;
+                    auto device_state_event = front->builder->device_state_event(
+                        mir_input_device_state_event_pointer_axis(device_state, mir_pointer_axis_x),
+                        mir_input_device_state_event_pointer_axis(device_state, mir_pointer_axis_y));
+                    front->destination->handle_input(*device_state_event);
+                }
             }
         });
 }
@@ -396,13 +421,7 @@
     for (auto new_dev : new_devs)
     {
         input_device_registry->add_device(new_dev.first);
-    }
-    for (auto const& event : early_device_states)
-    {
-        handle_device_state(*event);
-    }
-    for (auto new_dev : new_devs)
-    {
+
         auto early_event_queue = unknown_device_events.find(new_dev.second);
         if (early_event_queue != end(unknown_device_events))
         {
@@ -414,7 +433,6 @@
         }
     }
     unknown_device_events.clear();
-    early_device_states.clear();
 }
 
 void mgn::InputPlatform::config_changed()
@@ -443,33 +461,3 @@
     }
     state = started;
 }
-
-void mgn::InputPlatform::handle_device_state(MirEvent const& event)
-{
-    auto const* device_state = mir_event_get_input_device_state_event(&event);
-    for (size_t index = 0, end_index = mir_input_device_state_event_device_count(device_state);
-         index != end_index; ++index)
-    {
-        auto it = devices.find(mir_input_device_state_event_device_id(device_state, index));
-        if (it != end(devices) && it->second->destination)
-        {
-            auto dest = it->second->destination;
-            auto key_count = mir_input_device_state_event_device_pressed_keys_count(device_state, index);
-            std::vector<uint32_t> scan_codes;
-            for (uint32_t i = 0; i < key_count; i++)
-            {
-                scan_codes.push_back(mir_input_device_state_event_device_pressed_keys_for_index(device_state, index, i));
-            }
-
-            dest->key_state(scan_codes);
-            dest->pointer_state(
-                mir_input_device_state_event_device_pointer_buttons(device_state, index));
-        }
-    }
-
-    auto& front = begin(devices)->second;
-    auto device_state_event = front->builder->device_state_event(
-        mir_input_device_state_event_pointer_axis(device_state, mir_pointer_axis_x),
-        mir_input_device_state_event_pointer_axis(device_state, mir_pointer_axis_y));
-    front->destination->handle_input(*device_state_event);
-}

=== modified file 'src/server/graphics/nested/input_platform.h'
--- src/server/graphics/nested/input_platform.h	2017-03-14 20:52:46 +0000
+++ src/server/graphics/nested/input_platform.h	2017-02-15 07:38:33 +0000
@@ -58,7 +58,6 @@
     void config_changed();
     void update_devices();
     void update_devices_locked();
-    void handle_device_state(MirEvent const& event);
     struct InputDevice;
     std::shared_ptr<HostConnection> const connection;
     std::shared_ptr<input::InputDeviceRegistry> const input_device_registry;
@@ -71,7 +70,6 @@
     std::unordered_map<MirInputDeviceId, std::shared_ptr<InputDevice>> devices;
     std::unordered_map<MirInputDeviceId, std::vector<std::pair<EventUPtr, mir::geometry::Rectangle>>>
         unknown_device_events;
-    std::vector<EventUPtr> early_device_states;
     enum State
     {
         started, stopped, paused

=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2017-03-14 02:26:28 +0000
+++ src/server/input/default_configuration.cpp	2017-03-14 20:52:46 +0000
@@ -301,7 +301,12 @@
 
 std::shared_ptr<mi::InputDeviceHub> mir::DefaultServerConfiguration::the_input_device_hub()
 {
-    return the_default_input_device_hub();
+    return input_device_hub(
+        [this]()
+        {
+            return std::make_shared<mi::ExternalInputDeviceHub>(the_default_input_device_hub(),
+               the_main_loop());
+        });
 }
 
 std::shared_ptr<mi::DefaultInputDeviceHub> mir::DefaultServerConfiguration::the_default_input_device_hub()
@@ -314,7 +319,6 @@
            auto hub = std::make_shared<mi::DefaultInputDeviceHub>(
                the_seat(),
                the_input_reading_multiplexer(),
-               the_main_loop(),
                the_cookie_authority(),
                the_key_mapper(),
                the_server_status_listener());
@@ -359,7 +363,7 @@
     return input_configuration_changer(
         [this]()
         {
-            return std::make_shared<mi::ConfigChanger>(the_input_manager(), the_input_device_hub(), the_session_container(), the_session_event_handler_register());
+            return std::make_shared<mi::ConfigChanger>(the_input_manager(), the_default_input_device_hub(), the_session_container(), the_session_event_handler_register());
         }
         );
 }

=== modified file 'src/server/input/default_device.cpp'
--- src/server/input/default_device.cpp	2017-02-28 08:53:57 +0000
+++ src/server/input/default_device.cpp	2017-03-14 20:52:46 +0000
@@ -60,6 +60,23 @@
 {
 }
 
+mi::DefaultDevice::DefaultDevice(MirInputDevice const& config,
+                                 std::shared_ptr<dispatch::ActionQueue> const& actions,
+                                 InputDevice& device,
+                                 std::shared_ptr<KeyMapper> const& key_mapper,
+                                 std::function<void(Device*)> const& callback)
+    : DefaultDevice(config.id(), actions, device, key_mapper, callback)
+{
+    if (config.has_touchpad_config())
+        set_touchpad_configuration(config.touchpad_config());
+    if (config.has_keyboard_config())
+        set_keyboard_configuration(config.keyboard_config());
+    if (config.has_pointer_config())
+        set_pointer_configuration(config.pointer_config());
+    if (config.has_touchscreen_config())
+        set_touchscreen_configuration(config.touchscreen_config());
+}
+
 mi::DeviceCapabilities mi::DefaultDevice::capabilities() const
 {
     return info.capabilities;
@@ -117,6 +134,12 @@
     if (conf.cursor_acceleration_bias() < -1.0 || conf.cursor_acceleration_bias() > 1.0)
         BOOST_THROW_EXCEPTION(std::invalid_argument("Cursor acceleration bias out of range"));
 
+    set_pointer_configuration(conf);
+    device_changed_callback(this);
+}
+
+void mi::DefaultDevice::set_pointer_configuration(MirPointerConfig const& conf)
+{
     PointerSettings settings;
     settings.handedness = conf.handedness();
     settings.acceleration = conf.acceleration();
@@ -133,7 +156,6 @@
                      {
                          dev->apply_settings(settings);
                      });
-    device_changed_callback(this);
 }
 
 void mi::DefaultDevice::apply_touchpad_configuration(MirTouchpadConfig const& conf)
@@ -148,6 +170,12 @@
         conf.button_down_scroll_button() == mi::no_scroll_button)
         BOOST_THROW_EXCEPTION(std::invalid_argument("No scroll button configured"));
 
+    set_touchpad_configuration(conf);
+    device_changed_callback(this);
+}
+
+void mi::DefaultDevice::set_touchpad_configuration(MirTouchpadConfig const& conf)
+{
     TouchpadSettings settings;
     settings.click_mode= conf.click_mode();
     settings.scroll_mode = conf.scroll_mode();
@@ -166,7 +194,6 @@
                      {
                          dev->apply_settings(settings);
                      });
-    device_changed_callback(this);
 }
 
 mir::optional_value<MirKeyboardConfig> mi::DefaultDevice::keyboard_configuration() const
@@ -180,15 +207,18 @@
     if (!contains(info.capabilities, mi::DeviceCapability::keyboard))
         BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot apply a keyboard configuration"));
 
-    {
-        std::lock_guard<std::mutex> lock(config_mutex);
-        if (keyboard.value().device_keymap() != conf.device_keymap())
-            keyboard = conf;
-        else
-            return;
-    }
+    set_keyboard_configuration(conf);
+    device_changed_callback(this);
+}
+
+void mi::DefaultDevice::set_keyboard_configuration(MirKeyboardConfig const& conf)
+{
+    std::lock_guard<std::mutex> lock(config_mutex);
+    if (keyboard.value().device_keymap() != conf.device_keymap())
+        keyboard = conf;
+    else
+        return;
     key_mapper->set_keymap_for_device(device_id, conf.device_keymap());
-    device_changed_callback(this);
 }
 
 mir::optional_value<MirTouchscreenConfig> mi::DefaultDevice::touchscreen_configuration() const
@@ -206,6 +236,12 @@
     if (!touchscreen.is_set())
         BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot apply a touchscreen configuration"));
 
+    set_touchscreen_configuration(config);
+    device_changed_callback(this);
+}
+
+void mi::DefaultDevice::set_touchscreen_configuration(MirTouchscreenConfig const& config)
+{
     TouchscreenSettings settings;
     settings.output_id = config.output_id();
     settings.mapping_mode = config.mapping_mode();
@@ -216,5 +252,27 @@
                      {
                          dev->apply_settings(settings);
                      });
-    device_changed_callback(this);
+}
+
+MirInputDevice mi::DefaultDevice::config() const
+{
+    auto stored_dev = MirInputDevice(
+        id(),
+        capabilities(),
+        name(),
+        unique_id());
+    auto pointer_conf = pointer_configuration();
+    if (pointer_conf.is_set())
+        stored_dev.set_pointer_config(pointer_conf.value());
+    auto touchpad_conf = touchpad_configuration();
+    if (touchpad_conf.is_set())
+        stored_dev.set_touchpad_config(touchpad_conf.value());
+    auto keyboard_conf = keyboard_configuration();
+    if (keyboard_conf.is_set())
+        stored_dev.set_keyboard_config(keyboard_conf.value());
+    auto touchscreen_conf = touchscreen_configuration();
+    if (touchscreen_conf.is_set())
+        stored_dev.set_touchscreen_config(touchscreen_conf.value());
+
+    return stored_dev;
 }

=== modified file 'src/server/input/default_device.h'
--- src/server/input/default_device.h	2017-02-28 08:53:57 +0000
+++ src/server/input/default_device.h	2017-03-14 20:52:46 +0000
@@ -58,6 +58,11 @@
                   InputDevice& device,
                   std::shared_ptr<KeyMapper> const& key_mapper,
                   std::function<void(Device*)> const& change_callback);
+    DefaultDevice(MirInputDevice const& config,
+                  std::shared_ptr<dispatch::ActionQueue> const& actions,
+                  InputDevice& device,
+                  std::shared_ptr<KeyMapper> const& key_mapper,
+                  std::function<void(Device*)> const& change_callback);
     MirInputDeviceId id() const override;
     DeviceCapabilities capabilities() const override;
     std::string name() const override;
@@ -71,7 +76,14 @@
     void apply_keyboard_configuration(MirKeyboardConfig const&) override;
     optional_value<MirTouchscreenConfig> touchscreen_configuration() const override;
     void apply_touchscreen_configuration(MirTouchscreenConfig const&) override;
+
+    MirInputDevice config() const;
 private:
+    void set_pointer_configuration(MirPointerConfig const&);
+    void set_touchpad_configuration(MirTouchpadConfig const&);
+    void set_keyboard_configuration(MirKeyboardConfig const&);
+    void set_touchscreen_configuration(MirTouchscreenConfig const&);
+
     void wake_hub_for_device_change();
     MirInputDeviceId const device_id;
     InputDevice& device;

=== modified file 'src/server/input/default_input_device_hub.cpp'
--- src/server/input/default_input_device_hub.cpp	2017-03-14 02:26:28 +0000
+++ src/server/input/default_input_device_hub.cpp	2017-03-14 20:52:46 +0000
@@ -41,16 +41,129 @@
 
 namespace mi = mir::input;
 
+struct mi::ExternalInputDeviceHub::Internal : InputDeviceObserver
+{
+    Internal(std::shared_ptr<mi::InputDeviceHub> const& hub,
+             std::shared_ptr<ServerActionQueue> const& queue) :
+        hub{hub}, observer_queue{queue}
+    {}
+    void device_added(std::shared_ptr<Device> const& device) override;
+    void device_changed(std::shared_ptr<Device> const& device) override;
+    void device_removed(std::shared_ptr<Device> const& device) override;
+    void changes_complete() override;
+
+    std::weak_ptr<InputDeviceHub> hub;
+    std::shared_ptr<ServerActionQueue> const observer_queue;
+    ThreadSafeList<std::shared_ptr<InputDeviceObserver>> observers;
+    std::vector<std::shared_ptr<Device>> devices_added;
+    std::vector<std::shared_ptr<Device>> devices_changed;
+    std::vector<std::shared_ptr<Device>> devices_removed;
+    std::vector<std::shared_ptr<Device>> handles;
+};
+
+mi::ExternalInputDeviceHub::ExternalInputDeviceHub(std::shared_ptr<mi::InputDeviceHub> const& hub, std::shared_ptr<mir::ServerActionQueue> const& queue)
+    : data{std::make_shared<mi::ExternalInputDeviceHub::Internal>(hub, queue)}
+{
+    hub->add_observer(data);
+}
+
+mi::ExternalInputDeviceHub::~ExternalInputDeviceHub()
+{
+    data->observer_queue->pause_processing_for(data.get());
+}
+
+void mi::ExternalInputDeviceHub::add_observer(std::shared_ptr<InputDeviceObserver> const& observer)
+{
+    auto hub = data->hub.lock();
+    if (hub)
+    {
+        data->observer_queue->enqueue(
+            data.get(),
+            [observer, data = this->data]
+            {
+                for (auto const& item : data->handles)
+                    observer->device_added(item);
+                observer->changes_complete();
+                data->observers.add(observer);
+            });
+    }
+}
+
+void mi::ExternalInputDeviceHub::remove_observer(std::weak_ptr<InputDeviceObserver> const& obs)
+{
+    auto observer = obs.lock();
+    data->observers.remove(observer);
+}
+
+void mi::ExternalInputDeviceHub::for_each_input_device(std::function<void(Device const& device)> const& callback)
+{
+    auto hub = data->hub.lock();
+    hub->for_each_input_device(callback);
+}
+
+void mi::ExternalInputDeviceHub::for_each_mutable_input_device(std::function<void(Device& device)> const& callback)
+{
+    auto hub = data->hub.lock();
+    hub->for_each_mutable_input_device(callback);
+}
+
+void mi::ExternalInputDeviceHub::Internal::device_added(std::shared_ptr<Device> const& device)
+{
+    devices_added.push_back(device);
+}
+
+void mi::ExternalInputDeviceHub::Internal::device_changed(std::shared_ptr<Device> const& device)
+{
+    devices_changed.push_back(device);
+}
+
+void mi::ExternalInputDeviceHub::Internal::device_removed(std::shared_ptr<Device> const& device)
+{
+    devices_removed.push_back(device);
+}
+
+void mi::ExternalInputDeviceHub::Internal::changes_complete()
+{
+    decltype(devices_added) added, changed, removed;
+
+    std::swap(devices_added, added);
+    std::swap(devices_changed, changed);
+    std::swap(devices_removed, removed);
+
+    if (!(added.empty() && changed.empty() && removed.empty()))
+        observer_queue->enqueue(
+            this,
+            [this, added, changed, removed]
+            {
+                observers.for_each([&](std::shared_ptr<InputDeviceObserver> const& observer)
+                    {
+                        for (auto const& dev : added)
+                            observer->device_added(dev);
+                        for (auto const& dev : changed)
+                            observer->device_changed(dev);
+                        for (auto const& dev : removed)
+                            observer->device_removed(dev);
+                        observer->changes_complete();
+                    });
+
+                auto end_it = handles.end();
+                for (auto const& dev : removed)
+                    end_it = remove(begin(handles), end(handles), dev);
+                if (end_it != handles.end())
+                    handles.erase(end_it, end(handles));
+                for (auto const& dev : added)
+                    handles.push_back(dev);
+            });
+}
+
 mi::DefaultInputDeviceHub::DefaultInputDeviceHub(
     std::shared_ptr<mi::Seat> const& seat,
     std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
-    std::shared_ptr<mir::ServerActionQueue> const& observer_queue,
     std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
     std::shared_ptr<mi::KeyMapper> const& key_mapper,
     std::shared_ptr<mir::ServerStatusListener> const& server_status_listener)
     : seat{seat},
       input_dispatchable{input_multiplexer},
-      observer_queue(observer_queue),
       device_queue(std::make_shared<dispatch::ActionQueue>()),
       cookie_authority(cookie_authority),
       key_mapper(key_mapper),
@@ -74,24 +187,16 @@
 
     if (it == end(devices))
     {
-        auto id = create_new_device_id();
-        auto handle = std::make_shared<DefaultDevice>(id, device_queue, *device, key_mapper, [this](Device *d){device_changed(d);});
+        auto handle = restore_or_create_device(*device);
         // send input device info to observer loop..
         devices.push_back(std::make_unique<RegisteredDevice>(
-            device, id, input_dispatchable, cookie_authority, handle));
+            device, handle->id(), input_dispatchable, cookie_authority, handle));
 
         auto const& dev = devices.back();
+        add_device_handle(handle);
 
         seat->add_device(*handle);
         dev->start(seat);
-
-        // pass input device handle to observer loop..
-        observer_queue->enqueue(this,
-                                [this, handle]()
-                                {
-                                    add_device_handle(handle);
-                                });
-
     }
     else
     {
@@ -112,19 +217,14 @@
         {
             if (item->device_matches(device))
             {
+                store_device_config(*item->handle);
                 auto seat = item->seat;
                 if (seat)
                 {
                     seat->remove_device(*item->handle);
                     item->stop();
                 }
-                // send input device info to observer queue..
-                observer_queue->enqueue(
-                    this,
-                    [this,id = item->id()]()
-                    {
-                        remove_device_handle(id);
-                    });
+                remove_device_handle(item->id());
 
                 return true;
             }
@@ -230,18 +330,15 @@
 
 void mi::DefaultInputDeviceHub::add_observer(std::shared_ptr<InputDeviceObserver> const& observer)
 {
-    observer_queue->enqueue(
-        this,
-        [observer,this]
+    device_queue->enqueue(
+        [this,observer]()
         {
-            observers.add(observer);
+            std::unique_lock<std::mutex> lock(handles_guard);
             for (auto const& item : handles)
-            {
                 observer->device_added(item);
-            }
             observer->changes_complete();
-        }
-        );
+            observers.add(observer);
+        });
 }
 
 void mi::DefaultInputDeviceHub::for_each_input_device(std::function<void(Device const&)> const& callback)
@@ -270,12 +367,7 @@
 void mi::DefaultInputDeviceHub::remove_observer(std::weak_ptr<InputDeviceObserver> const& element)
 {
     auto observer = element.lock();
-
-    observer_queue->enqueue(this,
-                            [observer, this]
-                            {
-                                observers.remove(observer);
-                            });
+    observers.remove(observer);
 }
 
 void mi::DefaultInputDeviceHub::add_device_handle(std::shared_ptr<DefaultDevice> const& handle)
@@ -285,7 +377,7 @@
         handles.push_back(handle);
     }
 
-    observers.for_each([&handle](std::shared_ptr<InputDeviceObserver> const& observer)
+    observers.for_each([&handle, this](std::shared_ptr<InputDeviceObserver> const& observer)
         {
             observer->device_added(handle);
             observer->changes_complete();
@@ -396,3 +488,51 @@
     }
 }
 
+void mi::DefaultInputDeviceHub::store_device_config(mi::DefaultDevice const& dev)
+{
+    std::lock_guard<std::mutex> lock(stored_configurations_guard);
+    stored_devices.push_back(dev.config());
+}
+
+mir::optional_value<MirInputDevice>
+mi::DefaultInputDeviceHub::get_stored_device_config(std::string const& id)
+{
+    mir::optional_value<MirInputDevice> optional_config;
+    std::lock_guard<std::mutex> lock(stored_configurations_guard);
+    auto pos = remove_if(
+        begin(stored_devices),
+        end(stored_devices),
+        [&optional_config,id](auto const& handle)
+        {
+            if (id == handle.unique_id())
+            {
+                optional_config = handle;
+                return true;
+            }
+            return false;
+        });
+    stored_devices.erase(pos, end(stored_devices));
+
+    return optional_config;
+}
+
+std::shared_ptr<mi::DefaultDevice>
+mi::DefaultInputDeviceHub::restore_or_create_device(mi::InputDevice& device)
+{
+    auto device_config = get_stored_device_config(device.get_device_info().unique_id);
+
+    if (device_config.is_set())
+        return std::make_shared<DefaultDevice>(
+            device_config.value(),
+            device_queue,
+            device,
+            key_mapper,
+            [this](Device *d){device_changed(d);});
+    else
+        return std::make_shared<DefaultDevice>(
+            create_new_device_id(),
+            device_queue,
+            device,
+            key_mapper,
+            [this](Device *d){device_changed(d);});
+}

=== modified file 'src/server/input/default_input_device_hub.h'
--- src/server/input/default_input_device_hub.h	2017-03-14 02:26:28 +0000
+++ src/server/input/default_input_device_hub.h	2017-03-14 20:52:46 +0000
@@ -25,9 +25,11 @@
 #include "mir/input/input_sink.h"
 #include "mir/input/seat.h"
 #include "mir/input/input_device_hub.h"
+#include "mir/input/input_device_observer.h"
 #include "mir/input/input_device_info.h"
 #include "mir/input/mir_input_config.h"
 #include "mir/thread_safe_list.h"
+#include "mir/optional_value.h"
 
 #include "mir_toolkit/event.h"
 
@@ -57,13 +59,31 @@
 class DefaultDevice;
 class Seat;
 class KeyMapper;
-
-class DefaultInputDeviceHub : public InputDeviceRegistry, public InputDeviceHub
+class DefaultInputDeviceHub;
+
+struct ExternalInputDeviceHub : InputDeviceHub
+{
+    ExternalInputDeviceHub(std::shared_ptr<InputDeviceHub> const& actual_hub,
+                           std::shared_ptr<ServerActionQueue> const& observer_queue);
+    ~ExternalInputDeviceHub();
+
+    void add_observer(std::shared_ptr<InputDeviceObserver> const&) override;
+    void remove_observer(std::weak_ptr<InputDeviceObserver> const&) override;
+    void for_each_input_device(std::function<void(Device const& device)> const& callback) override;
+    void for_each_mutable_input_device(std::function<void(Device& device)> const& callback) override;
+
+private:
+    struct Internal;
+    std::shared_ptr<Internal> data;
+};
+
+class DefaultInputDeviceHub :
+    public InputDeviceRegistry,
+    public InputDeviceHub
 {
 public:
     DefaultInputDeviceHub(std::shared_ptr<Seat> const& seat,
                           std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
-                          std::shared_ptr<ServerActionQueue> const& observer_queue,
                           std::shared_ptr<cookie::Authority> const& cookie_authority,
                           std::shared_ptr<KeyMapper> const& key_mapper,
                           std::shared_ptr<ServerStatusListener> const& server_status_listener);
@@ -77,8 +97,6 @@
     void remove_observer(std::weak_ptr<InputDeviceObserver> const&) override;
     void for_each_input_device(std::function<void(Device const& device)> const& callback) override;
     void for_each_mutable_input_device(std::function<void(Device& device)> const& callback) override;
-
-
 private:
     void update_spots();
     void add_device_handle(std::shared_ptr<DefaultDevice> const& handle);
@@ -86,10 +104,13 @@
     void device_changed(Device* dev);
     void emit_changed_devices();
     MirInputDeviceId create_new_device_id();
+    void store_device_config(DefaultDevice const& dev);
+    std::shared_ptr<DefaultDevice> restore_or_create_device(InputDevice& dev);
+    mir::optional_value<MirInputDevice> get_stored_device_config(std::string const& id);
+
     std::shared_ptr<Seat> const seat;
     std::shared_ptr<dispatch::MultiplexingDispatchable> const input_dispatchable;
-    std::mutex handles_guard;
-    std::shared_ptr<ServerActionQueue> const observer_queue;
+    std::mutex mutable handles_guard;
     std::shared_ptr<dispatch::ActionQueue> const device_queue;
     std::shared_ptr<cookie::Authority> const cookie_authority;
     std::shared_ptr<KeyMapper> const key_mapper;
@@ -130,6 +151,9 @@
     std::mutex changed_devices_guard;
     std::unique_ptr<std::vector<std::shared_ptr<Device>>> changed_devices;
 
+    std::mutex stored_configurations_guard;
+    std::vector<MirInputDevice> stored_devices;
+
     MirInputDeviceId device_id_generator;
     bool ready{false};
 };

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2017-03-14 02:26:28 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2017-03-14 20:52:46 +0000
@@ -343,12 +343,13 @@
                     devices_available.raise();
             });
 
-        server.the_input_device_hub()->add_observer(counter);
+        auto hub = server.the_input_device_hub();
+        hub->add_observer(counter);
 
         devices_available.wait_for(5s);
         ASSERT_THAT(counter->count_devices, Eq(expected_number_of_input_devices));
 
-        server.the_input_device_hub()->remove_observer(counter);
+        hub->remove_observer(counter);
     }
 
     MirInputDevice const* get_device_with_capabilities(MirInputConfig const* config, MirInputDeviceCapabilities caps)

=== modified file 'tests/acceptance-tests/test_input_device_hub.cpp'
--- tests/acceptance-tests/test_input_device_hub.cpp	2017-01-18 02:29:37 +0000
+++ tests/acceptance-tests/test_input_device_hub.cpp	2017-03-14 20:52:46 +0000
@@ -60,7 +60,8 @@
     EXPECT_CALL(observer, changes_complete())
         .WillOnce(mt::WakeUp(&observer_registered));
 
-    server.the_input_device_hub()->add_observer(mt::fake_shared(observer));
+    auto device_hub = server.the_input_device_hub();
+    device_hub->add_observer(mt::fake_shared(observer));
     observer_registered.wait_for(std::chrono::seconds{4});
 }
 
@@ -75,7 +76,8 @@
     EXPECT_CALL(observer, changes_complete())
         .WillOnce(mt::WakeUp(&callbacks_received));
 
-    server.the_input_device_hub()->add_observer(mt::fake_shared(observer));
+    auto device_hub = server.the_input_device_hub();
+    device_hub->add_observer(mt::fake_shared(observer));
     observer_registered.wait_for(std::chrono::seconds{4});
 
     keep_on_living = mtf::add_fake_input_device(mi::InputDeviceInfo{"keyboard", "keyboard-uid", mir::input::DeviceCapability::keyboard});

=== modified file 'tests/acceptance-tests/test_nested_input.cpp'
--- tests/acceptance-tests/test_nested_input.cpp	2017-03-14 14:01:42 +0000
+++ tests/acceptance-tests/test_nested_input.cpp	2017-03-14 20:52:46 +0000
@@ -112,13 +112,12 @@
 
 struct NestedInput : public mtf::HeadlessInProcessServer
 {
-
     void SetUp()
     {
         initial_display_layout(display_geometry);
         mtf::HeadlessInProcessServer::SetUp();
     }
-    
+
     mtd::NestedMockEGL mock_egl;
 
     std::unique_ptr<mtf::FakeInputDevice> fake_keyboard{
@@ -301,13 +300,12 @@
     NestedServerWithMockEventFilter nested_mir{new_connection()};
     auto nested_hub = nested_mir.server.the_input_device_hub();
 
-    EXPECT_CALL(*mock_observer, device_added(_)).Times(1);
-    EXPECT_CALL(*mock_observer, changes_complete())
-        .Times(1)
+    EXPECT_CALL(*mock_observer, device_added(_))
         .WillOnce(mt::WakeUp(&input_device_changes_complete));
 
     nested_hub->add_observer(mock_observer);
     input_device_changes_complete.wait_for(10s);
+    nested_hub->remove_observer(mock_observer);
 }
 
 TEST_F(NestedInput, device_added_on_host_triggeres_nested_device_observer)
@@ -315,15 +313,18 @@
     NestedServerWithMockEventFilter nested_mir{new_connection()};
     auto nested_hub = nested_mir.server.the_input_device_hub();
 
-    EXPECT_CALL(*mock_observer, changes_complete()).Times(1)
+    // wait until we see the keyboard from the fixture:
+    EXPECT_CALL(*mock_observer, device_added(_)).Times(1)
         .WillOnce(mt::WakeUp(&input_device_changes_complete));
     nested_hub->add_observer(mock_observer);
 
     input_device_changes_complete.wait_for(10s);
     EXPECT_THAT(input_device_changes_complete.raised(), Eq(true));
     input_device_changes_complete.reset();
+    ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
 
-    EXPECT_CALL(*mock_observer, changes_complete())
+    // wait for the fake mouse
+    EXPECT_CALL(*mock_observer, device_added(_)).Times(1)
         .WillOnce(mt::WakeUp(&input_device_changes_complete));
 
     auto mouse = mtf::add_fake_input_device(mi::InputDeviceInfo{"mouse", "mouse-uid" , mi::DeviceCapability::pointer});

=== added file 'tests/include/mir/test/doubles/mock_device.h'
--- tests/include/mir/test/doubles/mock_device.h	1970-01-01 00:00:00 +0000
+++ tests/include/mir/test/doubles/mock_device.h	2017-03-14 20:52:46 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2017 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
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_DEVICE_H_
+#define MIR_TEST_DOUBLES_MOCK_DEVICE_H_
+
+#include "mir/input/device.h"
+#include "mir/input/device_capability.h"
+#include "mir/input/mir_pointer_config.h"
+#include "mir/input/mir_keyboard_config.h"
+#include "mir/input/mir_touchpad_config.h"
+#include "mir/input/mir_touchscreen_config.h"
+#include "mir/optional_value.h"
+
+#include <string>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockDevice : input::Device
+{
+    MockDevice(MirInputDeviceId id, input::DeviceCapabilities caps, std::string const& name, std::string const& unique_id)
+    {
+        ON_CALL(*this, id()).WillByDefault(testing::Return(id));
+        ON_CALL(*this, name()).WillByDefault(testing::Return(name));
+        ON_CALL(*this, unique_id()).WillByDefault(testing::Return(unique_id));
+        ON_CALL(*this, capabilities()).WillByDefault(testing::Return(caps));
+        ON_CALL(*this, pointer_configuration()).WillByDefault(testing::Return(MirPointerConfig{}));
+        ON_CALL(*this, keyboard_configuration()).WillByDefault(testing::Return(MirKeyboardConfig{}));
+        ON_CALL(*this, touchpad_configuration()).WillByDefault(testing::Return(MirTouchpadConfig{}));
+        ON_CALL(*this, touchscreen_configuration()).WillByDefault(testing::Return(MirTouchscreenConfig{}));
+    }
+
+    MOCK_CONST_METHOD0(id, MirInputDeviceId());
+    MOCK_CONST_METHOD0(capabilities, input::DeviceCapabilities());
+    MOCK_CONST_METHOD0(name, std::string());
+    MOCK_CONST_METHOD0(unique_id, std::string());
+    MOCK_CONST_METHOD0(pointer_configuration, optional_value<MirPointerConfig>());
+    MOCK_CONST_METHOD0(touchpad_configuration, optional_value<MirTouchpadConfig>());
+    MOCK_CONST_METHOD0(keyboard_configuration, optional_value<MirKeyboardConfig>());
+    MOCK_CONST_METHOD0(touchscreen_configuration, optional_value<MirTouchscreenConfig>());
+    MOCK_METHOD1(apply_pointer_configuration, void(MirPointerConfig const&));
+    MOCK_METHOD1(apply_touchpad_configuration, void(MirTouchpadConfig const&));
+    MOCK_METHOD1(apply_keyboard_configuration, void(MirKeyboardConfig const&));
+    MOCK_METHOD1(apply_touchscreen_configuration, void(MirTouchscreenConfig const&));
+};
+}
+}
+}
+
+#endif
+

=== modified file 'tests/integration-tests/input/test_single_seat_setup.cpp'
--- tests/integration-tests/input/test_single_seat_setup.cpp	2017-03-14 02:26:28 +0000
+++ tests/integration-tests/input/test_single_seat_setup.cpp	2017-03-14 20:52:46 +0000
@@ -51,6 +51,7 @@
 #include "mir/input/input_device_info.h"
 #include "mir/geometry/rectangles.h"
 #include "mir/test/input_config_matchers.h"
+#include "mir/test/fd_utils.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -131,9 +132,9 @@
                        mt::fake_shared(mock_cursor_listener), mt::fake_shared(display_config),
                        mt::fake_shared(key_mapper),           mt::fake_shared(clock),
                        mt::fake_shared(mock_seat_observer)};
-    mi::DefaultInputDeviceHub hub{mt::fake_shared(seat),          mt::fake_shared(multiplexer),
-                                  mt::fake_shared(observer_loop), cookie_authority,
-                                  mt::fake_shared(key_mapper),    mt::fake_shared(mock_status_listener)};
+    mi::DefaultInputDeviceHub hub{mt::fake_shared(seat), mt::fake_shared(multiplexer),
+                                  cookie_authority,      mt::fake_shared(key_mapper),
+                                  mt::fake_shared(mock_status_listener)};
     NiceMock<mtd::MockInputDeviceObserver> mock_observer;
     mi::ConfigChanger changer{
         mt::fake_shared(mock_input_manager),
@@ -151,6 +152,21 @@
 
     std::chrono::nanoseconds arbitrary_timestamp;
 
+    void SetUp()
+    {
+        // execute registration of ConfigChanger
+        expect_and_execute_multiplexer();
+    }
+
+    void expect_and_execute_multiplexer(int count = 1)
+    {
+        for (int i = 0; i != count; ++i)
+        {
+            mt::fd_becomes_readable(multiplexer.watch_fd(), 5s);
+            multiplexer.dispatch(mir::dispatch::FdEvent::readable);
+        }
+    }
+
     void capture_input_sink(NiceMock<mtd::MockInputDevice>& dev, mi::InputSink*& sink, mi::EventBuilder*& builder)
     {
         ON_CALL(dev,start(_,_))
@@ -173,14 +189,13 @@
 
     capture_input_sink(device, sink, builder);
 
-    EXPECT_CALL(mock_observer,device_added(_))
+    EXPECT_CALL(mock_observer, device_added(_))
         .WillOnce(SaveArg<0>(&handle));
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer(1);
     hub.add_device(mt::fake_shared(device));
 
-    observer_loop.trigger_server_actions();
-
     auto event = builder->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0,
                                     KEY_A);
 
@@ -198,8 +213,6 @@
 
     hub.add_device(mt::fake_shared(device));
 
-    observer_loop.trigger_server_actions();
-
     auto touch_event_1 = builder->touch_event(
         arbitrary_timestamp,
         {{0, mir_touch_action_down, mir_touch_tooltype_finger, 21.0f, 34.0f, 50.0f, 15.0f, 5.0f, 4.0f}});
@@ -245,7 +258,6 @@
     capture_input_sink(device, sink, builder);
 
     hub.add_device(mt::fake_shared(device));
-    observer_loop.trigger_server_actions();
     sink->handle_input(
         *builder->pointer_event(arbitrary_timestamp, mir_pointer_action_motion, 0, 0.0f, 0.0f, 10.0f, 10.0f));
     sink->handle_input(
@@ -265,7 +277,6 @@
     mi::EventBuilder* builder;
     capture_input_sink(device, sink, builder);
     hub.add_device(mt::fake_shared(device));
-    observer_loop.trigger_server_actions();
 
     sink->handle_input(
         *builder->pointer_event(arbitrary_timestamp, mir_pointer_action_motion, 0, 0.0f, 0.0f, 10.0f, 20.0f));
@@ -295,8 +306,8 @@
     ON_CALL(mock_observer, device_added(_)).WillByDefault(SaveArg<0>(&dev));
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
     hub.add_device(mt::fake_shared(touchpad));
-    observer_loop.trigger_server_actions();
 
     EXPECT_CALL(touchpad, apply_settings(Matcher<mi::PointerSettings const&>(_)));
 
@@ -311,8 +322,8 @@
     ON_CALL(mock_observer, device_added(_)).WillByDefault(SaveArg<0>(&dev));
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
     hub.add_device(mt::fake_shared(touchpad));
-    observer_loop.trigger_server_actions();
 
     EXPECT_CALL(touchpad, apply_settings(Matcher<mi::TouchpadSettings const&>(_)));
 
@@ -334,9 +345,9 @@
         .WillOnce(SaveArg<0>(&key_handle));
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
     hub.add_device(mt::fake_shared(another_device));
 
-    observer_loop.trigger_server_actions();
 
     const MirInputEventModifiers shift_left = mir_input_event_modifier_shift_left | mir_input_event_modifier_shift;
     auto shift_down =
@@ -370,11 +381,10 @@
         .WillOnce(SaveArg<0>(&key_handle));
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
     hub.add_device(mt::fake_shared(device));
     hub.add_device(mt::fake_shared(another_device));
 
-    observer_loop.trigger_server_actions();
-
     const MirInputEventModifiers r_alt_modifier = mir_input_event_modifier_alt_right | mir_input_event_modifier_alt;
     auto key =
         key_event_builder->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_RIGHTALT);
@@ -415,6 +425,7 @@
         .WillOnce(SaveArg<0>(&key_handle_2));
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
     hub.add_device(mt::fake_shared(device));
     hub.add_device(mt::fake_shared(another_device));
     hub.add_device(mt::fake_shared(third_device));
@@ -423,8 +434,6 @@
     const MirInputEventModifiers l_ctrl_modifier = mir_input_event_modifier_ctrl_left | mir_input_event_modifier_ctrl;
     const MirInputEventModifiers combined_modifier = r_alt_modifier | l_ctrl_modifier;
 
-    observer_loop.trigger_server_actions();
-
     auto alt_down = key_event_builder_1->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_RIGHTALT);
     auto ctrl_down = key_event_builder_2->key_event(arbitrary_timestamp, mir_keyboard_action_down, 0, KEY_LEFTCTRL);
     auto ctrl_up = key_event_builder_2->key_event(arbitrary_timestamp, mir_keyboard_action_up, 0, KEY_LEFTCTRL);
@@ -462,8 +471,6 @@
     hub.add_device(mt::fake_shared(device));
     hub.add_device(mt::fake_shared(another_device));
 
-    observer_loop.trigger_server_actions();
-
     auto motion_1 =
         mouse_event_builder_1->pointer_event(arbitrary_timestamp, mir_pointer_action_motion, 0, 0, 0, 23, 20);
     auto motion_2 =
@@ -495,8 +502,6 @@
     hub.add_device(mt::fake_shared(device));
     hub.add_device(mt::fake_shared(another_device));
 
-    observer_loop.trigger_server_actions();
-
     auto motion_1 =
         mouse_event_builder_1->pointer_event(arbitrary_timestamp, mir_pointer_action_button_down, mir_pointer_button_primary, 0, 0, 0, 0);
     auto motion_2 =
@@ -525,7 +530,6 @@
 
     EXPECT_CALL(session, send_input_config(UnorderedElementsAre(DeviceMatches(device.get_device_info()))));
     hub.add_device(mt::fake_shared(device));
-    observer_loop.trigger_server_actions();
 }
 
 TEST_F(SingleSeatInputDeviceHubSetup, input_device_changes_sent_to_session_multiple_devices)
@@ -534,25 +538,21 @@
     stub_session_container.insert_session(mt::fake_shared(session));
 
     hub.add_device(mt::fake_shared(device));
-    observer_loop.trigger_server_actions();
 
     EXPECT_CALL(session,
                 send_input_config(UnorderedElementsAre(DeviceMatches(device.get_device_info()),
                                                        DeviceMatches(another_device.get_device_info()))));
     hub.add_device(mt::fake_shared(another_device));
-    observer_loop.trigger_server_actions();
 }
 
 TEST_F(SingleSeatInputDeviceHubSetup, input_device_changes_sent_to_sink_removal)
 {
     hub.add_device(mt::fake_shared(device));
     hub.add_device(mt::fake_shared(another_device));
-    observer_loop.trigger_server_actions();
 
     NiceMock<mtd::MockSceneSession> session;
     stub_session_container.insert_session(mt::fake_shared(session));
     EXPECT_CALL(session,
                 send_input_config(UnorderedElementsAre(DeviceMatches(another_device.get_device_info()))));
     hub.remove_device(mt::fake_shared(device));
-    observer_loop.trigger_server_actions();
 }

=== modified file 'tests/unit-tests/input/CMakeLists.txt'
--- tests/unit-tests/input/CMakeLists.txt	2017-03-13 08:12:52 +0000
+++ tests/unit-tests/input/CMakeLists.txt	2017-03-14 20:52:46 +0000
@@ -8,6 +8,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_input_event.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_config_changer.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_event_builders.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_external_input_device_hub.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_input_device_hub.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_input_manager.cpp

=== modified file 'tests/unit-tests/input/test_config_changer.cpp'
--- tests/unit-tests/input/test_config_changer.cpp	2017-02-28 08:53:57 +0000
+++ tests/unit-tests/input/test_config_changer.cpp	2017-03-14 20:52:46 +0000
@@ -29,6 +29,7 @@
 
 #include "mir/test/doubles/mock_input_device_hub.h"
 #include "mir/test/doubles/mock_input_manager.h"
+#include "mir/test/doubles/mock_device.h"
 #include "mir/test/doubles/mock_scene_session.h"
 #include "mir/test/doubles/stub_session.h"
 #include "mir/test/doubles/stub_session_container.h"
@@ -47,34 +48,6 @@
 namespace
 {
 
-struct MockDevice : mir::input::Device
-{
-    MockDevice(MirInputDeviceId id, mi::DeviceCapabilities caps, std::string const& name, std::string const& unique_id)
-    {
-        ON_CALL(*this, id()).WillByDefault(Return(id));
-        ON_CALL(*this, name()).WillByDefault(Return(name));
-        ON_CALL(*this, unique_id()).WillByDefault(Return(unique_id));
-        ON_CALL(*this, capabilities()).WillByDefault(Return(caps));
-        ON_CALL(*this, pointer_configuration()).WillByDefault(Return(MirPointerConfig{}));
-        ON_CALL(*this, keyboard_configuration()).WillByDefault(Return(MirKeyboardConfig{}));
-        ON_CALL(*this, touchpad_configuration()).WillByDefault(Return(MirTouchpadConfig{}));
-        ON_CALL(*this, touchscreen_configuration()).WillByDefault(Return(MirTouchscreenConfig{}));
-    }
-
-    MOCK_CONST_METHOD0(id, MirInputDeviceId());
-    MOCK_CONST_METHOD0(capabilities, mir::input::DeviceCapabilities());
-    MOCK_CONST_METHOD0(name, std::string());
-    MOCK_CONST_METHOD0(unique_id, std::string());
-    MOCK_CONST_METHOD0(pointer_configuration, mir::optional_value<MirPointerConfig>());
-    MOCK_CONST_METHOD0(touchpad_configuration, mir::optional_value<MirTouchpadConfig>());
-    MOCK_CONST_METHOD0(keyboard_configuration, mir::optional_value<MirKeyboardConfig>());
-    MOCK_CONST_METHOD0(touchscreen_configuration, mir::optional_value<MirTouchscreenConfig>());
-    MOCK_METHOD1(apply_pointer_configuration, void(MirPointerConfig const&));
-    MOCK_METHOD1(apply_touchpad_configuration, void(MirTouchpadConfig const&));
-    MOCK_METHOD1(apply_keyboard_configuration, void(MirKeyboardConfig const&));
-    MOCK_METHOD1(apply_touchscreen_configuration, void(MirTouchscreenConfig const&));
-};
-
 struct FakeInputDeviceHub : mir::input::InputDeviceHub
 {
     std::shared_ptr<mi::InputDeviceObserver> observer;
@@ -86,8 +59,8 @@
                                         mi::DeviceCapability::keyboard | mi::DeviceCapability::alpha_numeric |
                                         mi::DeviceCapability::touchscreen;
 
-    NiceMock<MockDevice> first_device{first_id, caps, first, first};
-    NiceMock<MockDevice> second_device{second_id, caps, second, second};
+    NiceMock<mtd::MockDevice> first_device{first_id, caps, first, first};
+    NiceMock<mtd::MockDevice> second_device{second_id, caps, second, second};
     std::vector<std::shared_ptr<mir::input::Device>> active_devices;
 
     void add_observer(std::shared_ptr<mi::InputDeviceObserver> const& obs) override

=== modified file 'tests/unit-tests/input/test_default_device.cpp'
--- tests/unit-tests/input/test_default_device.cpp	2017-02-28 08:53:57 +0000
+++ tests/unit-tests/input/test_default_device.cpp	2017-03-14 20:52:46 +0000
@@ -18,6 +18,7 @@
 
 #include "src/server/input/default_device.h"
 #include "mir/input/input_device.h"
+#include "mir/input/mir_input_config.h"
 #include "mir/input/mir_touchpad_config.h"
 #include "mir/input/mir_pointer_config.h"
 #include "mir/input/mir_touchscreen_config.h"
@@ -57,6 +58,7 @@
     NiceMock<MockInputDevice> touchscreen;
     NiceMock<mtd::MockKeyMapper> key_mapper;
     std::shared_ptr<md::ActionQueue> queue{std::make_shared<md::ActionQueue>()};
+    std::function<void(mi::Device*)> const change_callback{[](mi::Device*){}};
 
     DefaultDevice()
     {
@@ -181,3 +183,128 @@
 
     queue->dispatch(md::FdEvent::readable);
 }
+
+TEST_F(DefaultDevice, touchpad_device_can_be_constructed_from_input_config)
+{
+    MirTouchpadConfig const tpd_conf{mir_touchpad_click_mode_finger_count, mir_touchpad_scroll_mode_edge_scroll, 0, false, true, true, true};
+    MirPointerConfig const ptr_conf{mir_pointer_handedness_right, mir_pointer_acceleration_adaptive, 0.5, -1.0, 1.0};
+    MirInputDevice conf(MirInputDeviceId{17}, mi::DeviceCapability::touchpad|mi::DeviceCapability::pointer, "touchpad", "toouchpad-event7");
+    conf.set_touchpad_config(tpd_conf);
+    conf.set_pointer_config(ptr_conf);
+    mi::DefaultDevice dev(conf, queue, touchpad, mt::fake_shared(key_mapper), change_callback);
+
+    EXPECT_EQ(tpd_conf, dev.touchpad_configuration().value());
+    EXPECT_EQ(ptr_conf, dev.pointer_configuration().value());
+}
+
+TEST_F(DefaultDevice, pointer_device_can_be_constructed_from_input_config)
+{
+    MirPointerConfig const ptr_config{mir_pointer_handedness_left, mir_pointer_acceleration_none, 0, 1.0, 1.0};
+    MirInputDevice conf(MirInputDeviceId{11}, mi::DeviceCapability::pointer, "pointer", "pointer-event7");
+    conf.set_pointer_config(ptr_config);
+    mi::DefaultDevice dev(conf, queue, mouse, mt::fake_shared(key_mapper), change_callback);
+
+    EXPECT_EQ(ptr_config, dev.pointer_configuration().value());
+}
+
+TEST_F(DefaultDevice, keyboard_device_can_be_constructed_from_input_config)
+{
+    MirKeyboardConfig const kbd_config{mi::Keymap{"pc104", "dvorak", "", ""}};
+    MirInputDevice conf(MirInputDeviceId{3}, mi::DeviceCapability::keyboard, "keyboard", "keyboard-event3c");
+    conf.set_keyboard_config(kbd_config);
+    mi::DefaultDevice dev(conf, queue, keyboard, mt::fake_shared(key_mapper), change_callback);
+
+    EXPECT_EQ(kbd_config, dev.keyboard_configuration().value());
+}
+
+TEST_F(DefaultDevice, touchscreen_device_can_be_constructed_from_input_config)
+{
+    MirTouchscreenConfig const ts_config{0, mir_touchscreen_mapping_mode_to_display_wall};
+    MirInputDevice conf(MirInputDeviceId{5}, mi::DeviceCapability::touchscreen, "ts", "ts-event7");
+    conf.set_touchscreen_config(ts_config);
+
+    mi::DefaultDevice dev(conf, queue, touchscreen, mt::fake_shared(key_mapper), change_callback);
+
+    EXPECT_EQ(ts_config, dev.touchscreen_configuration().value());
+}
+
+TEST_F(DefaultDevice, device_config_can_be_querried_from_touchpad)
+{
+    MirInputDeviceId const device_id{17};
+    mi::DefaultDevice dev(device_id, queue, touchpad, mt::fake_shared(key_mapper), change_callback);
+
+    auto dev_info = touchpad.get_device_info();
+    MirInputDevice conf(device_id, dev_info.capabilities, dev_info.name, dev_info.unique_id);
+    MirTouchpadConfig const tpd_conf{
+        mir_touchpad_click_mode_finger_count,
+        mir_touchpad_scroll_mode_edge_scroll,
+        0,
+        false,
+        true,
+        true,
+        true};
+    MirPointerConfig const ptr_conf{
+        mir_pointer_handedness_right,
+        mir_pointer_acceleration_adaptive,
+        0.5,
+        -1.0,
+        1.0};
+
+    conf.set_touchpad_config(tpd_conf);
+    conf.set_pointer_config(ptr_conf);
+
+    dev.apply_touchpad_configuration(tpd_conf);
+    dev.apply_pointer_configuration(ptr_conf);
+
+    EXPECT_EQ(conf, dev.config());
+}
+
+TEST_F(DefaultDevice, device_config_can_be_querried_from_pointer_device)
+{
+    MirInputDeviceId const device_id{11};
+    mi::DefaultDevice dev(device_id, queue, mouse, mt::fake_shared(key_mapper), change_callback);
+
+    auto dev_info = mouse.get_device_info();
+    MirInputDevice conf(device_id, dev_info.capabilities, dev_info.name, dev_info.unique_id);
+    MirPointerConfig const ptr_config{
+        mir_pointer_handedness_left,
+        mir_pointer_acceleration_none,
+        0,
+        1.0,
+        1.0};
+
+    conf.set_pointer_config(ptr_config);
+    dev.apply_pointer_configuration(ptr_config);
+
+    EXPECT_EQ(conf, dev.config());
+}
+
+TEST_F(DefaultDevice, device_config_can_be_querried_from_keyboard_device)
+{
+    MirInputDeviceId const device_id{3};
+    mi::DefaultDevice dev(device_id, queue, keyboard, mt::fake_shared(key_mapper), change_callback);
+
+    auto dev_info = keyboard.get_device_info();
+    MirInputDevice conf(device_id, dev_info.capabilities, dev_info.name, dev_info.unique_id);
+    MirKeyboardConfig const kbd_config{mi::Keymap{"pc104", "dvorak", "", ""}};
+
+    conf.set_keyboard_config(kbd_config);
+    dev.apply_keyboard_configuration(kbd_config);
+
+    EXPECT_EQ(kbd_config, dev.keyboard_configuration().value());
+}
+
+TEST_F(DefaultDevice, device_config_can_be_querried_from_touchscreen)
+{
+    MirInputDeviceId const device_id{5};
+    mi::DefaultDevice dev(device_id, queue, touchscreen, mt::fake_shared(key_mapper), change_callback);
+
+    auto dev_info = touchscreen.get_device_info();
+    MirInputDevice conf(device_id, dev_info.capabilities, dev_info.name, dev_info.unique_id);
+    MirTouchscreenConfig const ts_config{0, mir_touchscreen_mapping_mode_to_display_wall};
+
+    conf.set_touchscreen_config(ts_config);
+    dev.apply_touchscreen_configuration(ts_config);
+
+    EXPECT_EQ(ts_config, dev.touchscreen_configuration().value());
+}

=== modified file 'tests/unit-tests/input/test_default_input_device_hub.cpp'
--- tests/unit-tests/input/test_default_input_device_hub.cpp	2017-03-13 08:12:52 +0000
+++ tests/unit-tests/input/test_default_input_device_hub.cpp	2017-03-14 20:52:46 +0000
@@ -30,6 +30,7 @@
 #include "mir/test/doubles/triggered_main_loop.h"
 #include "mir/test/event_matchers.h"
 #include "mir/test/fake_shared.h"
+#include "mir/test/fd_utils.h"
 
 #include "mir/dispatch/action_queue.h"
 #include "mir/geometry/rectangles.h"
@@ -77,14 +78,14 @@
 
 struct InputDeviceHubTest : ::testing::Test
 {
-    mtd::TriggeredMainLoop observer_loop;
     std::shared_ptr<mir::cookie::Authority> cookie_authority = mir::cookie::Authority::create();
     mir::dispatch::MultiplexingDispatchable multiplexer;
     NiceMock<mtd::MockInputSeat> mock_seat;
     NiceMock<mtd::MockKeyMapper> mock_key_mapper;
     NiceMock<mtd::MockServerStatusListener> mock_server_status_listener;
     mi::DefaultInputDeviceHub hub{mt::fake_shared(mock_seat), mt::fake_shared(multiplexer),
-                                  mt::fake_shared(observer_loop), cookie_authority, mt::fake_shared(mock_key_mapper), mt::fake_shared(mock_server_status_listener)};
+                                  cookie_authority, mt::fake_shared(mock_key_mapper),
+                                  mt::fake_shared(mock_server_status_listener)};
     NiceMock<mtd::MockInputDeviceObserver> mock_observer;
     NiceMock<mtd::MockInputDevice> device{"device","dev-1", mi::DeviceCapability::unknown};
     NiceMock<mtd::MockInputDevice> another_device{"another_device","dev-2", mi::DeviceCapability::keyboard};
@@ -104,6 +105,12 @@
                                   }
                                  ));
     }
+
+    void expect_and_execute_multiplexer()
+    {
+        mt::fd_becomes_readable(multiplexer.watch_fd(), 2s);
+        multiplexer.dispatch(mir::dispatch::FdEvent::readable);
+    }
 };
 
 TEST_F(InputDeviceHubTest, input_device_hub_starts_device)
@@ -161,8 +168,7 @@
     hub.add_device(mt::fake_shared(another_device));
     hub.add_observer(mt::fake_shared(mock_observer));
 
-    observer_loop.trigger_server_actions();
-
+    expect_and_execute_multiplexer();
     EXPECT_THAT(handle_1,Ne(handle_2));
     EXPECT_THAT(handle_1->unique_id(),Ne(handle_2->unique_id()));
 }
@@ -208,10 +214,13 @@
     EXPECT_CALL(mock_observer, changes_complete());
 
     hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
+
     hub.add_device(mt::fake_shared(device));
+    expect_and_execute_multiplexer();
+
     hub.remove_device(mt::fake_shared(device));
-
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
 }
 
 TEST_F(InputDeviceHubTest, emit_ready_to_receive_input_after_first_device_added)
@@ -219,8 +228,6 @@
     EXPECT_CALL(mock_server_status_listener, ready_for_user_input()).Times(1);
     hub.add_device(mt::fake_shared(device));
     hub.add_device(mt::fake_shared(another_device));
-
-    observer_loop.trigger_server_actions();
 }
 
 TEST_F(InputDeviceHubTest, emit_stop_receiving_input_after_last_device_added)
@@ -231,7 +238,6 @@
 
     hub.remove_device(mt::fake_shared(device));
     hub.remove_device(mt::fake_shared(another_device));
-    observer_loop.trigger_server_actions();
 }
 
 TEST_F(InputDeviceHubTest, when_pointer_configuration_is_applied_successfully_observer_is_triggerd)
@@ -243,13 +249,13 @@
 
     hub.add_device(mt::fake_shared(mouse));
     hub.add_observer(mt::fake_shared(mock_observer));
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
 
     EXPECT_CALL(mock_observer, device_changed(WithName("mouse")));
     EXPECT_CALL(mock_observer, changes_complete());
 
     dev_ptr->apply_pointer_configuration(pointer_conf);
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
 }
 
 TEST_F(InputDeviceHubTest, when_tpd_configuration_is_applied_successfully_observer_is_triggerd)
@@ -261,13 +267,13 @@
 
     hub.add_device(mt::fake_shared(touchpad));
     hub.add_observer(mt::fake_shared(mock_observer));
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
 
     EXPECT_CALL(mock_observer, device_changed(WithName("tpd")));
     EXPECT_CALL(mock_observer, changes_complete());
 
     dev_ptr->apply_touchpad_configuration(tpd_conf);
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
 }
 
 TEST_F(InputDeviceHubTest, when_configuration_attempt_fails_observer_is_not_triggerd)
@@ -279,12 +285,58 @@
 
     hub.add_device(mt::fake_shared(mouse));
     hub.add_observer(mt::fake_shared(mock_observer));
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
 
     EXPECT_CALL(mock_observer, device_changed(WithName("mouse"))).Times(0);
     EXPECT_CALL(mock_observer, changes_complete()).Times(0);
 
     try {dev_ptr->apply_touchpad_configuration(tpd_conf); } catch (...) {}
-    observer_loop.trigger_server_actions();
+    expect_and_execute_multiplexer();
     ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
 }
+
+TEST_F(InputDeviceHubTest, restores_device_id_when_device_reappears)
+{
+    std::shared_ptr<mi::Device> dev_ptr;
+
+    ON_CALL(mock_observer, device_added(WithName("mouse"))).WillByDefault(SaveArg<0>(&dev_ptr));
+
+    hub.add_device(mt::fake_shared(mouse));
+    hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
+
+    auto device_id = dev_ptr->id();
+
+    hub.remove_device(mt::fake_shared(mouse));
+    dev_ptr.reset();
+    hub.add_device(mt::fake_shared(mouse));
+
+    ASSERT_THAT(dev_ptr, Ne(nullptr));
+
+    EXPECT_THAT(dev_ptr->id(), Eq(device_id));
+}
+
+TEST_F(InputDeviceHubTest, restores_configuration_when_device_reappears)
+{
+    std::shared_ptr<mi::Device> dev_ptr;
+    MirPointerConfig ptr_config;
+    ptr_config.handedness(mir_pointer_handedness_left);
+    ptr_config.acceleration(mir_pointer_acceleration_adaptive);
+    ptr_config.cursor_acceleration_bias(0.6);
+
+    ON_CALL(mock_observer, device_added(WithName("mouse"))).WillByDefault(SaveArg<0>(&dev_ptr));
+
+    hub.add_device(mt::fake_shared(mouse));
+    hub.add_observer(mt::fake_shared(mock_observer));
+    expect_and_execute_multiplexer();
+
+    dev_ptr->apply_pointer_configuration(ptr_config);
+
+    hub.remove_device(mt::fake_shared(mouse));
+    dev_ptr.reset();
+    hub.add_device(mt::fake_shared(mouse));
+
+    ASSERT_THAT(dev_ptr, Ne(nullptr));
+
+    EXPECT_THAT(dev_ptr->pointer_configuration().value(), Eq(ptr_config));
+}

=== added file 'tests/unit-tests/input/test_external_input_device_hub.cpp'
--- tests/unit-tests/input/test_external_input_device_hub.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/input/test_external_input_device_hub.cpp	2017-03-14 20:52:46 +0000
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2017 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
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "src/server/input/default_input_device_hub.h"
+#include "mir/test/doubles/mock_input_device_hub.h"
+#include "mir/test/doubles/mock_device.h"
+#include "mir/test/doubles/mock_input_device_observer.h"
+#include "mir/test/doubles/triggered_main_loop.h"
+#include "mir/test/fake_shared.h"
+
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
+namespace mi = mir::input;
+using namespace testing;
+
+namespace
+{
+
+struct WrappedHub : mtd::MockInputDeviceHub
+{
+    std::shared_ptr<mi::InputDeviceObserver> external_hub;
+    void add_observer(std::shared_ptr<mi::InputDeviceObserver> const& observer)
+    {
+        external_hub = observer;
+    }
+};
+
+struct ExternalInputDeviceHub : ::testing::Test
+{
+    mtd::TriggeredMainLoop server_actions;
+    std::shared_ptr<WrappedHub> wrapped_hub{std::make_shared<WrappedHub>()};
+    mi::ExternalInputDeviceHub hub{wrapped_hub, mt::fake_shared(server_actions)};
+    NiceMock<mtd::MockInputDeviceObserver> mock_observer;
+
+    NiceMock<mtd::MockDevice> device{1, mi::DeviceCapability::unknown, "name", "name-id-1"};
+    NiceMock<mtd::MockDevice> another_device{2, mi::DeviceCapability::keyboard, "keyboard", "keyboard-id-2"};
+
+    void submit_device_to_hub(std::shared_ptr<mi::Device> const& dev)
+    {
+        wrapped_hub->external_hub->device_added(dev);
+        wrapped_hub->external_hub->changes_complete();
+    }
+
+    void remove_device_to_hub(std::shared_ptr<mi::Device> const& dev)
+    {
+        wrapped_hub->external_hub->device_removed(dev);
+        wrapped_hub->external_hub->changes_complete();
+    }
+};
+}
+
+TEST_F(ExternalInputDeviceHub, is_observer_to_wrapped_hub)
+{
+    EXPECT_THAT(wrapped_hub->external_hub, Ne(nullptr));
+}
+
+TEST_F(ExternalInputDeviceHub, new_observer_is_called_through_server_action)
+{
+    EXPECT_CALL(mock_observer, changes_complete()).Times(1);
+    hub.add_observer(mt::fake_shared(mock_observer));
+    server_actions.trigger_server_actions();
+}
+
+TEST_F(ExternalInputDeviceHub, informs_observer_about_existing_devices)
+{
+    submit_device_to_hub(mt::fake_shared(device));
+    submit_device_to_hub(mt::fake_shared(another_device));
+
+    EXPECT_CALL(mock_observer, device_added(_)).Times(2);
+    EXPECT_CALL(mock_observer, changes_complete()).Times(1);
+    hub.add_observer(mt::fake_shared(mock_observer));
+    server_actions.trigger_server_actions();
+}
+
+TEST_F(ExternalInputDeviceHub, informs_observer_about_added_devices)
+{
+    InSequence seq;
+
+    EXPECT_CALL(mock_observer, changes_complete());
+    EXPECT_CALL(mock_observer, device_added(_));
+    EXPECT_CALL(mock_observer, changes_complete());
+    hub.add_observer(mt::fake_shared(mock_observer));
+    server_actions.trigger_server_actions();
+
+    submit_device_to_hub(mt::fake_shared(device));
+
+    server_actions.trigger_server_actions();
+}
+
+TEST_F(ExternalInputDeviceHub, triggers_observer_on_removed_devices)
+{
+    submit_device_to_hub(mt::fake_shared(device));
+
+    EXPECT_CALL(mock_observer, device_added(_)).Times(1);
+    EXPECT_CALL(mock_observer, changes_complete()).Times(1);
+    hub.add_observer(mt::fake_shared(mock_observer));
+    server_actions.trigger_server_actions();
+
+    EXPECT_CALL(mock_observer, device_removed(_)).Times(1);
+    EXPECT_CALL(mock_observer, changes_complete()).Times(1);
+
+    remove_device_to_hub(mt::fake_shared(device));
+    server_actions.trigger_server_actions();
+}