diff --git a/examples/daemon/README b/examples/daemon/README
index 287459f..c767420 100644
--- a/examples/daemon/README
+++ b/examples/daemon/README
@@ -8,8 +8,8 @@
         examples/prerequisites.sh
   - build daemon
         examples/build.sh
-  - binaries for daemon is at
-        out/Debug/weave_daemon
+  - binaries for daemon are in the directory
+        out/Debug/
 
 Prepare Host OS
 ---------------
@@ -50,7 +50,7 @@
         93019287-6b26-04a0-22ee-d55ad23a4226
   - go to terminal, register and start the daemon with
 
-        sudo out/Debug/weave_daemon --registration_ticket=93019287-6b26-04a0-22ee-d55ad23a4226
+        sudo out/Debug/weave_daemon_sample --registration_ticket=93019287-6b26-04a0-22ee-d55ad23a4226
 
         you should see something like:
           Publishing service
diff --git a/examples/daemon/examples.gyp b/examples/daemon/examples.gyp
index 8fee90d..2b497a5 100644
--- a/examples/daemon/examples.gyp
+++ b/examples/daemon/examples.gyp
@@ -7,7 +7,8 @@
         'sample/daemon.gyp:weave_daemon_sample',
         'light/daemon.gyp:weave_daemon_light',
         'lock/daemon.gyp:weave_daemon_lock',
-        'ledflasher/daemon.gyp:weave_daemon_ledflasher'
+        'ledflasher/daemon.gyp:weave_daemon_ledflasher',
+        'speaker/daemon.gyp:weave_daemon_speaker'
       ]
     }
   ]
diff --git a/examples/daemon/lock/lock.cc b/examples/daemon/lock/lock.cc
index e1ca2d9..3014fb1 100644
--- a/examples/daemon/lock/lock.cc
+++ b/examples/daemon/lock/lock.cc
@@ -34,11 +34,16 @@
     device_ = device;
 
     device->AddStateDefinitionsFromJson(R"({
-      "lock": {"lockedState": ["locked", "unlocked", "partiallyLocked"]}
+      "lock": {
+        "lockedState": ["locked", "unlocked", "partiallyLocked"],
+        "isLockingSupported": "boolean"}
     })");
 
     device->SetStatePropertiesFromJson(R"({
-      "lock":{"lockedState": "locked"}
+      "lock":{
+        "lockedState": "locked",
+        "isLockingSupported": true
+      }
     })",
                                        nullptr);
 
