Merge lp:~morphis/aethercast/input-provider-support into lp:aethercast

[Simon Fels]

Add input provider support

[Simon Fels (morphis)]

Still WIP.

review: Needs Fixing

[lp:~morphis/aethercast/input-provider-support]

119. By Simon Fels on 2015-12-16

Merge trunk

120. By Simon Fels on 2015-12-16

Fix problems after merge

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:120
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~morphis/aethercast/input-provider-support/+merge/280746/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/aethercast-ci/15/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/15
        deb: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/15/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-i386-ci/15

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/aethercast-ci/15/rebuild

review: Needs Fixing (continuous-integration)

[lp:~morphis/aethercast/input-provider-support]

121. By Simon Fels on 2015-12-17

Wrap input provider into service and add channel implementation + tests

122. By Simon Fels on 2015-12-17

Fix ForwardingMiracastController tests

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:122
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~morphis/aethercast/input-provider-support/+merge/280746/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/aethercast-ci/16/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-amd64-ci/16/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/16/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-i386-ci/16/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/aethercast-ci/16/rebuild

review: Needs Fixing (continuous-integration)

[lp:~morphis/aethercast/input-provider-support]

123. By Simon Fels on 2015-12-18

Correct InputEventChannel unit tests to pass fully

124. By Simon Fels on 2015-12-18

Process real input events

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:124
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~morphis/aethercast/input-provider-support/+merge/280746/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/aethercast-ci/17/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-amd64-ci/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/17
        deb: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/17/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-i386-ci/17

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/aethercast-ci/17/rebuild

review: Needs Fixing (continuous-integration)

[lp:~morphis/aethercast/input-provider-support]

125. By Simon Fels on 2015-12-18

Properly register input provider

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:125
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~morphis/aethercast/input-provider-support/+merge/280746/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/aethercast-ci/18/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-amd64-ci/18
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/18
        deb: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-armhf-ci/18/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/aethercast-vivid-i386-ci/18

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/aethercast-ci/18/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

125. By Simon Fels on 2015-12-18

Properly register input provider

124. By Simon Fels on 2015-12-18

Process real input events

123. By Simon Fels on 2015-12-18

Correct InputEventChannel unit tests to pass fully

122. By Simon Fels on 2015-12-17

Fix ForwardingMiracastController tests

121. By Simon Fels on 2015-12-17

Wrap input provider into service and add channel implementation + tests

120. By Simon Fels on 2015-12-16

Fix problems after merge

119. By Simon Fels on 2015-12-16

Merge trunk

118. By Simon Fels on 2015-12-16

First part of input provider infrastructure

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-12-10 06:47:03 +0000
+++ CMakeLists.txt	2015-12-18 16:38:21 +0000
@@ -64,6 +64,7 @@
 pkg_check_modules(GST REQUIRED gstreamer-1.0)
 pkg_check_modules(WDS REQUIRED wds)
 pkg_check_modules(READLINE readline)
+
 # Build with system gmock and embedded gtest
 set (GMOCK_INCLUDE_DIR "/usr/include/gmock/include" CACHE PATH "gmock source include directory")
 set (GMOCK_SOURCE_DIR "/usr/src/gmock" CACHE PATH "gmock source directory")

=== modified file 'data/org.aethercast.xml'
--- data/org.aethercast.xml	2015-12-10 17:13:50 +0000
+++ data/org.aethercast.xml	2015-12-18 16:38:21 +0000
@@ -9,10 +9,25 @@
             <arg name="path" type="o" direction="in"/>
         </method>
         <method name="Scan"/>
+        <method name="RegisterInputProvider">
+            <arg name="path" type="o" direction="in"/>
+            <arg name="options" type="a{sv}" direction="in"/>
+        </method>
+        <method name="UnregisterInputProvider">
+            <arg name="path" type="o" direction="in"/>
+        </method>
         <property name="State" type="s" access="read"/>
         <property name="Capabilities" type="as" access="read"/>
         <property name="Scanning" type="b" access="read"/>
     </interface>
+    <interface name="org.aethercast.InputProvider">
+        <method name="NewConnection">
+            <arg name="fd" type="h" direction="in"/>
+            <arg name="options" type="a{sv}" direction="in"/>
+        </method>
+        <method name="RequestDisconnection"/>
+        <property name="cursor" type="s" access="read"/>
+    </interface>
     <interface name="org.aethercast.Device">
         <method name="Connect">
             <arg name="role" type="s" direction="in"/>

=== modified file 'docs/input-provider.txt'
--- docs/input-provider.txt	2015-12-16 11:54:08 +0000
+++ docs/input-provider.txt	2015-12-18 16:38:21 +0000
@@ -43,7 +43,7 @@
 			This method gets called when the input provider is
 			unregistered and can be used to perform cleanup tasks.
 
-		void NewConnection(object device, fd, dict options)
+                void NewConnection(fd, dict options)
 
 			This methods gets called when a connection to a remote
 			display is established.
@@ -51,7 +51,7 @@
 			Possible errors: org.aethercast.Error.Rejected
 			                 org.aethercast.Error.Canceled
 
-		void RequestDisconnection(object device)
+                void RequestDisconnection()
 
 			This methods gets called when a device gets disconnected.
 

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-12-12 20:22:35 +0000
+++ src/CMakeLists.txt	2015-12-18 16:38:21 +0000
@@ -17,9 +17,12 @@
     mcs/keep_alive.h
     mcs/mac_address.h
     mcs/types.h
+    mcs/dbus_types.h
 )
 
 set(SOURCES
+  mcs/withdelegate.cpp
+  mcs/inputeventchannel.cpp
   mcs/utils.cpp
   mcs/networkutils.cpp
   mcs/mediamanagerfactory.cpp
@@ -37,10 +40,12 @@
   mcs/networkmanager.cpp
   mcs/networkmanagerfactory.cpp
   mcs/networkdevice.cpp
+  mcs/inputprovider.cpp
 
   ${CMAKE_CURRENT_BINARY_DIR}/mcs/aethercastinterface.c
   mcs/dbushelpers.cpp
   mcs/networkdeviceadapter.cpp
+  mcs/inputproviderstub.cpp
 
   wpa/gdhcp/common.c
   wpa/gdhcp/ipv4ll.c

=== added file 'src/mcs/dbus_types.h'
--- src/mcs/dbus_types.h	1970-01-01 00:00:00 +0000
+++ src/mcs/dbus_types.h	2015-12-18 16:38:21 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#ifndef DBUS_TYPES_H_
+#define DBUS_TYPES_H_
+
+#include <string>
+
+namespace mcs {
+namespace dbus {
+
+typedef std::string ObjectPath;
+
+} // namespace dbus
+} // namespace mcs
+
+#endif

=== modified file 'src/mcs/forwardingmiracastcontroller.cpp'
--- src/mcs/forwardingmiracastcontroller.cpp	2015-12-11 22:02:52 +0000
+++ src/mcs/forwardingmiracastcontroller.cpp	2015-12-18 16:38:21 +0000
@@ -57,4 +57,16 @@
 bool ForwardingMiracastController::Scanning() const {
     return fwd_->Scanning();
 }
+
+bool ForwardingMiracastController::HasInputProvider() const {
+    return fwd_->HasInputProvider();
+}
+
+void ForwardingMiracastController::SetInputProvider(const InputProvider::Ptr &provider) {
+    fwd_->SetInputProvider(provider);
+}
+
+void ForwardingMiracastController::ResetInputProvider() {
+    fwd_->ResetInputProvider();
+}
 }

=== modified file 'src/mcs/forwardingmiracastcontroller.h'
--- src/mcs/forwardingmiracastcontroller.h	2015-12-11 22:02:52 +0000
+++ src/mcs/forwardingmiracastcontroller.h	2015-12-18 16:38:21 +0000
@@ -38,6 +38,10 @@
     virtual std::vector<NetworkDeviceRole> SupportedRoles() const override;
     virtual bool Scanning() const override;
 
+    virtual bool HasInputProvider() const;
+    virtual void SetInputProvider(const InputProvider::Ptr &provider);
+    virtual void ResetInputProvider();
+
 private:
     MiracastController::Ptr fwd_;
 };