diff --git a/examples/daemon/speaker/daemon.gyp b/examples/daemon/speaker/daemon.gyp
new file mode 100644
index 0000000..3bf7a91
--- /dev/null
+++ b/examples/daemon/speaker/daemon.gyp
@@ -0,0 +1,18 @@
+# Copyright 2015 The Weave Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+{
+  'targets': [
+    {
+      'target_name': 'weave_daemon_speaker',
+      'type': 'executable',
+      'sources': [
+        'speaker.cc',
+      ],
+      'dependencies': [
+        '<@(DEPTH)/libweave_standalone.gyp:libweave',
+        '<@(DEPTH)/examples/provider/provider.gyp:libweave_provider',
+      ]
+    }
+  ]
+}
diff --git a/examples/daemon/speaker/speaker.cc b/examples/daemon/speaker/speaker.cc
new file mode 100644
index 0000000..32591f9
--- /dev/null
+++ b/examples/daemon/speaker/speaker.cc
@@ -0,0 +1,154 @@
+// Copyright 2015 The Weave Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "examples/daemon/common/daemon.h"
+
+#include <weave/device.h>
+
+#include <base/bind.h>
+#include <base/memory/weak_ptr.h>
+
+// SpeakerHandler is a command handler example that shows
+// how to handle commands for a Weave speaker.
+class SpeakerHandler {
+ public:
+  SpeakerHandler() = default;
+  void Register(weave::Device* device) {
+    device_ = device;
+
+    device->AddStateDefinitionsFromJson(R"({
+      "onOff": {"state": ["on", "standby"]},
+      "volume": {
+        "volume": "integer",
+        "isMuted": "boolean"
+      }
+    })");
+
+    device->SetStatePropertiesFromJson(R"({
+      "onOff":{"state": "standby"},
+      "volume":{
+        "volume": 100,
+        "isMuted": false
+      }
+    })",
+                                       nullptr);
+
+    device->AddCommandDefinitionsFromJson(R"({
+      "onOff": {
+         "setConfig":{
+           "parameters": {
+             "state": ["on", "standby"]
+           }
+         }
+       },
+       "volume": {
+         "setConfig":{
+           "parameters": {
+             "volume": {
+               "type": "integer",
+               "minimum": 0,
+               "maximum": 100
+             },
+             "isMuted": "boolean"
+           }
+        }
+      }
+    })");
+    device->AddCommandHandler("onOff.setConfig",
+                              base::Bind(&SpeakerHandler::OnOnOffSetConfig,
+                                         weak_ptr_factory_.GetWeakPtr()));
+    device->AddCommandHandler("volume.setConfig",
+                              base::Bind(&SpeakerHandler::OnVolumeSetConfig,
+                                         weak_ptr_factory_.GetWeakPtr()));
+  }
+
+ private:
+  void OnVolumeSetConfig(const std::weak_ptr<weave::Command>& command) {
+    auto cmd = command.lock();
+    if (!cmd)
+      return;
+    LOG(INFO) << "received command: " << cmd->GetName();
+
+    // Handle volume parameter
+    int32_t volume_value = 0;
+    if (cmd->GetParameters()->GetInteger("volume", &volume_value)) {
+      // Display this command in terminal.
+      LOG(INFO) << cmd->GetName() << " volume: " << volume_value;
+
+      if (volume_value_ != volume_value) {
+        volume_value_ = volume_value;
+        UpdateSpeakerState();
+      }
+      cmd->Complete({}, nullptr);
+      return;
+    }
+
+    // Handle isMuted parameter
+    bool isMuted_status = false;
+    if (cmd->GetParameters()->GetBoolean("isMuted", &isMuted_status)) {
+      // Display this command in terminal.
+      LOG(INFO) << cmd->GetName() << " is "
+                << (isMuted_status ? "muted" : "not muted");
+
+      if (isMuted_status_ != isMuted_status) {
+        isMuted_status_ = isMuted_status;
+
+        LOG(INFO) << "Speaker is now: "
+                  << (isMuted_status ? "muted" : "not muted");
+        UpdateSpeakerState();
+      }
+    }
+
+    cmd->Complete({}, nullptr);
+  }
+
+  void OnOnOffSetConfig(const std::weak_ptr<weave::Command>& command) {
+    auto cmd = command.lock();
+    if (!cmd)
+      return;
+    LOG(INFO) << "received command: " << cmd->GetName();
+    std::string requested_state;
+    if (cmd->GetParameters()->GetString("state", &requested_state)) {
+      LOG(INFO) << cmd->GetName() << " state: " << requested_state;
+
+      bool new_speaker_status = requested_state == "on";
+      if (new_speaker_status != speaker_status_) {
+        speaker_status_ = new_speaker_status;
+
+        LOG(INFO) << "Speaker is now: " << (speaker_status_ ? "ON" : "OFF");
+        UpdateSpeakerState();
+      }
+    }
+    cmd->Complete({}, nullptr);
+  }
+
+  void UpdateSpeakerState() {
+    base::DictionaryValue state;
+    state.SetString("onOff.state", speaker_status_ ? "on" : "standby");
+    state.SetBoolean("volume.isMuted", isMuted_status_);
+    state.SetInteger("volume.volume", volume_value_);
+    device_->SetStateProperties(state, nullptr);
+  }
+
+  weave::Device* device_{nullptr};
+
+  // Simulate the state of the speaker.
+  bool speaker_status_;
+  bool isMuted_status_;
+  int32_t volume_value_;
+  base::WeakPtrFactory<SpeakerHandler> weak_ptr_factory_{this};
+};
+
+int main(int argc, char** argv) {
+  Daemon::Options opts;
+  if (!opts.Parse(argc, argv)) {
+    Daemon::Options::ShowUsage(argv[0]);
+    return 1;
+  }
+  Daemon daemon{opts};
+  SpeakerHandler speaker;
+  speaker.Register(daemon.GetDevice());
+  daemon.Run();
+  return 0;
+}
diff --git a/examples/prerequisites.sh b/examples/prerequisites.sh
index d1661d0..7358b71 100755
--- a/examples/prerequisites.sh
+++ b/examples/prerequisites.sh
@@ -6,10 +6,11 @@
 DIR=$(cd -P -- "$(dirname -- "$0")" && pwd -P)
 ROOT_DIR=$(cd -P -- "$(dirname -- "$0")/.." && pwd -P)
 
-sudo apt-get install ${APT_GET_OPTS} \
+sudo apt-get update && sudo apt-get install ${APT_GET_OPTS} \
   autoconf \
   automake \
   binutils \
+  g++ \
   gyp \
   hostapd \
   libavahi-client-dev \
@@ -17,6 +18,7 @@
   libexpat1-dev \
   libnl-3-dev \
   libnl-route-3-dev \
+  libssl-dev \
   libtool \
   ninja-build \
   || exit 1
@@ -57,8 +59,10 @@
 ./autogen.sh || exit 1
 ./configure --disable-shared || exit 1
 make || exit 1
-echo -e "\n\nTesting libevent...\nCan take several minutes.\n"
-make verify || exit 1
+if [ -z "$DISABLE_LIBEVENT_TEST" ]; then
+  echo -e "\n\nTesting libevent...\nCan take several minutes.\n"
+  make verify || exit 1
+fi
 cp -rf include/* $ROOT_DIR/third_party/include/ || exit 1
 cp -rf .libs/lib* $ROOT_DIR/third_party/lib/ || exit 1
 rm -rf $ROOT_DIR/third_party/libevent
diff --git a/examples/provider/curl_http_client.cc b/examples/provider/curl_http_client.cc
index b440f39..32aa4af 100644
--- a/examples/provider/curl_http_client.cc
+++ b/examples/provider/curl_http_client.cc
@@ -4,10 +4,14 @@
 
 #include "examples/provider/curl_http_client.h"
 
+#include <future>
+#include <thread>
+
 #include <base/bind.h>
+#include <base/logging.h>
 #include <curl/curl.h>
-#include <weave/provider/task_runner.h>
 #include <weave/enum_to_string.h>
+#include <weave/provider/task_runner.h>
 
 namespace weave {
 namespace examples {
@@ -30,29 +34,24 @@
   return size * nmemb;
 }
 
-}  // namespace
-
-CurlHttpClient::CurlHttpClient(provider::TaskRunner* task_runner)
-    : task_runner_{task_runner} {}
-
-void CurlHttpClient::SendRequest(Method method,
-                                 const std::string& url,
-                                 const Headers& headers,
-                                 const std::string& data,
-                                 const SendRequestCallback& callback) {
+std::pair<std::unique_ptr<CurlHttpClient::Response>, ErrorPtr>
+SendRequestBlocking(CurlHttpClient::Method method,
+                    const std::string& url,
+                    const CurlHttpClient::Headers& headers,
+                    const std::string& data) {
   std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl{curl_easy_init(),
                                                            &curl_easy_cleanup};
   CHECK(curl);
 
   switch (method) {
-    case Method::kGet:
+    case CurlHttpClient::Method::kGet:
       CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HTTPGET, 1L));
       break;
-    case Method::kPost:
+    case CurlHttpClient::Method::kPost:
       CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HTTPPOST, 1L));
       break;
-    case Method::kPatch:
-    case Method::kPut:
+    case CurlHttpClient::Method::kPatch:
+    case CurlHttpClient::Method::kPut:
       CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_CUSTOMREQUEST,
                                           weave::EnumToString(method).c_str()));
       break;
@@ -66,7 +65,7 @@
 
   CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, chunk));
 
-  if (!data.empty() || method == Method::kPost) {
+  if (!data.empty() || method == CurlHttpClient::Method::kPost) {
     CHECK_EQ(CURLE_OK,
              curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, data.c_str()));
   }
@@ -89,8 +88,7 @@
   if (res != CURLE_OK) {
     Error::AddTo(&error, FROM_HERE, "curl", "curl_easy_perform_error",
                  curl_easy_strerror(res));
-    return task_runner_->PostDelayedTask(
-        FROM_HERE, base::Bind(callback, nullptr, base::Passed(&error)), {});
+    return {nullptr, std::move(error)};
   }
 
   const std::string kContentType = "\r\nContent-Type:";
@@ -98,8 +96,7 @@
   if (pos == std::string::npos) {
     Error::AddTo(&error, FROM_HERE, "curl", "no_content_header",
                  "Content-Type header is missing");
-    return task_runner_->PostDelayedTask(
-        FROM_HERE, base::Bind(callback, nullptr, base::Passed(&error)), {});
+    return {nullptr, std::move(error)};
   }
   pos += kContentType.size();
   auto pos_end = response->content_type.find("\r\n", pos);
@@ -112,8 +109,57 @@
   CHECK_EQ(CURLE_OK, curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE,
                                        &response->status));
 
+  return {std::move(response), nullptr};
+}
+
+}  // namespace
+
+CurlHttpClient::CurlHttpClient(provider::TaskRunner* task_runner)
+    : task_runner_{task_runner} {}
+
+void CurlHttpClient::SendRequest(Method method,
+                                 const std::string& url,
+                                 const Headers& headers,
+                                 const std::string& data,
+                                 const SendRequestCallback& callback) {
+  pending_tasks_.emplace_back(
+      std::async(std::launch::async, SendRequestBlocking, method, url, headers,
+                 data),
+      callback);
+  if (pending_tasks_.size() == 1)  // More means check is scheduled.
+    CheckTasks();
+}
+
+void CurlHttpClient::CheckTasks() {
+  VLOG(4) << "CurlHttpClient::CheckTasks, size=" << pending_tasks_.size();
+  auto ready_begin =
+      std::partition(pending_tasks_.begin(), pending_tasks_.end(),
+                     [](const decltype(pending_tasks_)::value_type& value) {
+                       return value.first.wait_for(std::chrono::seconds(0)) !=
+                              std::future_status::ready;
+                     });
+
+  for (auto it = ready_begin; it != pending_tasks_.end(); ++it) {
+    CHECK(it->first.valid());
+    auto result = it->first.get();
+    VLOG(2) << "CurlHttpClient::CheckTasks done";
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(it->second, base::Passed(&result.first),
+                              base::Passed(&result.second)),
+        {});
+  }
+
+  pending_tasks_.erase(ready_begin, pending_tasks_.end());
+
+  if (pending_tasks_.empty()) {
+    VLOG(2) << "No more CurlHttpClient tasks";
+    return;
+  }
+
   task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(callback, base::Passed(&response), nullptr), {});
+      FROM_HERE,
+      base::Bind(&CurlHttpClient::CheckTasks, weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromMilliseconds(100));
 }
 
 }  // namespace examples
diff --git a/examples/provider/curl_http_client.h b/examples/provider/curl_http_client.h
index b2f4bca..c342076 100644
--- a/examples/provider/curl_http_client.h
+++ b/examples/provider/curl_http_client.h
@@ -5,7 +5,9 @@
 #ifndef LIBWEAVE_EXAMPLES_PROVIDER_CURL_HTTP_CLIENT_H_
 #define LIBWEAVE_EXAMPLES_PROVIDER_CURL_HTTP_CLIENT_H_
 
+#include <future>
 #include <string>
+#include <utility>
 
 #include <base/memory/weak_ptr.h>
 #include <weave/provider/http_client.h>
@@ -31,6 +33,11 @@
                    const SendRequestCallback& callback) override;
 
  private:
+  void CheckTasks();
+
+  std::vector<
+      std::pair<std::future<std::pair<std::unique_ptr<Response>, ErrorPtr>>,
+                SendRequestCallback>> pending_tasks_;
   provider::TaskRunner* task_runner_{nullptr};
 
   base::WeakPtrFactory<CurlHttpClient> weak_ptr_factory_{this};
diff --git a/examples/provider/event_deleter.h b/examples/provider/event_deleter.h
new file mode 100644
index 0000000..078c326
--- /dev/null
+++ b/examples/provider/event_deleter.h
@@ -0,0 +1,37 @@
+// Copyright 2015 The Weave Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_PROVIDER_EVENT_DELETER_H
+#define LIBWEAVE_EXAMPLES_PROVIDER_EVENT_DELETER_H
+
+#include <memory>
+
+#include <third_party/include/event2/event.h>
+#include <third_party/include/event2/event_struct.h>
+#include <third_party/include/event2/http.h>
+
+namespace weave {
+namespace examples {
+
+// Defines overloaded deletion methods for various event_ objects
+// so we can use one unique_ptr definition for all of them
+class EventDeleter {
+ public:
+  void operator()(evhttp_uri* http_uri) { evhttp_uri_free(http_uri); }
+  void operator()(evhttp_connection* conn) { evhttp_connection_free(conn); }
+  void operator()(evhttp_request* req) { evhttp_request_free(req); }
+  void operator()(event_base* base) { event_base_free(base); }
+  void operator()(event* ev) {
+    event_del(ev);
+    event_free(ev);
+  }
+};
+
+template <typename T>
+using EventPtr = std::unique_ptr<T, EventDeleter>;
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_PROVIDER_EVENT_DELETER_H
diff --git a/examples/provider/event_http_client.cc b/examples/provider/event_http_client.cc
index b38bd55..03da97f 100644
--- a/examples/provider/event_http_client.cc
+++ b/examples/provider/event_http_client.cc
@@ -5,15 +5,14 @@
 #include "examples/provider/event_http_client.h"
 #include "examples/provider/event_task_runner.h"
 
-#include <weave/enum_to_string.h>
-
-#include <string>
 
 #include <base/bind.h>
-
 #include <event2/bufferevent.h>
 #include <event2/buffer.h>
 #include <event2/http.h>
+#include <weave/enum_to_string.h>
+
+#include "examples/provider/event_deleter.h"
 
 // EventHttpClient based on libevent2 http-client sample
 // TODO(proppy): https
@@ -38,13 +37,6 @@
 
 namespace {
 
-class EventDeleter {
- public:
-  void operator()(evhttp_uri* http_uri) { evhttp_uri_free(http_uri); }
-  void operator()(evhttp_connection* conn) { evhttp_connection_free(conn); }
-  void operator()(evhttp_request* req) { evhttp_request_free(req); }
-};
-
 class EventHttpResponse : public weave::provider::HttpClient::Response {
  public:
   int GetStatusCode() const override { return status; }
@@ -58,8 +50,8 @@
 
 struct EventRequestState {
   TaskRunner* task_runner_;
-  std::unique_ptr<evhttp_uri, EventDeleter> http_uri_;
-  std::unique_ptr<evhttp_connection, EventDeleter> evcon_;
+  EventPtr<evhttp_uri> http_uri_;
+  EventPtr<evhttp_connection> evcon_;
   HttpClient::SendRequestCallback callback_;
 };
 
@@ -101,8 +93,7 @@
                                   const SendRequestCallback& callback) {
   evhttp_cmd_type method_id;
   CHECK(weave::StringToEnum(weave::EnumToString(method), &method_id));
-  std::unique_ptr<evhttp_uri, EventDeleter> http_uri{
-      evhttp_uri_parse(url.c_str())};
+  EventPtr<evhttp_uri> http_uri{evhttp_uri_parse(url.c_str())};
   CHECK(http_uri);
   auto host = evhttp_uri_get_host(http_uri.get());
   CHECK(host);
@@ -121,11 +112,10 @@
   auto bev = bufferevent_socket_new(task_runner_->GetEventBase(), -1,
                                     BEV_OPT_CLOSE_ON_FREE);
   CHECK(bev);
-  std::unique_ptr<evhttp_connection, EventDeleter> conn{
-      evhttp_connection_base_bufferevent_new(task_runner_->GetEventBase(), NULL,
-                                             bev, host, port)};
+  EventPtr<evhttp_connection> conn{evhttp_connection_base_bufferevent_new(
+      task_runner_->GetEventBase(), NULL, bev, host, port)};
   CHECK(conn);
-  std::unique_ptr<evhttp_request, EventDeleter> req{evhttp_request_new(
+  EventPtr<evhttp_request> req{evhttp_request_new(
       &RequestDoneCallback,
       new EventRequestState{task_runner_, std::move(http_uri), std::move(conn),
                             callback})};
diff --git a/examples/provider/event_http_client.h b/examples/provider/event_http_client.h
index 7ad117e..378c4a3 100644
--- a/examples/provider/event_http_client.h
+++ b/examples/provider/event_http_client.h
@@ -10,11 +10,11 @@
 #include <base/memory/weak_ptr.h>
 #include <weave/provider/http_client.h>
 
+#include "examples/provider/event_task_runner.h"
+
 namespace weave {
 namespace examples {
 
-class EventTaskRunner;
-
 // Basic implementation of weave::HttpClient using libevent.
 class EventHttpClient : public provider::HttpClient {
  public:
diff --git a/examples/provider/event_task_runner.cc b/examples/provider/event_task_runner.cc
index c14a934..c07e912 100644
--- a/examples/provider/event_task_runner.cc
+++ b/examples/provider/event_task_runner.cc
@@ -24,6 +24,24 @@
   queue_.emplace(std::make_pair(new_time, ++counter_), task);
 }
 
+void EventTaskRunner::AddIoCompletionTask(
+    int fd,
+    int16_t what,
+    const EventTaskRunner::IoCompletionCallback& task) {
+  int16_t flags = EV_PERSIST | EV_ET;
+  flags |= (what & kReadable) ? EV_READ : 0;
+  flags |= (what & kWriteable) ? EV_WRITE : 0;
+  flags |= (what & kClosed) ? EV_CLOSED : 0;
+  event* ioevent = event_new(base_.get(), fd, flags, FdEventHandler, this);
+  EventPtr<event> ioeventPtr{ioevent};
+  fd_task_map_.emplace(fd, std::make_pair(std::move(ioeventPtr), task));
+  event_add(ioevent, nullptr);
+}
+
+void EventTaskRunner::RemoveIoCompletionTask(int fd) {
+  fd_task_map_.erase(fd);
+}
+
 void EventTaskRunner::Run() {
   g_event_base = base_.get();
 
@@ -44,7 +62,9 @@
   event_add(task_event_.get(), &tv);
 }
 
-void EventTaskRunner::EventHandler(int, int16_t, void* runner) {
+void EventTaskRunner::EventHandler(int /* fd */,
+                                   int16_t /* what */,
+                                   void* runner) {
   static_cast<EventTaskRunner*>(runner)->Process();
 }
 