=== added file 'src/mcs/inputeventchannel.cpp'
--- src/mcs/inputeventchannel.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/inputeventchannel.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+#include <linux/input.h>
+
+#include "inputeventchannel.h"
+#include "keep_alive.h"
+#include "logger.h"
+
+namespace mcs {
+
+std::ostream& operator<<(std::ostream& out, const InputEvent& e)
+{
+  return out << "["
+             << e.when.count() << " "
+             << e.type << " "
+             << e.code << " "
+             << e.value
+             << "]";
+}
+
+InputEventChannel::InputEventChannel() :
+    local_fd_(0),
+    remote_fd_(0),
+    channel_(nullptr),
+    channel_watch_(0) {
+}
+
+InputEventChannel::~InputEventChannel() {
+    if (channel_watch_ > 0)
+        g_source_remove(channel_watch_);
+
+    if (channel_)
+        g_io_channel_unref(channel_);
+
+    if (local_fd_ > 0)
+        ::close(local_fd_);
+
+    if (remote_fd_ > 0)
+        ::close(remote_fd_);
+}
+
+std::shared_ptr<InputEventChannel> InputEventChannel::Create() {
+    return std::shared_ptr<InputEventChannel>(new InputEventChannel)->FinalizeConstruction();
+}
+
+InputEvent InputEventChannel::ReadNextEvent() {
+    struct input_event ev;
+
+    ssize_t bytes_read = ::read(local_fd_, &ev, sizeof(ev));
+    if (bytes_read <= 0)
+        return InputEvent{};
+
+    return InputEvent{std::chrono::milliseconds(0), ev.type, ev.code, ev.value};
+}
+
+gboolean InputEventChannel::OnActivity(GIOChannel *channel, GIOCondition condition, gpointer user_data) {
+    auto inst = static_cast<WeakKeepAlive<InputEventChannel>*>(user_data)->GetInstance().lock();
+
+    if (condition & G_IO_HUP) {
+        if (auto sp = inst->delegate_.lock())
+            sp->OnChannelClosed();
+
+        return TRUE;
+    }
+
+    auto event = inst->ReadNextEvent();
+
+    if (auto sp = inst->delegate_.lock())
+        sp->OnEvent(event);
+
+    return TRUE;
+}
+
+std::shared_ptr<InputEventChannel> InputEventChannel::FinalizeConstruction() {
+    auto sp = shared_from_this();
+
+    int endpoints[2] = {0, 0};
+
+     if (::socketpair(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK, 0, endpoints) < 0) {
+        ERROR("Failed to create socket pair");
+        return sp;
+     }
+
+     local_fd_ = endpoints[0];
+     remote_fd_ = endpoints[1];
+
+     channel_ = g_io_channel_unix_new(local_fd_);
+     channel_watch_ = g_io_add_watch_full(channel_, 0, (GIOCondition) (G_IO_IN | G_IO_HUP | G_IO_ERR),
+                                          &InputEventChannel::OnActivity,
+                                          new WeakKeepAlive<InputEventChannel>{sp},
+                                          [](gpointer data) { delete static_cast<WeakKeepAlive<InputEventChannel>*>(data); });
+     if (channel_watch_ == 0) {
+         ERROR("Failed to input channel watch");
+         return sp;
+     }
+
+    return sp;
+}
+
+int InputEventChannel::RemoteEndpoint() {
+    return remote_fd_;
+}
+
+} // namespace mcs

=== added file 'src/mcs/inputeventchannel.h'
--- src/mcs/inputeventchannel.h	1970-01-01 00:00:00 +0000
+++ src/mcs/inputeventchannel.h	2015-12-18 16:38:21 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#ifndef INPUTEVENTCHANNEL_H_
+#define INPUTEVENTCHANNEL_H_
+
+#include <glib.h>
+
+#include <memory>
+#include <chrono>
+
+#include "non_copyable.h"
+#include "withdelegate.h"
+
+namespace mcs {
+
+struct InputEvent {
+    std::chrono::milliseconds when;
+    std::uint16_t type;
+    std::uint16_t code;
+    std::uint32_t value;
+};
+
+std::ostream& operator<<(std::ostream& out, const InputEvent& e);
+
+class InputEventChannelDelegate : public mcs::NonCopyable {
+public:
+    virtual ~InputEventChannelDelegate() { }
+    virtual void OnChannelClosed() = 0;
+    virtual void OnEvent(const InputEvent &event) = 0;
+};
+
+class InputEventChannel : public std::enable_shared_from_this<InputEventChannel>,
+                          public mcs::WithDelegate<InputEventChannelDelegate> {
+public:
+    static std::shared_ptr<InputEventChannel> Create();
+
+    ~InputEventChannel();
+
+    int RemoteEndpoint();
+
+private:
+    InputEventChannel();
+    std::shared_ptr<InputEventChannel> FinalizeConstruction();
+
+    InputEvent ReadNextEvent();
+
+private:
+    static gboolean OnActivity(GIOChannel *channel, GIOCondition condition, gpointer user_data);
+
+private:
+    int local_fd_;
+    int remote_fd_;
+    GIOChannel *channel_;
+    guint channel_watch_;
+};
+
+} // namespace mcs
+
+#endif

=== added file 'src/mcs/inputprovider.cpp'
--- src/mcs/inputprovider.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/inputprovider.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include "inputprovider.h"

=== added file 'src/mcs/inputprovider.h'
--- src/mcs/inputprovider.h	1970-01-01 00:00:00 +0000
+++ src/mcs/inputprovider.h	2015-12-18 16:38:21 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#ifndef INPUTPROVIDER_H_
+#define INPUTPROVIDER_H_
+
+#include <memory>
+
+#include "non_copyable.h"
+#include "withdelegate.h"
+
+namespace mcs {
+
+class InputProviderDelegate : public mcs::NonCopyable {
+public:
+    virtual ~InputProviderDelegate() { }
+    virtual void OnConnectedChanged() = 0;
+};
+
+class InputProvider : public mcs::WithDelegate<InputProviderDelegate> {
+public:
+    typedef std::shared_ptr<InputProvider> Ptr;
+
+    virtual bool NewConnection(int fd) = 0;
+    virtual void RequestDisconnection() = 0;
+
+    virtual bool Connected() const = 0;
+};
+
+} // namespace mcs
+
+#endif

=== added file 'src/mcs/inputproviderstub.cpp'
--- src/mcs/inputproviderstub.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/inputproviderstub.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include <boost/concept_check.hpp>
+
+#include "inputproviderstub.h"
+#include "keep_alive.h"
+#include "logger.h"
+
+namespace mcs {
+namespace dbus {
+
+std::shared_ptr<InputProviderStub> InputProviderStub::Create(const SharedGObject<GDBusConnection> &connection, const ObjectPath &path) {
+    return std::shared_ptr<InputProviderStub>(new InputProviderStub(path))->FinalizeConstruction(connection);
+}
+
+InputProviderStub::InputProviderStub(const ObjectPath &path) :
+    path_(path),
+    proxy_(nullptr),
+    connected_(false) {
+}
+
+InputProviderStub::~InputProviderStub() {
+}
+
+void InputProviderStub::RequestDisconnection() {
+    if (!connected_)
+        return;
+
+    auto sp = shared_from_this();
+
+    aethercast_interface_input_provider_call_request_disconnection(proxy_,
+                                                                   nullptr,
+                                                                   InputProviderStub::OnNewConnectionFinish,
+                                                                   new SharedKeepAlive<InputProviderStub>{sp});
+}
+
+void InputProviderStub::OnRequestDisconnectionFinish(GObject *object, GAsyncResult *res, gpointer user_data) {
+    boost::ignore_unused_variable_warning(object);
+
+    auto inst = static_cast<SharedKeepAlive<InputProviderStub>*>(user_data)->ShouldDie();
+
+    GError *error = nullptr;
+    if (!aethercast_interface_input_provider_call_request_disconnection_finish(inst->proxy_, res, &error)) {
+        ERROR("Failed to request disconnection of the input provider %s: %s", inst->path_, error->message);
+        g_error_free(error);
+        return;
+    }
+
+    inst->connected_ = false;
+
+    if (auto sp = inst->delegate_.lock())
+        sp->OnConnectedChanged();
+}
+
+bool InputProviderStub::NewConnection(int fd) {
+    if (connected_)
+        return false;
+
+    auto sp = shared_from_this();
+
+    aethercast_interface_input_provider_call_new_connection(proxy_,
+                                                            g_variant_new_handle(fd),
+                                                            nullptr, // We don't have any options to provide yet
+                                                            nullptr,
+                                                            InputProviderStub::OnNewConnectionFinish,
+                                                            new SharedKeepAlive<InputProviderStub>{sp});
+
+    return true;
+}
+
+void InputProviderStub::OnNewConnectionFinish(GObject *object, GAsyncResult *res, gpointer user_data) {
+    boost::ignore_unused_variable_warning(object);
+
+    auto inst = static_cast<SharedKeepAlive<InputProviderStub>*>(user_data)->ShouldDie();
+
+    GError *error = nullptr;
+    if (!aethercast_interface_input_provider_call_new_connection_finish(inst->proxy_, res, &error)) {
+        ERROR("Failed to signal a new connection to the input provider %s: %s", inst->path_, error->message);
+        g_error_free(error);
+        return;
+    }
+
+    inst->connected_ = true;
+
+    if (auto sp = inst->delegate_.lock())
+        sp->OnConnectedChanged();
+}
+
+void InputProviderStub::OnProxyConnected(GObject *object, GAsyncResult *res, gpointer user_data) {
+    boost::ignore_unused_variable_warning(object);
+
+    auto inst = static_cast<SharedKeepAlive<InputProviderStub>*>(user_data)->ShouldDie();
+
+    GError *error = nullptr;
+    inst->proxy_ = aethercast_interface_input_provider_proxy_new_finish(res, &error);
+    if (!inst->proxy_) {
+        ERROR("Failed to connect with input provider %s: %s", inst->path_, error->message);
+        g_error_free(error);
+        return;
+    }
+}
+
+std::shared_ptr<InputProviderStub> InputProviderStub::FinalizeConstruction(const SharedGObject<GDBusConnection> &connection) {
+    auto sp = shared_from_this();
+
+    aethercast_interface_input_provider_proxy_new(connection.get(),
+                                                  G_DBUS_PROXY_FLAGS_NONE,
+                                                  nullptr,
+                                                  path_.c_str(),
+                                                  nullptr,
+                                                  &InputProviderStub::OnProxyConnected,
+                                                  new SharedKeepAlive<InputProviderStub>{sp});
+
+    return sp;
+}
+
+bool InputProviderStub::Connected() const {
+    return connected_;
+}
+
+} // namespace dbus
+} // namespace mcs