@@ -66,5 +86,17 @@
   }
 }
 
+void EventTaskRunner::FdEventHandler(int fd, int16_t what, void* runner) {
+  static_cast<EventTaskRunner*>(runner)->ProcessFd(fd, what);
+}
+
+void EventTaskRunner::ProcessFd(int fd, int16_t what) {
+  auto it = fd_task_map_.find(fd);
+  if (it != fd_task_map_.end()) {
+    const IoCompletionCallback& callback = it->second.second;
+    callback.Run(fd, what, this);
+  }
+}
+
 }  // namespace examples
 }  // namespace weave
diff --git a/examples/provider/event_task_runner.h b/examples/provider/event_task_runner.h
index 473441e..7291314 100644
--- a/examples/provider/event_task_runner.h
+++ b/examples/provider/event_task_runner.h
@@ -10,9 +10,10 @@
 #include <vector>
 
 #include <event2/event.h>
-
 #include <weave/provider/task_runner.h>
 
+#include "examples/provider/event_deleter.h"
+
 namespace weave {
 namespace examples {
 
@@ -23,6 +24,40 @@
                        const base::Closure& task,
                        base::TimeDelta delay) override;
 
+  // Defines the types of I/O completion events that the
+  // application can register to receive on a file descriptor.
+  enum IOEvent : int16_t {
+    kReadable = 0x01,
+    kWriteable = 0x02,
+    kClosed = 0x04,
+    kReadableWriteable = kReadable | kWriteable,
+    kReadableOrClosed = kReadable | kClosed,
+    kAll = kReadableOrClosed | kWriteable,
+  };
+
+  // Callback type for I/O completion events.
+  // Arguments:
+  //  fd -      file descriptor that triggered the event
+  //  what -    combination of IOEvent flags indicating
+  //            which event(s) occurred
+  //  sender -  reference to the EventTaskRunner that
+  //            called the IoCompletionCallback
+  using IoCompletionCallback =
+      base::Callback<void(int fd, int16_t what, EventTaskRunner* sender)>;
+
+  // Adds a handler for the specified IO completion events on a file
+  // descriptor. The 'what' parameter is a combination of IOEvent flags.
+  // Only one callback is allowed per file descriptor; calling this function
+  // with an fd that has already been registered will replace the previous
+  // callback with the new one.
+  void AddIoCompletionTask(int fd,
+                           int16_t what,
+                           const IoCompletionCallback& task);
+
+  // Remove the callback associated with this fd and stop listening for
+  // events related to it.
+  void RemoveIoCompletionTask(int fd);
+
   event_base* GetEventBase() const { return base_.get(); }
 
   void Run();
@@ -33,6 +68,9 @@
   static void FreeEvent(event* evnt);
   void Process();
 
+  static void FdEventHandler(int fd, int16_t what, void* runner);
+  void ProcessFd(int fd, int16_t what);
+
   using QueueItem = std::pair<std::pair<base::Time, size_t>, base::Closure>;
 
   struct Greater {
@@ -47,10 +85,12 @@
                       std::vector<QueueItem>,
                       EventTaskRunner::Greater> queue_;
 
-  std::unique_ptr<event_base, decltype(&event_base_free)> base_{
-      event_base_new(), &event_base_free};
-  std::unique_ptr<event, decltype(&FreeEvent)> task_event_{
-      event_new(base_.get(), -1, EV_TIMEOUT, &EventHandler, this), &FreeEvent};
+  EventPtr<event_base> base_{event_base_new()};
+
+  EventPtr<event> task_event_{
+      event_new(base_.get(), -1, EV_TIMEOUT, &EventHandler, this)};
+
+  std::map<int, std::pair<EventPtr<event>, IoCompletionCallback>> fd_task_map_;
 };
 
 }  // namespace examples
diff --git a/examples/provider/wifi_manager.cc b/examples/provider/wifi_manager.cc
index 6e216e4..ed6a9fd 100644
--- a/examples/provider/wifi_manager.cc
+++ b/examples/provider/wifi_manager.cc
@@ -42,7 +42,7 @@
 
 WifiImpl::WifiImpl(provider::TaskRunner* task_runner, EventNetworkImpl* network)
     : task_runner_{task_runner}, network_{network} {
-  CHECK_EQ(0, getuid())
+  CHECK_EQ(0u, getuid())
       << "WiFi manager expects root access to control WiFi capabilities";
   StopAccessPoint();
 }