=== added file 'src/mcs/inputproviderstub.h'
--- src/mcs/inputproviderstub.h	1970-01-01 00:00:00 +0000
+++ src/mcs/inputproviderstub.h	2015-12-18 16:38:21 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#ifndef INPUTPROVIDERSTUB_H_
+#define INPUTPROVIDERSTUB_H_
+
+#include <memory>
+
+#include "inputprovider.h"
+
+#include "dbus_types.h"
+#include "shared_gobject.h"
+
+extern "C" {
+#include "aethercastinterface.h"
+}
+
+namespace mcs {
+namespace dbus {
+
+class InputProviderStub : public std::enable_shared_from_this<InputProviderStub>,
+                          public InputProvider {
+public:
+    static constexpr const char *kManagerIface{"org.aethercast.InputProvider"};
+
+    static std::shared_ptr<InputProviderStub> Create(const SharedGObject<GDBusConnection> &connection, const ObjectPath &path);
+
+    ~InputProviderStub();
+
+    bool NewConnection(int fd);
+    void RequestDisconnection();
+
+    bool Connected() const override;
+
+private:
+    InputProviderStub(const ObjectPath &path);
+    std::shared_ptr<InputProviderStub> FinalizeConstruction(const SharedGObject<GDBusConnection> &connection);
+
+private:
+    static void OnProxyConnected(GObject *object, GAsyncResult *res, gpointer user_data);
+    static void OnNewConnectionFinish(GObject *object, GAsyncResult *res, gpointer user_data);
+    static void OnRequestDisconnectionFinish(GObject *object, GAsyncResult *res, gpointer user_data);
+
+private:
+    std::string path_;
+    AethercastInterfaceInputProvider *proxy_;
+    bool connected_;
+};
+
+} // namespace dbus
+} // namespace mcs
+
+#endif

=== modified file 'src/mcs/miracastcontroller.cpp'
--- src/mcs/miracastcontroller.cpp	2015-12-11 21:10:24 +0000
+++ src/mcs/miracastcontroller.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */

=== modified file 'src/mcs/miracastcontroller.h'
--- src/mcs/miracastcontroller.h	2015-12-11 21:10:24 +0000
+++ src/mcs/miracastcontroller.h	2015-12-18 16:38:21 +0000
@@ -22,6 +22,7 @@
 #include <memory>
 
 #include "networkdevice.h"
+#include "inputprovider.h"
 #include "non_copyable.h"
 #include "types.h"
 
@@ -57,6 +58,10 @@
     virtual std::vector<NetworkDeviceRole> SupportedRoles() const = 0;
     virtual bool Scanning() const = 0;
 
+    virtual bool HasInputProvider() const = 0;
+    virtual void SetInputProvider(const InputProvider::Ptr &provider) = 0;
+    virtual void ResetInputProvider() = 0;
+
 protected:
 
 };

=== modified file 'src/mcs/miracastcontrollerskeleton.cpp'
--- src/mcs/miracastcontrollerskeleton.cpp	2015-12-16 14:59:45 +0000
+++ src/mcs/miracastcontrollerskeleton.cpp	2015-12-18 16:38:21 +0000
@@ -23,6 +23,8 @@
 #include <boost/concept_check.hpp>
 
 #include "miracastcontrollerskeleton.h"
+#include "inputproviderstub.h"
+
 #include "keep_alive.h"
 #include "utils.h"
 #include "dbushelpers.h"
@@ -114,13 +116,18 @@
     SyncProperties();
 }
 
+#define CONNECT_HANDLER(signal, callback) \
+    g_signal_connect_data(inst->manager_obj_.get(), signal, \
+                     G_CALLBACK(&MiracastControllerSkeleton::callback), new WeakKeepAlive<MiracastControllerSkeleton>(inst), \
+                     [](gpointer data, GClosure *) { delete static_cast<WeakKeepAlive<MiracastControllerSkeleton>*>(data); }, GConnectFlags(0))
+
 void MiracastControllerSkeleton::OnNameAcquired(GDBusConnection *connection, const gchar *name, gpointer user_data) {
     auto inst = static_cast<SharedKeepAlive<MiracastControllerSkeleton>*>(user_data)->ShouldDie();
     inst->manager_obj_.reset(aethercast_interface_manager_skeleton_new());
 
-    g_signal_connect_data(inst->manager_obj_.get(), "handle-scan",
-                     G_CALLBACK(&MiracastControllerSkeleton::OnHandleScan), new WeakKeepAlive<MiracastControllerSkeleton>(inst),
-                     [](gpointer data, GClosure *) { delete static_cast<WeakKeepAlive<MiracastControllerSkeleton>*>(data); }, GConnectFlags(0));
+    CONNECT_HANDLER("handle-scan", OnHandleScan);
+    CONNECT_HANDLER("handle-register-input-provider", OnHandleRegisterInputProvider);
+    CONNECT_HANDLER("handle-unregister-input-provider", OnHandleUnregisterInputProvider);
 
     inst->SyncProperties();
 
@@ -152,6 +159,62 @@
     return TRUE;
 }
 
+gboolean MiracastControllerSkeleton::OnHandleRegisterInputProvider(AethercastInterfaceManager *skeleton,
+                                                               GDBusMethodInvocation *invocation,
+                                                               const char *path, GVariant *options,
+                                                               gpointer user_data) {
+    boost::ignore_unused_variable_warning(skeleton);
+    auto inst = static_cast<WeakKeepAlive<MiracastControllerSkeleton>*>(user_data)->GetInstance().lock();
+
+    if (not inst) {
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid state");
+        return TRUE;
+    }
+
+    DEBUG("Got request for new input provider %s", path);
+
+    if (inst->HasInputProvider()) {
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
+                                              "Input provider is already registered");
+        return TRUE;
+    }
+
+    auto provider = mcs::dbus::InputProviderStub::Create(inst->bus_connection_, mcs::dbus::ObjectPath(path));
+
+    inst->SetInputProvider(provider);
+
+    g_dbus_method_invocation_return_value(invocation, nullptr);
+
+    return TRUE;
+}
+
+gboolean MiracastControllerSkeleton::OnHandleUnregisterInputProvider(AethercastInterfaceManager *skeleton,
+                                                                 GDBusMethodInvocation *invocation,
+                                                                 const char *path,
+                                                                 gpointer user_data) {
+    boost::ignore_unused_variable_warning(skeleton);
+    auto inst = static_cast<WeakKeepAlive<MiracastControllerSkeleton>*>(user_data)->GetInstance().lock();
+
+    if (not inst) {
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid state");
+        return TRUE;
+    }
+
+    DEBUG("Got request to remove input provider %s", path);
+
+    if (!inst->HasInputProvider()) {
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
+                                              "Input provider is not registered");
+        return TRUE;
+    }
+
+    inst->ResetInputProvider();
+
+    g_dbus_method_invocation_return_value(invocation, nullptr);
+
+    return TRUE;
+}
+
 std::shared_ptr<MiracastControllerSkeleton> MiracastControllerSkeleton::FinalizeConstruction() {
     auto sp = shared_from_this();
 

=== modified file 'src/mcs/miracastcontrollerskeleton.h'
--- src/mcs/miracastcontrollerskeleton.h	2015-12-16 14:59:45 +0000
+++ src/mcs/miracastcontrollerskeleton.h	2015-12-18 16:38:21 +0000
@@ -18,13 +18,9 @@
 #ifndef MIRACASTSERVICEADAPTOR_H_
 #define MIRACASTSERVICEADAPTOR_H_
 
-#ifdef __cplusplus
 extern "C" {
-#endif
 #include "aethercastinterface.h"
-#ifdef __cplusplus
 }
-#endif
 
 #include <memory>
 #include <unordered_map>
@@ -59,6 +55,14 @@
     static gboolean OnHandleScan(AethercastInterfaceManager *skeleton, GDBusMethodInvocation *invocation,
                                  gpointer user_data);
 
+    static gboolean OnHandleRegisterInputProvider(AethercastInterfaceManager *skeleton, GDBusMethodInvocation *invocation,
+                                                  const char *path, GVariant *options,
+                                                  gpointer user_data);
+
+    static gboolean OnHandleUnregisterInputProvider(AethercastInterfaceManager *skeleton, GDBusMethodInvocation *invocation,
+                                                    const char *path,
+                                                    gpointer user_data);
+
     MiracastControllerSkeleton(const std::shared_ptr<MiracastController> &controller);
     std::shared_ptr<MiracastControllerSkeleton> FinalizeConstruction();
 

=== modified file 'src/mcs/miracastservice.cpp'
--- src/mcs/miracastservice.cpp	2015-12-16 14:59:45 +0000
+++ src/mcs/miracastservice.cpp	2015-12-18 16:38:21 +0000
@@ -346,4 +346,20 @@
 void MiracastService::Scan(const std::chrono::seconds &timeout) {
     network_manager_->Scan(timeout);
 }
+
+bool MiracastService::HasInputProvider() const {
+    return !!input_provider_;
+}
+
+void MiracastService::SetInputProvider(const InputProvider::Ptr &provider) {
+    input_provider_ = provider;
+}
+
+void MiracastService::ResetInputProvider() {
+    if (input_provider_->Connected())
+        input_provider_->RequestDisconnection();
+
+    input_provider_.reset();
+}
+
 } // namespace miracast

=== modified file 'src/mcs/miracastservice.h'
--- src/mcs/miracastservice.h	2015-12-11 21:10:24 +0000
+++ src/mcs/miracastservice.h	2015-12-18 16:38:21 +0000
@@ -30,6 +30,8 @@
 #include "miracastsourcemanager.h"
 #include "networkmanager.h"
 #include "networkdevice.h"
+#include "inputprovider.h"
+
 #include "non_copyable.h"
 #include "types.h"
 
@@ -70,6 +72,10 @@
     std::vector<NetworkDeviceRole> SupportedRoles() const;
     bool Scanning() const;
 
+    bool HasInputProvider() const;
+    void SetInputProvider(const InputProvider::Ptr &provider);
+    void ResetInputProvider();
+
     void OnClientDisconnected();
 
 public:
@@ -101,6 +107,7 @@
     guint scan_timeout_source_;
     ResultCallback current_scan_callback_;
     std::vector<NetworkDeviceRole> supported_roles_;
+    InputProvider::Ptr input_provider_;
 };
 } // namespace mcs
 #endif

=== added file 'src/mcs/withdelegate.cpp'
--- src/mcs/withdelegate.cpp	1970-01-01 00:00:00 +0000
+++ src/mcs/withdelegate.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */

=== added file 'src/mcs/withdelegate.h'
--- src/mcs/withdelegate.h	1970-01-01 00:00:00 +0000
+++ src/mcs/withdelegate.h	2015-12-18 16:38:21 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#ifndef WITHDELEGATE_H_
+#define WITHDELEGATE_H_
+
+#include <memory>
+
+namespace mcs {
+
+template <typename T>
+class WithDelegate {
+public:
+    void SetDelegate(const std::weak_ptr<T> &delegate) { delegate_ = delegate; }
+    void ResetDelegate() { delegate_.reset(); }
+
+protected:
+    std::weak_ptr<T> delegate_;
+};
+
+} // namespace mcs
+
+#endif

=== modified file 'tests/mcs/CMakeLists.txt'
--- tests/mcs/CMakeLists.txt	2015-12-11 22:02:52 +0000
+++ tests/mcs/CMakeLists.txt	2015-12-18 16:38:21 +0000
@@ -24,4 +24,12 @@
 target_link_libraries(miracastcontrollerskeleton_tests aethercast-core gmock gmock_main)
 add_test(miracastcontrollerskeleton_tests miracastcontrollerskeleton_tests)
 
+add_executable(inputeventchannel_tests inputeventchannel_tests.cpp)
+target_link_libraries(inputeventchannel_tests aethercast-core gmock gmock_main)
+add_test(inputeventchannel_tests inputeventchannel_tests)
+
+add_executable(miracastservice_tests miracastservice_tests.cpp)
+target_link_libraries(miracastservice_tests aethercast-core gmock gmock_main)
+add_test(miracastservice_tests miracastservice_tests)
+
 add_subdirectory(acceptance_tests)

=== modified file 'tests/mcs/forwardingmiracastcontroller_tests.cpp'
--- tests/mcs/forwardingmiracastcontroller_tests.cpp	2015-12-11 22:02:52 +0000
+++ tests/mcs/forwardingmiracastcontroller_tests.cpp	2015-12-18 16:38:21 +0000
@@ -32,6 +32,10 @@
     MOCK_CONST_METHOD0(State, mcs::NetworkDeviceState());
     MOCK_CONST_METHOD0(SupportedRoles, std::vector<mcs::NetworkDeviceRole>());
     MOCK_CONST_METHOD0(Scanning, bool());
+
+    MOCK_CONST_METHOD0(HasInputProvider, bool());
+    MOCK_METHOD1(SetInputProvider, void(const mcs::InputProvider::Ptr &));
+    MOCK_METHOD0(ResetInputProvider, void());
 };
 }
 
@@ -52,6 +56,9 @@
     EXPECT_CALL(*impl, State()).Times(1).WillRepeatedly(Return(mcs::NetworkDeviceState::kConnected));
     EXPECT_CALL(*impl, SupportedRoles()).Times(1).WillRepeatedly(Return(std::vector<mcs::NetworkDeviceRole>{mcs::NetworkDeviceRole::kSource}));
     EXPECT_CALL(*impl, Scanning()).Times(1).WillRepeatedly(Return(true));
+    EXPECT_CALL(*impl, HasInputProvider()).Times(1);
+    EXPECT_CALL(*impl, SetInputProvider(_)).Times(1);
+    EXPECT_CALL(*impl, ResetInputProvider()).Times(1);
 
     mcs::ForwardingMiracastController fmc{impl};
     fmc.SetDelegate(std::shared_ptr<mcs::MiracastController::Delegate>{});
@@ -62,4 +69,7 @@
     fmc.State();
     fmc.SupportedRoles();
     fmc.Scanning();
+    fmc.HasInputProvider();
+    fmc.SetInputProvider(nullptr);
+    fmc.ResetInputProvider();
 }

=== added file 'tests/mcs/inputeventchannel_tests.cpp'
--- tests/mcs/inputeventchannel_tests.cpp	1970-01-01 00:00:00 +0000
+++ tests/mcs/inputeventchannel_tests.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include <gmock/gmock.h>
+
+#include <mcs/inputeventchannel.h>
+
+#include <linux/input.h>
+
+namespace {
+class MockInputEventChannelDelegate : public mcs::InputEventChannelDelegate {
+public:
+    MOCK_METHOD0(OnChannelClosed, void());
+    MOCK_METHOD1(OnEvent, void(const mcs::InputEvent &));
+};
+
+static void RunMainLoopIteration() {
+    std::shared_ptr<GMainLoop> loop(g_main_loop_new(nullptr, false), &g_main_loop_unref);
+    auto context = g_main_loop_get_context(loop.get());
+    g_main_context_iteration(context, TRUE);
+}
+}
+
+TEST(InputEventChannel, ChannelGotClosed) {
+    auto delegate = std::make_shared<MockInputEventChannelDelegate>();
+
+    EXPECT_CALL(*delegate, OnChannelClosed()).Times(1);
+
+    auto channel = mcs::InputEventChannel::Create();
+    channel->SetDelegate(delegate);
+
+    ::close(channel->RemoteEndpoint());
+
+    RunMainLoopIteration();
+}
+
+TEST(InputEventChannel, EventReporting) {
+    using namespace ::testing;
+
+    auto delegate = std::make_shared<MockInputEventChannelDelegate>();
+
+    EXPECT_CALL(*delegate, OnEvent(_)).Times(1);
+
+    auto channel = mcs::InputEventChannel::Create();
+    channel->SetDelegate(delegate);
+
+    struct input_event ev = {{0, 0}, EV_ABS, ABS_X, 42};
+    EXPECT_EQ(::write(channel->RemoteEndpoint(), &ev, sizeof(ev)), sizeof(ev));
+
+    RunMainLoopIteration();
+}
+

=== modified file 'tests/mcs/miracastcontrollerskeleton_tests.cpp'
--- tests/mcs/miracastcontrollerskeleton_tests.cpp	2015-12-12 20:03:23 +0000
+++ tests/mcs/miracastcontrollerskeleton_tests.cpp	2015-12-18 16:38:21 +0000
@@ -32,6 +32,10 @@
     MOCK_CONST_METHOD0(State, mcs::NetworkDeviceState());
     MOCK_CONST_METHOD0(SupportedRoles, std::vector<mcs::NetworkDeviceRole>());
     MOCK_CONST_METHOD0(Scanning, bool());
+
+    MOCK_CONST_METHOD0(HasInputProvider, bool());
+    MOCK_METHOD1(SetInputProvider, void(const mcs::InputProvider::Ptr &));
+    MOCK_METHOD0(ResetInputProvider, void());
 };
 }
 

=== added file 'tests/mcs/miracastservice_tests.cpp'
--- tests/mcs/miracastservice_tests.cpp	1970-01-01 00:00:00 +0000
+++ tests/mcs/miracastservice_tests.cpp	2015-12-18 16:38:21 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2015 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include <gmock/gmock.h>
+
+#include <mcs/miracastservice.h>
+
+class MockNetworkManager : public mcs::NetworkManager {
+public:
+    MOCK_METHOD1(SetDelegate, void(mcs::NetworkManager::Delegate*));
+    MOCK_METHOD0(Setup, bool());
+    MOCK_METHOD1(Scan, void(const std::chrono::seconds &));
+    MOCK_METHOD1(Connect, bool(const mcs::NetworkDevice::Ptr &));
+    MOCK_METHOD1(Disconnect, bool(const mcs::NetworkDevice::Ptr &));
+    MOCK_METHOD1(SetWfdSubElements, void(const std::list<std::string> &));
+
+    MOCK_CONST_METHOD0(Devices, std::vector<mcs::NetworkDevice::Ptr>());
+    MOCK_CONST_METHOD0(LocalAddress, mcs::IpV4Address());
+    MOCK_CONST_METHOD0(Running, bool());
+    MOCK_CONST_METHOD0(Scanning, bool());
+};
+
+class MockInputProvider : public mcs::InputProvider {
+public:
+    MOCK_METHOD1(NewConnection, bool(int));
+    MOCK_METHOD0(RequestDisconnection, void());
+    MOCK_CONST_METHOD0(Connected, bool());
+};
+
+TEST(MiracastService, CorrectConstruction) {
+    using namespace ::testing;
+
+    auto network_manager = std::make_shared<MockNetworkManager>();
+
+    EXPECT_CALL(*network_manager, SetDelegate(_)).Times(1);
+    EXPECT_CALL(*network_manager, Setup()).Times(1);
+
+    auto service = mcs::MiracastService::Create(network_manager);
+    EXPECT_TRUE(!!service);
+}
+
+TEST(MiracastService, InputProviderRegistration) {
+   using namespace ::testing;
+
+    auto network_manager = std::make_shared<MockNetworkManager>();
+
+   EXPECT_CALL(*network_manager, SetDelegate(_)).Times(1);
+   EXPECT_CALL(*network_manager, Setup()).Times(1);
+
+   auto service = mcs::MiracastService::Create(network_manager);
+   EXPECT_TRUE(!!service);
+
+   auto input_provider = std::make_shared<MockInputProvider>();
+
+   EXPECT_FALSE(service->HasInputProvider());
+
+   service->SetInputProvider(input_provider);
+
+   EXPECT_TRUE(service->HasInputProvider());
+
+   service->ResetInputProvider();
+
+   EXPECT_FALSE(service->HasInputProvider());
+}