Project import

diff --git a/common/MODULE_LICENSE_APACHE2 b/common/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/common/MODULE_LICENSE_APACHE2


diff --git a/common/NOTICE b/common/NOTICE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/common/NOTICE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diff --git a/common/brillo_camera/Android.mk b/common/brillo_camera/Android.mk
new file mode 100644
index 0000000..950ed33
--- /dev/null
+++ b/common/brillo_camera/Android.mk

@@ -0,0 +1,33 @@
+# Copyright 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := brillo_camera_client
+LOCAL_CFLAGS := -Wall -Werror
+LOCAL_SHARED_LIBRARIES := \
+    libbinder \
+    libbrillo \
+    libbrillo-binder \
+    libcamera_client \
+    libcamera_metadata \
+    libchrome \
+    libcutils \
+    libgui \
+    libutils
+LOCAL_SRC_FILES := \
+    main.cpp
+include $(BUILD_EXECUTABLE)

diff --git a/common/brillo_camera/main.cpp b/common/brillo_camera/main.cpp
new file mode 100644
index 0000000..6d5a3f8
--- /dev/null
+++ b/common/brillo_camera/main.cpp

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+#include <string>
+
+#include <base/at_exit.h>
+#include <base/bind.h>
+#include <base/logging.h>
+#include <binder/IServiceManager.h>
+#include <brillo/binder_watcher.h>
+#include <brillo/message_loops/base_message_loop.h>
+#include <brillo/syslog_logging.h>
+#include <camera/CameraMetadata.h>
+#include <camera/ICameraService.h>
+#include <camera/camera2/CaptureRequest.h>
+#include <camera/camera2/ICameraDeviceCallbacks.h>
+#include <camera/camera2/ICameraDeviceUser.h>
+#include <camera/camera2/OutputConfiguration.h>
+#include <gui/BufferQueue.h>
+#include <gui/BufferQueueConsumer.h>
+#include <gui/BufferQueueCore.h>
+#include <gui/BufferQueueProducer.h>
+#include <gui/CpuConsumer.h>
+#include <gui/Surface.h>
+#include <hardware/camera3.h>
+#include <system/camera_metadata.h>
+#include <utils/String16.h>
+#include <utils/String8.h>
+#include <utils/StrongPointer.h>
+
+using android::BnCameraDeviceCallbacks;
+using android::BufferQueue;
+using android::CameraMetadata;
+using android::CaptureRequest;
+using android::CaptureResultExtras;
+using android::CpuConsumer;
+using android::ICameraDeviceCallbacks;
+using android::ICameraDeviceUser;
+using android::ICameraService;
+using android::IGraphicBufferConsumer;
+using android::IGraphicBufferProducer;
+using android::OK;
+using android::String16;
+using android::Surface;
+using android::sp;
+
+namespace {
+
+// TODO(wiley) This constant should probably come out that client library, but
+//             where is not obvious.
+const char kCameraServiceName[] = "media.camera";
+// TODO(wiley) This happens to be a format supported by both gralloc.default and
+//             the golfish camera HAL, but I have no idea how to get this into
+//             an actual viewable image.
+const int kHalPixelFormat = HAL_PIXEL_FORMAT_RAW16;
+
+class CameraDeviceCallbacks : public BnCameraDeviceCallbacks {
+ public:
+  explicit CameraDeviceCallbacks(brillo::MessageLoop* loop) : loop_(loop) {}
+
+  void onDeviceError(ICameraDeviceCallbacks::CameraErrorCode error_code,
+                     const CaptureResultExtras& /* result_extras */) override {
+    LOG(ERROR) << "Received camera error = " << error_code;
+    loop_->BreakLoop();
+  }
+
+  void onDeviceIdle() override {
+    LOG(INFO) << "Camera device is idle";
+  }
+
+  void onCaptureStarted(
+      const CaptureResultExtras& /* result_extras */,
+      int64_t /* timestamp */) override {
+    LOG(INFO) << "Capture started.";
+  }
+
+  void onResultReceived(
+      const CameraMetadata& /* metadata */,
+      const CaptureResultExtras& /* result_extras */) override {
+    LOG(INFO) << "Capture result received";
+    result_received_ = true;
+    loop_->BreakLoop();
+  }
+
+  void onPrepared(int stream_id) override {
+    LOG(INFO) << "Camera is prepared for stream " << stream_id;
+  }
+
+  bool result_received() { return result_received_; }
+
+ private:
+  brillo::MessageLoop* loop_ = nullptr;
+  bool result_received_ = false;
+};
+
+}  // namespace
+
+
+int main() {
+  base::AtExitManager at_exit_manager;
+  brillo::InitLog(brillo::kLogToStderr);
+
+  // Create a message loop.
+  brillo::BaseMessageLoop message_loop;
+
+  // Initialize a binder watcher.
+  brillo::BinderWatcher watcher(&message_loop);
+  watcher.Init();
+
+  LOG(INFO) << "Retrieving a binder for the camera service.";
+  sp<ICameraService> camera_service;
+  android::status_t status = android::getService(
+      String16(kCameraServiceName), &camera_service);
+  CHECK(status == OK)
+      << "Failed to get ICameraService binder from service manager!";
+
+  LOG(INFO) << "Asking how many cameras we have.";
+  const int32_t num_cameras = camera_service->getNumberOfCameras(
+      ICameraService::CAMERA_TYPE_ALL);
+  CHECK(num_cameras > 0)
+      << "ICameraService reports no cameras available";
+
+  const int camera_id = 0;
+  LOG(INFO) << "Connecting to camera " << camera_id;
+  sp<CameraDeviceCallbacks> camera_cb =
+      new CameraDeviceCallbacks(&message_loop);
+  sp<ICameraDeviceCallbacks> camera_cb_alias = camera_cb;
+  const String16 client_package_name("brillo");
+  sp<ICameraDeviceUser> camera_device_user;
+  status = camera_service->connectDevice(
+      camera_cb_alias, camera_id, client_package_name,
+      ICameraService::USE_CALLING_UID,
+      camera_device_user);
+  CHECK(status == OK) << "Failed to connect to camera id=" << camera_id
+                      << " error=" << status;
+
+  LOG(INFO) << "Obtaining camera info";
+  CameraMetadata camera_metadata;
+  status = camera_device_user->getCameraInfo(&camera_metadata);
+  CHECK(status == OK) << "Failed to get camera info, error=" << status;
+
+  LOG(INFO) << "Calculating smallest stream configuration";
+  camera_metadata_entry streamConfigs =
+      camera_metadata.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
+  int32_t width = std::numeric_limits<int32_t>::max();
+  int32_t height = 1;
+  for (size_t i = 0; i < streamConfigs.count; i += 4) {
+    int32_t fmt = streamConfigs.data.i32[i];
+    int32_t inout = streamConfigs.data.i32[i + 3];
+    if (fmt == ANDROID_SCALER_AVAILABLE_FORMATS_RAW16 &&
+        inout == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT) {
+      int32_t w = streamConfigs.data.i32[i + 1];
+      int32_t h = streamConfigs.data.i32[i + 2];
+
+      if (width * height > w * h) {
+        width = w;
+        height = h;
+      }
+    }
+  }
+  LOG(INFO) << "width = " << width << " height = " << height;
+  CHECK(width != std::numeric_limits<int32_t>::max())
+      << "Unable to configure stream dimensions";
+
+  LOG(INFO) << "Obtaining buffer queue";
+  sp<IGraphicBufferProducer> buffer_producer = nullptr;
+  sp<IGraphicBufferConsumer> buffer_consumer = nullptr;
+  BufferQueue::createBufferQueue(&buffer_producer, &buffer_consumer);
+  CHECK(buffer_producer.get() != nullptr && buffer_consumer.get() != nullptr);
+
+  LOG(INFO) << "Creating buffer consumer";
+  sp<CpuConsumer> consumer = new CpuConsumer(
+      buffer_consumer, 1 /* one frame only */, true /* controlled by app */);
+  consumer->setDefaultBufferSize(width, height);
+  consumer->setDefaultBufferFormat(kHalPixelFormat);
+
+  LOG(INFO) << "Configuring the camera";
+  status = camera_device_user->beginConfigure();
+  CHECK(status == OK) << "Failed calling ICameraDeviceUser::beginConfigure()"
+                      << " error = " << status;
+  android::OutputConfiguration output_configuration(
+      buffer_producer, CAMERA3_STREAM_ROTATION_0);
+  status = camera_device_user->createStream(output_configuration);
+  CHECK(status == OK) << "Failed calling ICameraDeviceUser::createStream()"
+                      << " error = " << status;
+  status = camera_device_user->endConfigure(false /* isConstrainedHighSpeed */);
+  CHECK(status == OK) << "Failed calling ICameraDeviceUser::endConfigure()"
+                      << " error = " << status;
+
+  LOG(INFO) << "Creating capture_request";
+  sp<CaptureRequest> capture_request = new CaptureRequest;
+  status = camera_device_user->createDefaultRequest(
+      CAMERA3_TEMPLATE_STILL_CAPTURE, &capture_request->mMetadata);
+  sp<Surface> surface = new Surface(
+      buffer_producer, true /* controlled by app */);
+  capture_request->mSurfaceList.push_back(surface);
+  capture_request->mIsReprocess = false;
+
+  LOG(INFO) << "Submitting capture request";
+  int64_t last_frame_number = 0;
+  status = camera_device_user->submitRequest(
+      capture_request, false, &last_frame_number);
+  CHECK(status == OK) << "Got error=" << status
+                      << " while submitting capture request.";
+
+  LOG(INFO) << "Waiting for the camera to take a picture.";
+  // If we don't hear back from the camera for long enough, just time out.
+  message_loop.PostDelayedTask(
+      base::Bind(&brillo::BaseMessageLoop::BreakLoop,
+                 base::Unretained(&message_loop)),
+      base::TimeDelta::FromSeconds(30));
+  message_loop.Run();  // We'll exit on a callback from the camera.
+
+  CHECK(camera_cb->result_received());
+
+  // TODO(wiley) render this image to a file to save somewhere.
+
+  return 0;
+}

diff --git a/common/brillo_gpios/AndroidProducts.mk b/common/brillo_gpios/AndroidProducts.mk
new file mode 100644
index 0000000..e31e144
--- /dev/null
+++ b/common/brillo_gpios/AndroidProducts.mk

@@ -0,0 +1,16 @@
+#
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+PRODUCT_MAKEFILES := $(LOCAL_DIR)/brillo_gpios.mk

diff --git a/common/brillo_gpios/README b/common/brillo_gpios/README
new file mode 100644
index 0000000..be80916
--- /dev/null
+++ b/common/brillo_gpios/README

@@ -0,0 +1,43 @@
+README for Brillo GPIO sample
+
+This GPIO sample demonstrates how to set up GPIO and write/read to GPIO pins.
+Specifically this app does the following.
+
+ - Export an input and output GPIO pins
+ - Set output e.g. pin 24 direction to "out" and value to 1
+ - Set input e.g. pin 28 direction to "in" and edge to "both"
+ - Read input pin by polling
+ - Once input pin is triggered to input value 1, set output value to 0
+
+Once built, you can find the binary inside your tree at:
+
+out/target/product/dragonboard/symbols/system/bin/gpio_playground
+
+Do the following to deploy the sample:
+ - adb root
+ - adb remount
+ - adb sync
+
+Hardware setup:
+ - You need to connect a GPIO pin as output to an LED
+ - You need to connect a GPIO pin as input to a push button switch
+
+Do the following to run the sample on Dragonboard and check logs for info:
+ - Open a shell window and run: adb logcat
+ - Open another shell window and run:
+   - Default input pin 28 and output pin 24
+     - adb shell '/system/bin/gpio_playground &'
+   - Choose your own output and input pins
+     - adb shell '/system/bin/gpio_playground --gin=<input> --gout=<output> &'
+     - For example, adb shell '/system/bin/gpio_playground --gin=28 --gout=24 &'
+ - Observe the logging info from the first window
+ - Observe that the LED of pin 24 is turned on
+ - Now push the switch of pin 28 and see that the LED gets turned off
+
+Notes:
+ - There is a GPIO port offset defined by const kDefaultGpioOffset that depends 
+   on what kind of boards you use. For Dragonboard it is 902. This offset can
+   also be configured by a commandline parameter.
+ - There is an output pin and input pin defined by const kDefaultGpioOut and
+   kDefaultGpioIn respectively.  They can both be configured by commandline
+   parameters.

diff --git a/common/brillo_gpios/brillo_gpios.mk b/common/brillo_gpios/brillo_gpios.mk
new file mode 100644
index 0000000..2c92214
--- /dev/null
+++ b/common/brillo_gpios/brillo_gpios.mk

@@ -0,0 +1,22 @@
+#
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+$(call inherit-product, device/generic/brillo/brillo_base.mk)
+
+PRODUCT_NAME := brillo_gpios
+PRODUCT_BRAND := Brillo
+
+PRODUCT_DEVICE := dragonboard
+PRODUCT_PACKAGES += gpio_playground

diff --git a/common/brillo_gpios/src/gpio_playground/Android.mk b/common/brillo_gpios/src/gpio_playground/Android.mk
new file mode 100644
index 0000000..cf4ca71
--- /dev/null
+++ b/common/brillo_gpios/src/gpio_playground/Android.mk

@@ -0,0 +1,24 @@
+#
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := gpio_playground
+LOCAL_SRC_FILES := gpio_playground.cpp
+LOCAL_SHARED_LIBRARIES := libchrome libbrillo libbrillo-stream
+LOCAL_C_INCLUDES := external/gtest/include
+LOCAL_CFLAGS := -Wall -Werror -Wno-error=unused-parameter
+include $(BUILD_EXECUTABLE)

diff --git a/common/brillo_gpios/src/gpio_playground/gpio_playground.cpp b/common/brillo_gpios/src/gpio_playground/gpio_playground.cpp
new file mode 100644
index 0000000..2e6319d
--- /dev/null
+++ b/common/brillo_gpios/src/gpio_playground/gpio_playground.cpp

@@ -0,0 +1,212 @@
+/* Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include <sys/poll.h>
+#include <sys/signalfd.h>
+#include <sys/timerfd.h>
+
+#include <base/files/file_path.h>
+#include <base/format_macros.h>
+#include <base/logging.h>
+#include <base/strings/stringprintf.h>
+#include <base/strings/string_number_conversions.h>
+#include <base/strings/string_util.h>
+
+#include <brillo/flag_helper.h>
+#include <brillo/streams/file_stream.h>
+#include <brillo/streams/stream_utils.h>
+
+// Define defaults that work on the Dragonboard 410c.
+const int kDefaultGpioPortOffset = 902;
+const int kDefaultGpioOut = 24;
+const int kDefaultGpioIn = 28;
+
+// GPIO sysfs path
+const char* const kGPIOSysfsPath = "/sys/class/gpio";
+// GPIO polling timeout in milliseconds
+const int kPollTimeoutMsecs = 3000; /* 3 seconds */
+const int kBufSize = 10;
+
+namespace {
+
+/*
+ * Get a file stream for GPIO export
+ * bool write: access mode with true for write
+ * return: file stream pointer
+ */
+brillo::StreamPtr GetGPIOExportStream(bool write) {
+  std::string gpio_path;
+  gpio_path = base::StringPrintf("%s/export", kGPIOSysfsPath);
+  base::FilePath dev_path{gpio_path};
+  auto access_mode = brillo::stream_utils::MakeAccessMode(!write, write);
+  return brillo::FileStream::Open(
+      dev_path, access_mode, brillo::FileStream::Disposition::OPEN_EXISTING,
+      nullptr);
+}
+
+/*
+ * Get a file stream for GPIO data
+ * int gpio: GPIO pin number
+ * std::string type: GPIO type e.g. direction, edge, value
+ * bool write: access mode with true for write
+ * return: file stream pointer
+ */
+brillo::StreamPtr GetGPIODataStream(int gpio, const std::string type, bool write) {
+  std::string gpio_path;
+  gpio_path = base::StringPrintf("%s/gpio%d/%s", kGPIOSysfsPath, gpio, type.c_str());
+  base::FilePath dev_path{gpio_path};
+  auto access_mode = brillo::stream_utils::MakeAccessMode(!write, write);
+  return brillo::FileStream::Open(
+      dev_path, access_mode, brillo::FileStream::Disposition::OPEN_EXISTING,
+      nullptr);
+}
+
+}  // anonymous namespace
+
+/*
+ * Export GPIO to user space
+ * int gpio: GPIO pin number
+ */
+void export_gpio(int gpio) {
+
+  brillo::StreamPtr stream = GetGPIOExportStream(true);
+  if (!stream)
+    return;
+
+  std::string value = base::StringPrintf("%d", gpio);
+  stream->WriteAllBlocking(value.data(), value.size(), nullptr);
+}
+
+/*
+ * Write to GPIO
+ * std::string type: what GPIO type i.e. direction, value, edge
+ * std::string v: value to be written
+ * return: true
+ */
+bool write_gpio(int gpio, const std::string type, std::string v) {
+
+  brillo::StreamPtr stream = GetGPIODataStream(gpio, type, true);
+  if (!stream)
+    return false;
+
+  stream->WriteAllBlocking(v.data(), v.size(), nullptr);
+  return true;
+}
+
+/*
+ * This method polls GPIO pin for 0 -> 1 transition.
+ * int gpio: GPIO pin to be polled.
+ * return:
+ *   true if polling reads back successfully
+ *   false if GPIO open error or polling error
+ */
+bool poll_gpio(int gpio) {
+  char buf[kBufSize];
+  struct pollfd fdset[1];
+  int nfds = 1;
+  int fd = -1;
+  int rc = -1;
+  int len = -1;
+
+  std::string gpio_path;
+  gpio_path = base::StringPrintf("%s/gpio%d/value", kGPIOSysfsPath, gpio);
+  fd = open(gpio_path.c_str(), O_RDONLY | O_NONBLOCK );
+  if (fd < 0) {
+     PLOG(ERROR) << "GPIO open error";
+     return false;
+  }
+
+  // Use this sawZeroValue to ignore the first spurious interrupt.
+  bool sawZeroValue = false;
+
+  while(1) {
+    memset((void*)fdset, 0, sizeof(fdset));
+    fdset[0].fd = fd;
+    fdset[0].events = POLLPRI;
+
+    rc = poll(fdset, nfds, kPollTimeoutMsecs);
+    if (rc < 0) {
+      PLOG(ERROR) << "poll() failed!";
+      close(fd);
+      return false;
+    } else if (rc == 0) {
+      LOG(INFO) << "polling...";
+    } else if (fdset[0].revents & POLLPRI) {
+      len = read(fdset[0].fd, buf, kBufSize - 1);
+      lseek(fdset[0].fd, 0, SEEK_SET);
+      if (len >= 0) {
+        buf[len] = '\0';
+      }
+      // TODO: http://b/25317933 Handle the case where read()
+      // might result in multiple events being read.
+      if (buf[0] == '0') {
+        LOG(INFO) << "First interrupt with value 0 ignored.";
+        sawZeroValue = true;
+        continue;
+      }
+      if (sawZeroValue && buf[0] == '1') {
+        LOG(INFO) << "GPIO pin reset and interrupt with value 1 caught.";
+        close(fd);
+        return true;
+      }
+    }
+  }
+  close(fd);
+  return true;
+}
+
+int main(int argc, char **argv) {
+  int gpio_out = -1;
+  int gpio_in = -1;
+  int goffset = kDefaultGpioPortOffset;
+
+  DEFINE_int32(gin, 28, "GPIO input");
+  DEFINE_int32(gout, 24, "GPIO output");
+  DEFINE_int32(goffset, 902, "GPIO port offset for Dragonboard");
+  brillo::FlagHelper::Init(argc, argv, "GPIO Playground.");
+
+  if (argc == 1 || argc == 3 || argc == 4) {
+    if (FLAGS_goffset) {
+      goffset = FLAGS_goffset;
+    }
+    gpio_out = FLAGS_gout + goffset;
+    gpio_in = FLAGS_gin + goffset;
+  } else {
+    printf("Pass input & output GPIO pin as follows\n");
+    printf("adb shell '/system/bin/gpio_playground --gin=28 --gout=24 --goffset=902 &'\n");
+    return -1;
+  }
+
+  LOG(INFO) << "Export pin " << kDefaultGpioOut << " to userspace";
+  export_gpio(gpio_out);
+  LOG(INFO) << "Set pin " << kDefaultGpioOut << " direction to out";
+  write_gpio(gpio_out, "direction", "out");
+  LOG(INFO) << "Set pin " << kDefaultGpioOut << " value to 1";
+  write_gpio(gpio_out, "value", "1");
+
+  LOG(INFO) << "Export pin " << kDefaultGpioIn << " to userspace";
+  export_gpio(gpio_in);
+  LOG(INFO) << "Set pin " << kDefaultGpioIn << " direction to in";
+  write_gpio(gpio_in, "direction", "in");
+  LOG(INFO) << "Set pin " << kDefaultGpioIn << " edge to both";
+  write_gpio(gpio_in, "edge", "both");
+
+  if (poll_gpio(gpio_in)) {
+    LOG(INFO) << "Pin " << kDefaultGpioIn << " pushed. Now turn off LED";
+    write_gpio(gpio_out, "value", "0");
+  }
+  return 0;
+}

diff --git a/common/brillo_gpios/vendorsetup.sh b/common/brillo_gpios/vendorsetup.sh
new file mode 100644
index 0000000..cdec5ff
--- /dev/null
+++ b/common/brillo_gpios/vendorsetup.sh

@@ -0,0 +1 @@
+add_lunch_combo brillo_gpios-userdebug

diff --git a/common/brillo_i2c/AndroidProducts.mk b/common/brillo_i2c/AndroidProducts.mk
new file mode 100644
index 0000000..bb7c051
--- /dev/null
+++ b/common/brillo_i2c/AndroidProducts.mk

@@ -0,0 +1,14 @@
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+PRODUCT_MAKEFILES := $(LOCAL_DIR)/brillo_i2c.mk

diff --git a/common/brillo_i2c/brillo_i2c.mk b/common/brillo_i2c/brillo_i2c.mk
new file mode 100644
index 0000000..5ebc92a
--- /dev/null
+++ b/common/brillo_i2c/brillo_i2c.mk

@@ -0,0 +1,20 @@
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+$(call inherit-product, device/generic/brillo/brillo_base.mk)
+
+PRODUCT_NAME := brillo_i2c
+PRODUCT_BRAND := Brillo
+
+PRODUCT_DEVICE := dragonboard

diff --git a/common/brillo_i2c/src/i2c_service/Android.mk b/common/brillo_i2c/src/i2c_service/Android.mk
new file mode 100644
index 0000000..4f4df94
--- /dev/null
+++ b/common/brillo_i2c/src/i2c_service/Android.mk

@@ -0,0 +1,23 @@
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := i2c_service
+LOCAL_REQUIRED_MODULES := init.i2c_service.rc
+LOCAL_SRC_FILES := i2c_service.cpp i2c_device.cpp
+LOCAL_SHARED_LIBRARIES := libc libbase
+LOCAL_CFLAGS := -Werror
+include $(BUILD_EXECUTABLE)

diff --git a/common/brillo_i2c/src/i2c_service/i2c_device.cpp b/common/brillo_i2c/src/i2c_service/i2c_device.cpp
new file mode 100644
index 0000000..35089b6
--- /dev/null
+++ b/common/brillo_i2c/src/i2c_service/i2c_device.cpp

@@ -0,0 +1,131 @@
+// Copyright 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include "i2c_device.h"
+
+I2CDevice::I2CDevice(const char* device_filename,
+                     const uint8_t device_address) :
+  // Does nothing except store the constant values.
+  address_(device_address),
+  filename_(device_filename)
+
+  {
+    LOG(INFO) << "New i2c device for " << address_ << " at " << filename_;
+  }
+
+
+int I2CDevice::Begin() {
+  // First, this opens the /dev device.
+  int rc = open_i2c();
+  if (rc < 0) {
+    return rc;
+  }
+  // Then, registers it as a slave.
+  rc = enslave_i2c();
+  if (rc < 0) {
+    return rc;
+  }
+  return 0;
+}
+
+
+int I2CDevice::End() {
+  return close(fd_);
+}
+
+
+int I2CDevice::open_i2c() {
+  // Opening the device is just a R/W file open.
+  int fd = open(filename_, O_RDWR);
+  if (-1 == fd) {
+    PLOG(ERROR) << "Could not open i2c device.";
+    return -1;
+  }
+  LOG(INFO) << "i2c device opened at " << filename_;
+  fd_ = fd;
+  return fd;
+}
+
+
+int I2CDevice::enslave_i2c() {
+  // The I2C_SLAVE ioctl is sent to the device at the given address.
+  int rc = ioctl(fd_, I2C_SLAVE, address_);
+  if (rc < 0) {
+    PLOG(ERROR) << "i2c device failed to become a slave.";
+    return rc;
+  }
+  printf("yes %x\n", address_);
+  LOG(INFO) << "i2c device is a slave at" << filename_;
+  return rc;
+}
+
+
+int I2CDevice::Send(struct i2c_msg messages[],
+                    const size_t count) {
+  // Sending messages requires them to be wrapped in the i2c_rdwr_ioctl_data
+  // struct and sending them using the I2C_RDWR ioctl.
+  struct i2c_rdwr_ioctl_data data = {
+    .msgs = messages,
+    .nmsgs = count
+  };
+  int rc = ioctl(fd_, I2C_RDWR, &data);
+  if (rc < 0) {
+    PLOG(ERROR) << "Unable to send data.";
+  }
+  return rc;
+}
+
+
+int I2CDevice::SetRegister(const uint8_t register_address,
+                           const uint8_t value) {
+  // Setting a register involves sending a single message with a 2-byte payload.
+  // The first byte is the register address, and the second is the value.
+  uint8_t outbuf[] = {register_address, value};
+  struct i2c_msg messages[1];
+  messages[0] = {
+    .addr = address_,
+    .flags = 0,
+    .len = sizeof(outbuf),
+    .buf = outbuf
+  };
+  return Send(messages, 1);
+}
+
+
+int I2CDevice::GetRegister(const uint8_t register_address,
+                           uint8_t& value) {
+  // Reading a register involves sending two messages, each with a single-byte
+  // payload. The first message contains the register address and the second
+  // message is empty and will contain the response value.
+  struct i2c_msg messages[2];
+  uint8_t outbuf = register_address;
+  // Both messages need the addr value set.
+  messages[0] = {
+    .addr = address_,
+    .flags = 0,
+    .len = 1,
+    .buf = &outbuf
+  };
+  // Needs to pass the I2C_M_RD flag in order to get the value.
+  messages[1] = {
+    .addr = address_,
+    .flags = I2C_M_RD,
+    .len = 1,
+    .buf = &value,
+  };
+  // Will contain the register value.
+  int rc = Send(messages, 2);
+  return rc;
+}

diff --git a/common/brillo_i2c/src/i2c_service/i2c_device.h b/common/brillo_i2c/src/i2c_service/i2c_device.h
new file mode 100644
index 0000000..62eec04
--- /dev/null
+++ b/common/brillo_i2c/src/i2c_service/i2c_device.h

@@ -0,0 +1,70 @@
+// Copyright 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Defines a single i2c device at an address for a named i2c bus.
+//
+// Can be used to read and write i2c registers, or send arbitrary streams of
+// messages.
+
+
+#include <fcntl.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <android-base/logging.h>
+
+
+class I2CDevice {
+
+ public:
+  // Creates an I2CDevice for a given filename and address.
+  //
+  // For example: I2CDevice my_device("/dev/i2c-0", 0x20);
+  //
+  // Note: this constructor does not actually open the device, Begin() must be
+  // called at the appropriate time.
+  I2CDevice(const char* device_filename,
+            const uint8_t device_address);
+  // Opens the device for reading and writing. Returns 0 on success, or the
+  // error code from the open/ioctl operations.
+  int Begin();
+  // Closes the device. Returns 0 on success or the error code from the close
+  // operation.
+  int End();
+  // Sends a sequence of I2C messages. This is used for write operations AND
+  // read operations, since reads are just an empty outbound message. Returns 0
+  // on success or the error code from the ioctl operation.
+  int Send(struct i2c_msg messages[],
+           const size_t count);
+  // Sets a register at a given address to a given value. Returns 0 on success
+  // or the error code from the ioctl operation.
+  int SetRegister(const uint8_t register_address,
+                  const uint8_t value);
+  // Reads a register into a passed value. Returns 0 on success or the error
+  // code from the ioctl operation.
+  int GetRegister(const uint8_t register_address,
+                  uint8_t& value);
+
+ private:
+  // Demonstrates opening a device.
+  int open_i2c();
+  // Demonstrates sending the I2C_SLAVE ioctl.
+  int enslave_i2c();
+
+  // Stores the device address.
+  const uint8_t address_;
+  // Stores the device filename.
+  const char* filename_;
+  // Stores the open file descriptor for the device.
+  int fd_;
+};

diff --git a/common/brillo_i2c/src/i2c_service/i2c_service.cpp b/common/brillo_i2c/src/i2c_service/i2c_service.cpp
new file mode 100644
index 0000000..dd6f9c8
--- /dev/null
+++ b/common/brillo_i2c/src/i2c_service/i2c_service.cpp

@@ -0,0 +1,121 @@
+// Copyright 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+// Example of using i2c devices with Brillo.
+//
+// These use /dev/i2c-6. On the dragonboard 410c, this device maps to i2c1 on
+// pins 19 (SCL) and 21 (SDA).
+
+
+#include <android-base/logging.h>
+
+#include "i2c_device.h"
+
+
+// Example of using the mcp23017 IO port expander.
+//
+// On the expander, pin0 is an output pin, and pin1 is an input pin, simply
+// connected to gnd through an led or switch.
+//
+// 0 -> LED -> gnd
+// 1 -> SWITCH -> gnd
+//
+// i2c is connected directly to the board. Pin1 will use the internal pullup
+// resistor of the mcp23017.
+//
+void io_expander_demo() {
+  // Opens the device at i2c1 at the default address (the default address is
+  // calculated when A0 A1 A2 pins are all pulled low).
+  I2CDevice mcp23017("/dev/i2c-6", 0x20);
+  mcp23017.Begin();
+  // Sets the pin1 as an input, the rest as output.
+  mcp23017.SetRegister(0x0,  0b00000010);
+  // Sets the internal pullup resistor for pin1.
+  mcp23017.SetRegister(0xC,  0b00000010);
+  // Sets the initial values of the GPIOA register.
+  mcp23017.SetRegister(0x12, 0b00000010);
+  uint8_t register_value;
+  while(1) {
+    // Reads the GPIOA register.
+    mcp23017.GetRegister(0x12, register_value);
+    // Decides if switch is on based on whether pin1 is low.
+    uint8_t is_switch_on = (register_value & 0b00000010) >> 1;
+    // Sets the GPIO register at pin0 to reflect the switch state on pin1.
+    mcp23017.SetRegister(0x12, is_switch_on ^ 0b10000001);
+    LOG(INFO) << (is_switch_on ? "On." : "Off.");
+    // Waiting a bit is sensible.
+    usleep(0x10000);
+  }
+}
+
+
+// Example of using the ds1307 real time clock.
+//
+// i2c is connected directly to the board.
+//
+void rtc_demo() {
+  // Opens the device at i2c1 at the default address (the default address is
+  // calculated when A0 A1 A2 pins are all pulled low).
+  I2CDevice ds1307("/dev/i2c-6", 0x68);
+  ds1307.Begin();
+  // Needs three bytes, one for each of seconds, minutes, hours.
+  uint8_t seconds_register_value = 0x0;
+  uint8_t minutes_register_value = 0x0;
+  uint8_t hours_register_value   = 0x0;
+  char time_string[10];
+  while (1) {
+    ds1307.GetRegister(0x0, seconds_register_value);
+    ds1307.GetRegister(0x1, minutes_register_value);
+    ds1307.GetRegister(0x2, hours_register_value);
+    // Munges the values based on their storage scheme.
+    int seconds = 10 * ((seconds_register_value & 0b01110000) >> 4) +
+        (seconds_register_value & 0b00001111);
+    int minutes = 10 * ((minutes_register_value & 0b01110000) >> 4) +
+        (minutes_register_value & 0b00001111);
+    int hours   = 10 * ((hours_register_value & 0b00110000) >> 4) +
+        (hours_register_value & 0b00001111);
+    sprintf(time_string, "%02d:%02d:%02d", hours, minutes, seconds);
+    LOG(INFO) << "Time is:" << time_string;
+    sleep(1);
+  }
+}
+
+
+// Example of reading the ds1307 real time clock, and writing to the mcp23017
+// port expander.
+//
+// This demo uses both devices at the same time.
+void binary_watch_demo() {
+  I2CDevice mcp23017("/dev/i2c-6", 0x20);
+  mcp23017.Begin();
+  mcp23017.SetRegister(0x0,  0b00000000);
+  mcp23017.SetRegister(0x12, 0b00000000);
+  I2CDevice ds1307("/dev/i2c-6", 0x68);
+  ds1307.Begin();
+  uint8_t seconds_register_value = 0x0;
+  while(1) {
+    ds1307.GetRegister(0x0, seconds_register_value);
+    mcp23017.SetRegister(0x12, seconds_register_value << 2);
+    sleep(1);
+  }
+}
+
+
+int main(int argc __unused, char **argv __unused) {
+  //io_expander_demo();
+  //rtc_demo();
+  binary_watch_demo();
+  return 0;
+}

diff --git a/common/brillo_i2c/vendorsetup.sh b/common/brillo_i2c/vendorsetup.sh
new file mode 100644
index 0000000..907895a
--- /dev/null
+++ b/common/brillo_i2c/vendorsetup.sh

@@ -0,0 +1,14 @@
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+add_lunch_combo brillo_i2c-userdebug

diff --git a/common/brillo_leds/AndroidProducts.mk b/common/brillo_leds/AndroidProducts.mk
new file mode 100644
index 0000000..7f9fdb1
--- /dev/null
+++ b/common/brillo_leds/AndroidProducts.mk

@@ -0,0 +1 @@
+PRODUCT_MAKEFILES := $(LOCAL_DIR)/brillo_leds.mk

diff --git a/common/brillo_leds/README b/common/brillo_leds/README
new file mode 100644
index 0000000..e0fe8ec
--- /dev/null
+++ b/common/brillo_leds/README

@@ -0,0 +1,23 @@
+README for Brillo LED sample
+
+This LED sample creates a service that can be run on Brillo Dragonboard. It animates LED 1 through LED 4.
+
+Once built, you can find the binary inside your AOSP tree at:
+
+out/target/product/dragonboard/symbols/system/bin/led_service
+
+Do the following to deploy the sample:
+
+ - adb root
+ - adb remount
+ - adb sync
+
+Do the following to run the sample on Dragonboard:
+
+ - adb shell
+ - /system/bin/led_service &
+ - logcat
+
+Note the last step shows logging info
+
+

diff --git a/common/brillo_leds/brillo_leds.mk b/common/brillo_leds/brillo_leds.mk
new file mode 100644
index 0000000..cc2b31e
--- /dev/null
+++ b/common/brillo_leds/brillo_leds.mk

@@ -0,0 +1,8 @@
+$(call inherit-product, device/generic/brillo/brillo_base.mk)
+
+PRODUCT_NAME := brillo_leds
+PRODUCT_BRAND := Brillo
+
+PRODUCT_DEVICE := dragonboard
+PRODUCT_PACKAGES += brillo_led_tool
+

diff --git a/common/brillo_leds/src/brillo_led_tool/Android.mk b/common/brillo_leds/src/brillo_led_tool/Android.mk
new file mode 100644
index 0000000..b9a1320
--- /dev/null
+++ b/common/brillo_leds/src/brillo_led_tool/Android.mk

@@ -0,0 +1,7 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := brillo_led_tool
+LOCAL_SRC_FILES := brillo_led_tool.cpp
+LOCAL_SHARED_LIBRARIES := libc libbase
+LOCAL_CFLAGS := -Werror
+include $(BUILD_EXECUTABLE)

diff --git a/common/brillo_leds/src/brillo_led_tool/brillo_led_tool.cpp b/common/brillo_leds/src/brillo_led_tool/brillo_led_tool.cpp
new file mode 100644
index 0000000..10454f7
--- /dev/null
+++ b/common/brillo_leds/src/brillo_led_tool/brillo_led_tool.cpp

@@ -0,0 +1,33 @@
+#include <unistd.h>
+#include <android-base/logging.h>
+
+int main(int argc __unused, char **argv __unused) {
+  static const char* const leds[] = {
+    "/sys/class/leds/led1/brightness",
+    "/sys/class/leds/led2/brightness",
+    "/sys/class/leds/led3/brightness",
+    "/sys/class/leds/boot/brightness"
+  };
+
+  LOG(INFO) << "starting blinking LEDs";
+  int i = 0;
+  for(;;) {
+    FILE *fp;
+    fp = fopen(leds[i], "w");
+    if (fp == NULL) {
+      PLOG(ERROR) << "Error opening file";
+      return 0;
+    } else {
+      fputs("255", fp);
+      fseek(fp, 0, SEEK_SET);
+      sleep(1);
+      fputs("0", fp);
+      fclose(fp);
+      LOG(INFO) << "toggling LED " << i + 1 << " on/off";
+      i++;
+      i = i % 4;
+    }
+  }
+  LOG(INFO) << "exiting";
+  return 0;
+}

diff --git a/common/brillo_leds/vendorsetup.sh b/common/brillo_leds/vendorsetup.sh
new file mode 100644
index 0000000..ace4f2e
--- /dev/null
+++ b/common/brillo_leds/vendorsetup.sh

@@ -0,0 +1 @@
+add_lunch_combo brillo_leds-userdebug

diff --git a/common/dbus_example/Android.mk b/common/dbus_example/Android.mk
new file mode 100644
index 0000000..5b97f08
--- /dev/null
+++ b/common/dbus_example/Android.mk

@@ -0,0 +1,42 @@
+#
+# Copyright (C) 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+dbus_exampleCommonCppExtension := .cc
+dbus_exampleCommonCFlags := -Wall -Werror -Wno-sign-promo \
+  -Wno-unused-parameter
+dbus_exampleCommonSharedLibraries := \
+  libchrome \
+  libchrome-dbus \
+  libdbus \
+  liblog \
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := dbus-example-daemon
+LOCAL_SRC_FILES := dbus-example-daemon.cc
+LOCAL_SHARED_LIBRARIES := $(dbus_exampleCommonSharedLibraries)
+LOCAL_CPP_EXTENSION := $(dbus_exampleCommonCppExtension)
+LOCAL_CFLAGS := $(dbus_exampleCommonCFlags)
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := dbus-example-client
+LOCAL_SRC_FILES := dbus-example-client.cc
+LOCAL_SHARED_LIBRARIES := $(dbus_exampleCommonSharedLibraries)
+LOCAL_CPP_EXTENSION := $(dbus_exampleCommonCppExtension)
+LOCAL_CFLAGS := $(dbus_exampleCommonCFlags)
+include $(BUILD_EXECUTABLE)

diff --git a/common/dbus_example/build.gradle b/common/dbus_example/build.gradle
new file mode 100644
index 0000000..4271050
--- /dev/null
+++ b/common/dbus_example/build.gradle

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Return the android build root. */
+def gettop = {
+    File cwd = new File('.').absoluteFile
+    while (!(new File(cwd, 'build/core/envsetup.mk')).isFile()) {
+        cwd = cwd.parentFile
+    }
+    return cwd
+}
+
+ext.android_build_root = gettop()
+ext.nr_threads = Runtime.runtime.availableProcessors()
+
+/* Invoke an Android Build System command. */
+def call_abs(cmd) {
+    String full_cmd = 'source "' + android_build_root + '/build/envsetup.sh" && ' + cmd
+    println 'Calling ' + full_cmd
+    exec {
+        commandLine 'sh', '-c', full_cmd
+    }
+}
+
+task build << {
+    call_abs 'mm -j ' + nr_threads
+}
+
+task clean << {
+    call_abs 'm clean'
+}
+
+task buildAll << {
+    call_abs 'm -j ' + nr_threads
+}
+
+task emulator(type: Exec) {
+    commandLine 'emulator-arm'
+}

diff --git a/common/dbus_example/constants.h b/common/dbus_example/constants.h
new file mode 100644
index 0000000..2286440
--- /dev/null
+++ b/common/dbus_example/constants.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEVICE_GENERIC_BRILLO_EXAMPLES_DBUS_CONSTANTS_H_
+#define DEVICE_GENERIC_BRILLO_EXAMPLES_DBUS_CONSTANTS_H_
+
+namespace dbus_example {
+
+// D-Bus-related constants.
+static const char kServicePath[] = "/com/android/brillo/DBusExample";
+static const char kServiceName[] = "com.android.brillo.DBusExample";
+static const char kInterface[] = "com.android.brillo.DBusExample";
+static const char kMethodName[] = "Ping";
+
+}  // namespace dbus_example
+
+#endif  // DEVICE_GENERIC_BRILLO_EXAMPLES_DBUS_CONSTANTS_H_

diff --git a/common/dbus_example/dbus-example-client.cc b/common/dbus_example/dbus-example-client.cc
new file mode 100644
index 0000000..171bc6f
--- /dev/null
+++ b/common/dbus_example/dbus-example-client.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unistd.h>
+
+#include <memory>
+
+#include <dbus/bus.h>
+#include <dbus/message.h>
+#include <dbus/object_proxy.h>
+#include <utils/Log.h>
+
+#include "constants.h"
+
+// Used implicitly.
+#undef LOG_TAG
+#define LOG_TAG "dbus-example-client"
+
+int main(int argc, char *argv[]) {
+  dbus::Bus::Options options;
+  options.bus_type = dbus::Bus::SYSTEM;
+  scoped_refptr<dbus::Bus> bus(new dbus::Bus(options));
+  CHECK(bus->Connect());
+  dbus::ObjectProxy* proxy = bus->GetObjectProxy(
+      dbus_example::kServiceName, dbus::ObjectPath(dbus_example::kServicePath));
+  CHECK(proxy);
+
+  int32_t token = 1;
+  while (true) {
+    dbus::MethodCall method_call(dbus_example::kInterface,
+                                 dbus_example::kMethodName);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendInt32(token);
+
+    ALOGI("Calling %s with %d", dbus_example::kMethodName, token);
+    std::unique_ptr<dbus::Response> response(
+        proxy->CallMethodAndBlock(
+            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    if (!response) {
+      ALOGE("Didn't receive response from server");
+    } else {
+      int32_t response_token = 0;
+      dbus::MessageReader reader(response.get());
+      if (!reader.PopInt32(&response_token))
+        ALOGE("Missing token in response from server");
+      else
+        ALOGI("Received %d", response_token);
+    }
+
+    token++;
+    sleep(1);
+  }
+
+  return 0;
+}

diff --git a/common/dbus_example/dbus-example-daemon.cc b/common/dbus_example/dbus-example-daemon.cc
new file mode 100644
index 0000000..6a069e1
--- /dev/null
+++ b/common/dbus_example/dbus-example-daemon.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <memory>
+
+#include <base/at_exit.h>
+#include <base/bind.h>
+#include <base/memory/ref_counted.h>
+#include <base/message_loop/message_loop.h>
+#include <base/run_loop.h>
+#include <dbus/bus.h>
+#include <dbus/exported_object.h>
+#include <dbus/message.h>
+#include <utils/Log.h>
+
+#include "constants.h"
+
+// Used implicitly.
+#undef LOG_TAG
+#define LOG_TAG "dbus-example-daemon"
+
+namespace dbus_example {
+namespace {
+
+class Daemon {
+ public:
+  Daemon() : dbus_object_(nullptr) {}
+  ~Daemon() {}
+
+  void Init() {
+    ALOGI("Connecting to system bus");
+    dbus::Bus::Options options;
+    options.bus_type = dbus::Bus::SYSTEM;
+    bus_ = new dbus::Bus(options);
+    CHECK(bus_->Connect());
+
+    ALOGI("Exporting method %s on %s", kMethodName, kServicePath);
+    dbus_object_ = bus_->GetExportedObject(dbus::ObjectPath(kServicePath));
+    CHECK(dbus_object_->ExportMethodAndBlock(
+        kInterface, kMethodName,
+        base::Bind(&Daemon::HandleMethodCall, base::Unretained(this))));
+
+    ALOGI("Requesting ownership of %s", kServiceName);
+    CHECK(bus_->RequestOwnershipAndBlock(kServiceName,
+                                         dbus::Bus::REQUIRE_PRIMARY));
+  }
+
+ private:
+  void HandleMethodCall(dbus::MethodCall* method_call,
+                        dbus::ExportedObject::ResponseSender response_sender) {
+    int32_t token = 0;
+    dbus::MessageReader reader(method_call);
+    if (!reader.PopInt32(&token)) {
+      ALOGE("Request didn't have token");
+      response_sender.Run(std::unique_ptr<dbus::Response>(
+          dbus::ErrorResponse::FromMethodCall(method_call,
+              DBUS_ERROR_INVALID_ARGS, "Expected token argument")));
+      return;
+    }
+
+    std::unique_ptr<dbus::Response> response =
+        dbus::Response::FromMethodCall(method_call);
+    dbus::MessageWriter writer(response.get());
+    writer.AppendInt32(token);
+    ALOGI("Replying to request with token %d", token);
+    response_sender.Run(std::move(response));
+  }
+
+  scoped_refptr<dbus::Bus> bus_;
+  dbus::ExportedObject* dbus_object_;  // weak; owned by |bus_|
+
+  DISALLOW_COPY_AND_ASSIGN(Daemon);
+};
+
+}  // namespace
+}  // namespace dbus_example
+
+int main(int argc, char *argv[]) {
+  base::AtExitManager at_exit;
+  base::MessageLoopForIO loop;
+  dbus_example::Daemon daemon;
+  daemon.Init();
+  base::RunLoop().Run();
+  return 0;
+}

diff --git a/common/keyboard_example/Android.mk b/common/keyboard_example/Android.mk
new file mode 100644
index 0000000..f2c5942
--- /dev/null
+++ b/common/keyboard_example/Android.mk

@@ -0,0 +1,24 @@
+#
+# Copyright (C) 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := keyboard-example
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := keyboard_example.cpp
+include $(BUILD_EXECUTABLE)

diff --git a/common/keyboard_example/README b/common/keyboard_example/README
new file mode 100644
index 0000000..7ecd119
--- /dev/null
+++ b/common/keyboard_example/README

@@ -0,0 +1,14 @@
+This folder contains example code for writing native apps that use keyboard
+inputs.
+
+Example file:
+  keyboard_example.cpp:
+    Demos listing devices and querying their metadata, polling for keyboard
+    events and detecting different events (pressed, released, hold) for a given
+    key.
+
+    This uses the evdev kernel mechanism to handle input events. It does not use
+    the input HAL.
+    See https://www.kernel.org/doc/Documentation/input/input.txt and
+    https://www.kernel.org/doc/Documentation/input/event-codes.txt for more
+    information.

diff --git a/common/keyboard_example/keyboard_example.cpp b/common/keyboard_example/keyboard_example.cpp
new file mode 100644
index 0000000..3358be9
--- /dev/null
+++ b/common/keyboard_example/keyboard_example.cpp

@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/input.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/poll.h>
+#include <unistd.h>
+
+#include <string>
+#include <vector>
+
+using std::string;
+using std::vector;
+
+static const int kMaxDeviceName = 80;
+
+// Reads the list of files in |directory_path| into |filenames|.
+void ListDirectory(const string& directory_path, vector<string>* filenames) {
+  if (!filenames) {
+    printf("Error: filenames is null.\n");
+    exit(1);
+  }
+  DIR* directory = opendir(directory_path.c_str());
+  if (!directory) {
+    printf("Failed to open %s.\n", directory_path.c_str());
+    return;
+  }
+  struct dirent *entry = NULL;
+  while ((entry = readdir(directory))) {
+    if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
+      filenames->push_back(directory_path + "/" + entry->d_name);
+    }
+  }
+}
+
+// Returns true iff the device reports EV_KEY events.
+bool HasKeyEvents(int device_fd) {
+  unsigned long evbit = 0;
+  // Get the bit field of available event types.
+  ioctl(device_fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
+  return evbit & (1 << EV_KEY);
+}
+
+// Returns true iff the given device has |key|.
+bool HasSpecificKey(int device_fd, unsigned int key) {
+  size_t nchar = KEY_MAX/8 + 1;
+  unsigned char bits[nchar];
+  // Get the bit fields of available keys.
+  ioctl(device_fd, EVIOCGBIT(EV_KEY, sizeof(bits)), &bits);
+  return bits[key/8] & (1 << (key % 8));
+}
+
+int main(int argc, char** argv) {
+  string input_directory = "/dev/input";
+  if (argc < 2) {
+    printf("No input directory specified, using the default one: %s.\n",
+           input_directory.c_str());
+  } else {
+    input_directory = argv[1];
+  }
+
+  vector<string> filenames;
+  ListDirectory(input_directory, &filenames);
+  printf("%i devices found in %s.\n", filenames.size(),
+         input_directory.c_str());
+
+  // Initializing the pollfd structures.
+  vector<pollfd> poll_fds;
+  char device_name[kMaxDeviceName];
+  for (size_t i = 0; i < filenames.size(); i++) {
+    int fd = open(filenames[i].c_str(), O_RDONLY);
+    if (fd < 0) {
+      printf("Failed to open %s for reading: %s\n", filenames[i].c_str(),
+             strerror(errno));
+      return 1;
+    }
+
+    // Reads the device name.
+    if(ioctl(fd, EVIOCGNAME(sizeof(device_name) - 1),
+             &device_name) < 1) {
+      device_name[0] = '\0';
+    }
+
+    if (!HasKeyEvents(fd)) {
+      printf("Discarding %s (%s): does not report any EV_KEY events.\n",
+             filenames[i].c_str(), device_name);
+      continue;
+    }
+    if (!HasSpecificKey(fd, KEY_B)) {
+      printf("Discarding %s (%s): does not have a B key.\n",
+             filenames[i].c_str(), device_name);
+      continue;
+    }
+    poll_fds.push_back(pollfd{fd, POLLIN, 0});
+
+    printf("Adding device %s: %s\n", filenames[i].c_str(), device_name);
+  }
+
+  if (poll_fds.empty()) {
+    printf("No keyboard detected, exiting.\n");
+    return 1;
+  }
+
+  // Number of repeated events + 1.
+  int count = 1;
+  // Events accumulated for each device.
+  vector<vector<input_event>> events(poll_fds.size());
+
+  const char instructions[] = "Press B to start the game and release B to go "
+      "back to the main menu.";
+  printf("%s\n", instructions);
+  while (true) {
+    // Wait for data to be available on one of the file descriptors without
+    // timeout (-1).
+    poll(poll_fds.data(), poll_fds.size(), -1);
+
+    for (size_t i = 0; i < poll_fds.size(); i++) {
+      if (poll_fds[i].revents & POLLIN) {
+        struct input_event event;
+        if (read(poll_fds[i].fd, &event, sizeof(event)) != sizeof(event)) {
+          printf("Failed to read an event.\n");
+          return 1;
+        }
+
+        // When receiving a key event for B, add it to the list of events.
+        // Don't process it yet as there might be other events in that report.
+        if (event.type == EV_KEY && event.code == KEY_B) {
+          events[i].push_back(event);
+        }
+
+        // A SYN_REPORT event signals the end of a report, process all the
+        // previously accumulated events.
+        // At that point we only have events for B in the event vector.
+        if (event.type == EV_SYN && event.code == SYN_REPORT) {
+          for (vector<input_event>::iterator it = events[i].begin();
+               it != events[i].end(); it++) {
+            switch (it->value) {
+              case 0: {
+                // A value of 0 indicates a "key released" event.
+                double percent = 1. - 1./count;
+                printf("%.02f%% loaded.\n", percent * 100);
+                printf("B released, returning to the main menu.\n\n");
+                printf("%s\n", instructions);
+                break;
+              }
+              case 1: {
+                // A value of 1 indicates a "key pressed" event.
+                printf("B pressed, starting the game...\n");
+                count = 1;
+                break;
+              }
+              case 2: {
+                // A value of 2 indicates a "key repeat" event.
+                count++;
+                break;
+              }
+              default: {}
+            }
+          }
+          // Discard all processed events.
+          events[i].clear();
+        }
+      }
+    }
+  }
+  return 0;
+}
+

diff --git a/common/lights_example/example-app/Android.mk b/common/lights_example/example-app/Android.mk
new file mode 100644
index 0000000..6e3caae
--- /dev/null
+++ b/common/lights_example/example-app/Android.mk

@@ -0,0 +1,29 @@
+#
+# Copyright (C) 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := lights-hal-example-app
+LOCAL_MODULE_TAGS := optional
+LOCAL_SRC_FILES := hal-example-app.cpp
+LOCAL_CFLAGS := -Wall -Werror
+LOCAL_SHARED_LIBRARIES := \
+  libc \
+  libhardware \
+
+include $(BUILD_EXECUTABLE)

diff --git a/common/lights_example/example-app/README b/common/lights_example/example-app/README
new file mode 100644
index 0000000..a8fc128
--- /dev/null
+++ b/common/lights_example/example-app/README

@@ -0,0 +1,8 @@
+This folder contains example code for writing native apps that use Brillo LED
+lights.
+
+Example files:
+  hal-example-app.cpp:
+    An example app that uses the lights HAL (defined in
+    hardware/libhardware/include/lights.h) directly. The app turns on the LED
+    light used for notifications, and turns it off 3 seconds later.

diff --git a/common/lights_example/example-app/hal-example-app.cpp b/common/lights_example/example-app/hal-example-app.cpp
new file mode 100644
index 0000000..f014bd0
--- /dev/null
+++ b/common/lights_example/example-app/hal-example-app.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <err.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <hardware/hardware.h>
+#include <hardware/lights.h>
+
+int main() {
+  const hw_module_t* module = nullptr;
+  struct light_device_t* light_device = nullptr;
+
+  int ret = hw_get_module(LIGHTS_HARDWARE_MODULE_ID, &module);
+  if (ret || !module) {
+    err(1, "Failed to load %s module", LIGHTS_HARDWARE_MODULE_ID);
+  }
+
+  ret = module->methods->open(
+      module, LIGHT_ID_NOTIFICATIONS,
+      reinterpret_cast<struct hw_device_t**>(&light_device));
+  if (ret || !light_device) {
+    err(1, "Failed to open light device for %s", LIGHT_ID_NOTIFICATIONS);
+  }
+
+  struct light_state_t state = {
+      .color = 0,
+      .flashMode = LIGHT_FLASH_NONE,
+      .flashOnMS = 0,
+      .flashOffMS = 0,
+      .brightnessMode = 0,
+  };
+
+  // Turn light on for three seconds.
+  state.color = 1;
+  light_device->set_light(light_device, &state);
+  sleep(3);
+
+  // Flash for three seconds.
+  state.flashMode = LIGHT_FLASH_TIMED;
+  state.flashOnMS = 50;
+  state.flashOffMS = 50;
+  light_device->set_light(light_device, &state);
+  sleep(3);
+
+  // Turn light off.
+  state.color = 0;
+  state.flashMode = LIGHT_FLASH_NONE;
+  light_device->set_light(light_device, &state);
+
+  light_device->common.close(
+      reinterpret_cast<struct hw_device_t*>(light_device));
+
+  return 0;
+}

diff --git a/common/sensors_example/Android.mk b/common/sensors_example/Android.mk
new file mode 100644
index 0000000..e423f15
--- /dev/null
+++ b/common/sensors_example/Android.mk

@@ -0,0 +1,44 @@
+#
+# Copyright (C) 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+# Example Sensors HAL implementation.
+include $(CLEAR_VARS)
+LOCAL_MODULE := sensors.example
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_MODULE_TAGS := optional
+LOCAL_CFLAGS := -Wno-unused-parameter
+LOCAL_SRC_FILES := \
+  example_sensors.cpp \
+  sensors_hal.cpp
+include $(BUILD_SHARED_LIBRARY)
+
+# Example app that uses sensors HAL.
+include $(CLEAR_VARS)
+LOCAL_MODULE := sensors-hal-example-app
+LOCAL_SRC_FILES := hal-example-app.cpp
+LOCAL_CFLAGS := -Wno-unused-parameter
+LOCAL_SHARED_LIBRARIES := libhardware
+include $(BUILD_EXECUTABLE)
+
+# Example app that uses NDK sensors API.
+include $(CLEAR_VARS)
+LOCAL_MODULE := sensors-ndk-example-app
+LOCAL_SRC_FILES := ndk-example-app.cpp
+LOCAL_CFLAGS := -Wno-unused-parameter
+LOCAL_SHARED_LIBRARIES := libsensor
+include $(BUILD_EXECUTABLE)

diff --git a/common/sensors_example/README b/common/sensors_example/README
new file mode 100644
index 0000000..a8d2c61
--- /dev/null
+++ b/common/sensors_example/README

@@ -0,0 +1,26 @@
+This folder contains example code for writing native apps that use Brillo
+sensors. The sensors HAL implementation must exist on the device for the apps
+in this folder to run successfully.
+
+Example files:
+  hal-example-app.cpp:
+    An example app that uses the sensors HAL (defined in
+    hardware/libhardware/include/sensors.h) directly. In the app, the list of
+    sensors found on the device is printed. And if an accelerometer exists, the
+    app will read the data and print it out.
+
+  ndk-example-app.cpp:
+    An example app that uses the NDK sensors interface. In the app, the list of
+    sensors found on the device is printed. And then the app tries to read data
+    from accelerometer, proximity sensor, and significant motion sensor, which
+    has continuous, on-change, and one-shot reporting modes respectively.
+
+  sensors_hal.cpp
+    An example implementation of a sensors HAL. It implements a fake
+    accelerometer and custom sensor (defined in example_sensors.{h|cpp}). The
+    accelerometer always returns random data. The custom sensor returns the hour
+    for the local time.
+
+    To use this HAL implementation, push the binary file sensors.example into
+    /system/lib/hw/ folder and rename it to sensors.default (make sure there is
+    no other sensors.* file under that folder).

diff --git a/common/sensors_example/example_sensors.cpp b/common/sensors_example/example_sensors.cpp
new file mode 100644
index 0000000..22d5381
--- /dev/null
+++ b/common/sensors_example/example_sensors.cpp

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "example_sensors.h"
+
+#include <stdlib.h>
+#include <time.h>
+
+#include <hardware/sensors.h>
+
+SensorBase::SensorBase() {}
+SensorBase::~SensorBase() {}
+
+int SensorBase::activate(int handle, int enabled) {
+  return 0;
+}
+
+int SensorBase::setDelay(int handle, int64_t ns) {
+  return 0;
+}
+
+int SensorBase::batch(int handle, int flags,
+                      int64_t period_ns, int64_t timeout) {
+  return 0;
+}
+
+int SensorBase::flush(int handle) {
+  return 0;
+}
+
+
+Accelerometer::Accelerometer() {}
+Accelerometer::~Accelerometer() {}
+
+int Accelerometer::pollEvents(sensors_event_t* data, int count) {
+  // Returns fake random values.
+  data->acceleration.x = static_cast<float>(random() % kMaxRange);
+  data->acceleration.y = static_cast<float>(random() % kMaxRange);
+  data->acceleration.z = static_cast<float>(random() % kMaxRange);
+  return 1;
+}
+
+
+CustomSensor::CustomSensor() {}
+CustomSensor::~CustomSensor() {}
+
+int CustomSensor::pollEvents(sensors_event_t* data, int count) {
+  if (data) {
+    // For this custom sensor, we will return the hour of the local time.
+    time_t t = time(NULL);
+    struct tm* now = localtime(&t);
+    if (now) {
+      // Any field can be used to return data for a custom sensor.
+      // See definition of struct sensors_event_t in hardware/sensors.h for the
+      // available fields.
+      data->data[0] = now->tm_hour;
+      return 1;
+    }
+  }
+  // Note: poll() return value is the number of events being returned. We use
+  // -1 to signal an error.
+  return -1;
+}

diff --git a/common/sensors_example/example_sensors.h b/common/sensors_example/example_sensors.h
new file mode 100644
index 0000000..5e984ea
--- /dev/null
+++ b/common/sensors_example/example_sensors.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SENSORS_EXAMPLE_SENSORS_H
+#define SENSORS_EXAMPLE_SENSORS_H
+
+#include <stdint.h>
+
+struct sensors_event_t;
+
+class SensorBase {
+ public:
+  SensorBase();
+  virtual ~SensorBase();
+
+  virtual int activate(int handle, int enabled);
+  virtual int setDelay(int handle, int64_t ns);
+  virtual int pollEvents(sensors_event_t* data, int count) = 0;
+  virtual int batch(int handle, int flags, int64_t period_ns, int64_t timeout);
+  virtual int flush(int handle);
+};
+
+class Accelerometer : public SensorBase {
+ public:
+  static const int kMaxRange = 1000;
+
+  Accelerometer();
+  ~Accelerometer() override;
+
+  int pollEvents(sensors_event_t* data, int count) override;
+};
+
+class CustomSensor : public SensorBase {
+ public:
+  CustomSensor();
+  ~CustomSensor() override;
+
+  int pollEvents(sensors_event_t* data, int count) override;
+};
+
+#endif  // SENSORS_EXAMPLE_SENSORS_H

diff --git a/common/sensors_example/hal-example-app.cpp b/common/sensors_example/hal-example-app.cpp
new file mode 100644
index 0000000..dfec435
--- /dev/null
+++ b/common/sensors_example/hal-example-app.cpp

@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This file contains an example app that uses sensors HAL.
+ * It accepts a sensor type as an input argument and reads data from a
+ * sensor of that type.
+ *
+ * For any specified sensor type, there may be multiple such sensors defined
+ * in the HAL. Some or all of the defined sensors will actually be equipped.
+ * This test program will scan the HAL for the first equipped sensor of
+ * the specified sensor type and dump data from that sensor.
+ */
+
+#include <getopt.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <hardware/hardware.h>
+#include <hardware/sensors.h>
+
+#include <sys/types.h>
+
+#define DEFAULT_SENSOR_TYPE SENSOR_TYPE_ACCELEROMETER
+
+// Structure to hold the decoded command line options
+struct pgm_options {
+  int    sensor_type;
+};
+
+// Be sure to keep the options for longopts and shortopts in the same order
+// so that Usage() is correct.
+static struct option longopts[] = {
+  {"help",     no_argument,  NULL,  '?'},
+  {"accel",    no_argument,  NULL,  'a'},
+  {"temp",     no_argument,  NULL,  't'},
+  {"light",    no_argument,  NULL,  'l'},
+  {"orient",   no_argument,  NULL,  'o'},
+  {"prox",     no_argument,  NULL,  'p'},
+  {"motion",   no_argument,  NULL,  'm'},
+  {NULL,       0,            NULL,   0}
+};
+static char shortopts[] = "?atlopm";
+
+// Describes the options for this program.
+void Usage(char *pgm_name) {
+  printf("Usage: %s [options...]\n", pgm_name);
+  printf("Exercises the sensors HAL by direct calling.\n");
+  printf("Options:\n");
+  for (int i = 0; longopts[i].name; i++) {
+    printf("  --%-6s or -%c\n", longopts[i].name, shortopts[i]);
+  }
+}
+
+// Processes all command line options.
+//   sets the options members for commnd line options
+//   returns (0) on success, -1 otherwise.
+int ReadOpts(int argc, char **argv, struct pgm_options *options) {
+  int ch = 0;
+
+  if (!options) {
+    fprintf(stderr, "Invalid options pointer\n");
+    return 1;
+  }
+
+  while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
+    switch (ch) {
+    case 'a':
+      options->sensor_type  = SENSOR_TYPE_ACCELEROMETER;
+      break;
+    case 't':
+      options->sensor_type  = SENSOR_TYPE_TEMPERATURE;
+      break;
+    case 'l':
+      options->sensor_type  = SENSOR_TYPE_LIGHT;
+      break;
+    case 'o':
+      options->sensor_type  = SENSOR_TYPE_ORIENTATION;
+      break;
+    case 'p':
+      options->sensor_type  = SENSOR_TYPE_PROXIMITY;
+      break;
+    case 'm':
+      options->sensor_type  = SENSOR_TYPE_SIGNIFICANT_MOTION;
+      break;
+    default:
+      Usage(argv[0]);
+      return -1;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+  return 0;
+}
+
+// Prints data associated with each supported sensor type.
+// Be sure to provide a case for each sensor type supported in
+// the ReadOpts() function.
+void DisplaySensorData(int sensor_type, const sensors_event_t *data) {
+  switch (sensor_type) {
+    case SENSOR_TYPE_PROXIMITY:
+      printf("Proximity distance: %f\n", data->distance);
+      break;
+    case SENSOR_TYPE_SIGNIFICANT_MOTION:
+      if (data->data[0] == 1) {
+        printf("Significant motion detected\n");
+      }
+      break;
+    case SENSOR_TYPE_ACCELEROMETER:
+      printf("Acceleration: x = %f, y = %f, z = %f\n",
+             data->acceleration.x, data->acceleration.y, data->acceleration.z);
+      break;
+    case SENSOR_TYPE_TEMPERATURE:
+      printf("Temperature: %f\n", data->temperature);
+      break;
+    case SENSOR_TYPE_LIGHT:
+      printf("Light: %f\n", data->light);
+      break;
+    case SENSOR_TYPE_ORIENTATION: {
+      float heading =
+        atan2(static_cast<double>(data->orientation.y),
+              static_cast<double>(data->orientation.x)) * 180.0 / M_PI;
+      if (heading < 0.0)
+        heading += 360.0;
+      printf("Heading: %f, Orientation: x = %f, y = %f, z = %f\n",
+             heading, data->orientation.x, data->orientation.y,
+             data->orientation.z);
+      }
+      break;
+  }
+}
+
+int main(int argc, char* argv[]) {
+  pgm_options options = {DEFAULT_SENSOR_TYPE};
+  if (ReadOpts(argc, argv, &options) < 0)
+    return 1;
+
+  sensors_module_t* sensor_module = nullptr;
+  int ret = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
+      const_cast<hw_module_t const**>(
+      reinterpret_cast<hw_module_t**>(&sensor_module)));
+  if (ret || !sensor_module) {
+    fprintf(stderr, "Failed to load %s module: %s\n",
+            SENSORS_HARDWARE_MODULE_ID, strerror(-ret));
+    return 1;
+  }
+
+  const sensor_t *sensor_list = nullptr;
+  int sensor_count =
+      sensor_module->get_sensors_list(sensor_module, &sensor_list);
+  printf("Found %d supported sensors\n", sensor_count);
+  for (int i = 0; i < sensor_count; i++) {
+    printf("HAL supports sensor %s\n", sensor_list[i].name);
+  }
+
+  // sensors_open_1 is used in HAL versions >= 1.0.
+  sensors_poll_device_1_t* sensor_device = nullptr;
+  ret = sensors_open_1(&sensor_module->common, &sensor_device);
+  if (ret || !sensor_device) {
+    fprintf(stderr, "Failed to open the sensor HAL\n");
+    return 1;
+  }
+
+  // Find the first sensor of the specified type that can be opened
+  bool sensor_found = false;
+  const sensor_t *sensor = nullptr;
+  for (int i = 0; i < sensor_count; i++) {
+    sensor = &sensor_list[i];
+    if (sensor->type != options.sensor_type)
+      continue;
+    if (sensor_device->activate(
+        reinterpret_cast<sensors_poll_device_t*>(sensor_device),
+        sensor->handle, 1 /* enabled */) < 0) {
+      continue;
+    }
+
+    // Found an equipped sensor of the specified type.
+    sensor_found = true;
+    break;
+  }
+
+  if (!sensor_found) {
+    fprintf(stderr, "No sensor of the specified type found\n");
+    ret = sensors_close_1(sensor_device);
+    if (ret)
+      fprintf(stderr, "Failed to close the sensor device\n");
+    return 1;
+  }
+  printf("\nSensor %s activated\n", sensor->name);
+
+  const int kNumEvents = 1;
+  const int kNumSamples = 10;
+  const int kWaitTimeSecs = 1;
+  for (int i = 0; i < kNumSamples; i++) {
+    sensors_event_t data[kNumEvents];
+    memset(data, 0, sizeof(data));
+    int event_count = sensor_device->poll(
+        reinterpret_cast<sensors_poll_device_t*>(sensor_device),
+        data, kNumEvents);
+    if (!event_count) {
+      fprintf(stderr, "Failed to read data from the sensor.\n");
+      continue;
+    }
+
+    DisplaySensorData(options.sensor_type, data);
+    sleep(kWaitTimeSecs);
+  }
+
+  ret = sensor_device->activate(
+      reinterpret_cast<sensors_poll_device_t*>(sensor_device),
+      sensor->handle, 0 /* disabled */);
+  if (ret) {
+    fprintf(stderr, "Failed to disable %s: %s\n", sensor->name, strerror(ret));
+    return 1;
+  }
+
+  // sensors_close_1 is used in HAL versions >= 1.0.
+  ret = sensors_close_1(sensor_device);
+  if (ret) {
+    fprintf(stderr, "Failed to close the sensor device\n");
+    return 1;
+  }
+
+  return 0;
+}

diff --git a/common/sensors_example/ndk-example-app.cpp b/common/sensors_example/ndk-example-app.cpp
new file mode 100644
index 0000000..628068d
--- /dev/null
+++ b/common/sensors_example/ndk-example-app.cpp

@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This file contains an example app that uses sensors NDK.
+ * It accepts a sensor type as an input argument and reads data from a
+ * sensor of that type.
+ *
+ * For any specified sensor type, there may be multiple such sensors defined
+ * in the HAL. Some or all of the defined sensors will actually be equipped.
+ * This test program will scan the HAL for the first equipped sensor of
+ * the specified sensor type and dump data from that sensor.
+ */
+
+#include <getopt.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <android/looper.h>
+#include <android/sensor.h>
+#include <hardware/sensors.h>
+
+#define DEFAULT_SENSOR_TYPE SENSOR_TYPE_ACCELEROMETER
+
+// Structure to hold the decoded command line options
+struct pgm_options {
+  int    sensor_type;
+};
+
+// Be sure to keep the options for longopts and shortopts in the same order
+// so that Usage() is correct.
+static struct option longopts[] = {
+  {"help",     no_argument,  NULL,  '?'},
+  {"accel",    no_argument,  NULL,  'a'},
+  {"temp",     no_argument,  NULL,  't'},
+  {"light",    no_argument,  NULL,  'l'},
+  {"orient",   no_argument,  NULL,  'o'},
+  {"prox",     no_argument,  NULL,  'p'},
+  {"motion",   no_argument,  NULL,  'm'},
+  {NULL,       0,            NULL,   0}
+};
+static char shortopts[] = "?atlopm";
+
+// Describes the options for this program.
+void Usage(char *pgm_name) {
+  printf("Usage: %s [options...]\n", pgm_name);
+  printf("Exercises the sensors NDK by calling into the sensorserver.\n");
+  printf("Options:\n");
+  for (int i = 0; longopts[i].name; i++) {
+    printf("  --%-6s or -%c\n", longopts[i].name, shortopts[i]);
+  }
+}
+
+// Processes all command line options.
+//   sets the options members for commnd line options
+//   returns (0) on success, -1 otherwise.
+int ReadOpts(int argc, char **argv, struct pgm_options *options) {
+  int ch = 0;
+
+  if (!options) {
+    fprintf(stderr, "Invalid options pointer\n");
+    return 1;
+  }
+
+  while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
+    switch (ch) {
+    case 'a':
+      options->sensor_type  = SENSOR_TYPE_ACCELEROMETER;
+      break;
+    case 't':
+      options->sensor_type  = SENSOR_TYPE_TEMPERATURE;
+      break;
+    case 'l':
+      options->sensor_type  = SENSOR_TYPE_LIGHT;
+      break;
+    case 'o':
+      options->sensor_type  = SENSOR_TYPE_ORIENTATION;
+      break;
+    case 'p':
+      options->sensor_type  = SENSOR_TYPE_PROXIMITY;
+      break;
+    case 'm':
+      options->sensor_type  = SENSOR_TYPE_SIGNIFICANT_MOTION;
+      break;
+    default:
+      Usage(argv[0]);
+      return -1;
+    }
+  }
+  argc -= optind;
+  argv += optind;
+  return 0;
+}
+
+// Prints data associated with each supported sensor type.
+// Be sure to provide a case for each sensor type supported in
+// the ReadOpts() function.
+void DisplaySensorData(int sensor_type, const ASensorEvent *data) {
+  switch (sensor_type) {
+    case SENSOR_TYPE_PROXIMITY:
+      printf("Proximity distance: %f\n", data->distance);
+      break;
+    case SENSOR_TYPE_SIGNIFICANT_MOTION:
+      if (data->data[0] == 1) {
+        printf("Significant motion detected\n");
+      }
+      break;
+    case SENSOR_TYPE_ACCELEROMETER:
+      printf("Acceleration: x = %f, y = %f, z = %f\n",
+             data->acceleration.x, data->acceleration.y, data->acceleration.z);
+      break;
+    case SENSOR_TYPE_TEMPERATURE:
+      printf("Temperature: %f\n", data->temperature);
+      break;
+    case SENSOR_TYPE_LIGHT:
+      printf("Light: %f\n", data->light);
+      break;
+    case SENSOR_TYPE_ORIENTATION: {
+      float heading =
+        atan2(static_cast<double>(data->magnetic.y),
+              static_cast<double>(data->magnetic.x)) * 180.0 / M_PI;
+      if (heading < 0.0)
+        heading += 360.0;
+      printf("Heading: %f, Orientation: x = %f, y = %f, z = %f\n",
+             heading, data->magnetic.x, data->magnetic.y, data->magnetic.z);
+      }
+      break;
+  }
+}
+
+int main(int argc, char* argv[]) {
+  pgm_options options = {DEFAULT_SENSOR_TYPE};
+  if (ReadOpts(argc, argv, &options) < 0)
+    return 1;
+
+  const char kPackageName[] = "ndk-example-app";
+  ASensorManager* sensor_manager =
+    ASensorManager_getInstanceForPackage(kPackageName);
+  if (!sensor_manager) {
+    fprintf(stderr, "Failed to get a sensor manager\n");
+    return 1;
+  }
+
+  ASensorList sensor_list = nullptr;
+  int sensor_count = ASensorManager_getSensorList(sensor_manager, &sensor_list);
+  printf("Found %d supported sensors\n", sensor_count);
+  for (int i = 0; i < sensor_count; i++) {
+    printf("HAL supports sensor %s\n", ASensor_getName(sensor_list[i]));
+  }
+
+  const int kLooperId = 1;
+  ASensorEventQueue* queue = ASensorManager_createEventQueue(
+      sensor_manager,
+      ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS),
+      kLooperId,
+      NULL, /* no callback */
+      NULL  /* no private data for a callback  */);
+  if (!queue) {
+    fprintf(stderr, "Failed to create a sensor event queue\n");
+    return 1;
+  }
+
+  // Find the first sensor of the specified type that can be opened
+  const int kTimeoutMicroSecs = 1000000;
+  const int kTimeoutMilliSecs = 1000;
+  ASensorRef sensor = nullptr;
+  bool sensor_found = false;
+  for (int i = 0; i < sensor_count; i++) {
+    sensor = sensor_list[i];
+    if (ASensor_getType(sensor) != options.sensor_type)
+      continue;
+    if (ASensorEventQueue_enableSensor(queue, sensor) < 0)
+      continue;
+    if (ASensorEventQueue_setEventRate(queue, sensor, kTimeoutMicroSecs) < 0) {
+      fprintf(stderr, "Failed to set the %s sample rate\n",
+          ASensor_getName(sensor));
+      return 1;
+    }
+
+    // Found an equipped sensor of the specified type.
+    sensor_found = true;
+    break;
+  }
+
+  if (!sensor_found) {
+    fprintf(stderr, "No sensor of the specified type found\n");
+    int ret = ASensorManager_destroyEventQueue(sensor_manager, queue);
+    if (ret < 0)
+      fprintf(stderr, "Failed to destroy event queue: %s\n", strerror(-ret));
+    return 1;
+  }
+  printf("\nSensor %s activated\n", ASensor_getName(sensor));
+
+  const int kNumEvents = 1;
+  const int kNumSamples = 10;
+  const int kWaitTimeSecs = 1;
+  for (int i = 0; i < kNumSamples; i++) {
+    ASensorEvent data[kNumEvents];
+    memset(data, 0, sizeof(data));
+    int ident = ALooper_pollAll(
+        kTimeoutMilliSecs,
+        NULL /* no output file descriptor */,
+        NULL /* no output event */,
+        NULL /* no output data */);
+    if (ident != kLooperId) {
+      fprintf(stderr, "Incorrect Looper ident read from poll.\n");
+      continue;
+    }
+    if (ASensorEventQueue_getEvents(queue, data, kNumEvents) <= 0) {
+      fprintf(stderr, "Failed to read data from the sensor.\n");
+      continue;
+    }
+
+    DisplaySensorData(options.sensor_type, data);
+    sleep(kWaitTimeSecs);
+  }
+
+  int ret = ASensorEventQueue_disableSensor(queue, sensor);
+  if (ret < 0) {
+    fprintf(stderr, "Failed to disable %s: %s\n",
+            ASensor_getName(sensor), strerror(-ret));
+  }
+
+  ret = ASensorManager_destroyEventQueue(sensor_manager, queue);
+  if (ret < 0) {
+    fprintf(stderr, "Failed to destroy event queue: %s\n", strerror(-ret));
+    return 1;
+  }
+
+  return 0;
+}

diff --git a/common/sensors_example/sensors_hal.cpp b/common/sensors_example/sensors_hal.cpp
new file mode 100644
index 0000000..5b89e59
--- /dev/null
+++ b/common/sensors_example/sensors_hal.cpp

@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "sensors_hal.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include "example_sensors.h"
+
+SensorContext::SensorContext(const hw_module_t* module) {
+  memset(&device, 0, sizeof(device));
+
+  device.common.tag = HARDWARE_DEVICE_TAG;
+  device.common.version = SENSORS_DEVICE_API_VERSION_1_0;
+  device.common.module = const_cast<hw_module_t*>(module);
+  device.common.close = CloseWrapper;
+  device.activate = ActivateWrapper;
+  device.setDelay = SetDelayWrapper;
+  device.poll = PollEventsWrapper;
+  device.batch = BatchWrapper;
+  device.flush = FlushWrapper;
+
+  sensors[AvailableSensors::kAccelerometer] = new Accelerometer();
+  sensors[AvailableSensors::kCustom] = new CustomSensor();
+}
+
+SensorContext::~SensorContext() {
+  for (int i = 0; i < AvailableSensors::kNumSensors; i++) {
+    if (sensors[i]) delete sensors[i];
+  }
+}
+
+int SensorContext::activate(int handle, int enabled) {
+  return sensors[handle]->activate(handle, enabled);
+}
+
+int SensorContext::setDelay(int handle, int64_t ns) {
+  return sensors[handle]->setDelay(handle, ns);
+}
+
+int SensorContext::pollEvents(sensors_event_t* data, int count) {
+  return sensors[0]->pollEvents(data, count);
+}
+
+int SensorContext::batch(int handle, int flags,
+                         int64_t period_ns, int64_t timeout) {
+  return sensors[handle]->batch(handle, flags, period_ns, timeout);
+}
+
+int SensorContext::flush(int handle) {
+  return sensors[handle]->flush(handle);
+}
+
+// static
+int SensorContext::CloseWrapper(hw_device_t* dev) {
+  SensorContext* sensor_context = reinterpret_cast<SensorContext*>(dev);
+  if (sensor_context) {
+    delete sensor_context;
+  }
+  return 0;
+}
+
+// static
+int SensorContext::ActivateWrapper(sensors_poll_device_t* dev,
+                                   int handle, int enabled) {
+  return reinterpret_cast<SensorContext*>(dev)->activate(handle, enabled);
+}
+
+// static
+int SensorContext::SetDelayWrapper(sensors_poll_device_t* dev,
+                                   int handle, int64_t ns) {
+  return reinterpret_cast<SensorContext*>(dev)->setDelay(handle, ns);
+}
+
+// static
+int SensorContext::PollEventsWrapper(sensors_poll_device_t* dev,
+                                     sensors_event_t* data, int count) {
+  return reinterpret_cast<SensorContext*>(dev)->pollEvents(data, count);
+}
+
+// static
+int SensorContext::BatchWrapper(sensors_poll_device_1_t* dev, int handle,
+                                int flags, int64_t period_ns, int64_t timeout) {
+  return reinterpret_cast<SensorContext*>(dev)->batch(handle, flags, period_ns,
+                                                      timeout);
+}
+
+// static
+int SensorContext::FlushWrapper(sensors_poll_device_1_t* dev,
+                                int handle) {
+  return reinterpret_cast<SensorContext*>(dev)->flush(handle);
+}
+
+
+static int open_sensors(const struct hw_module_t* module,
+                        const char* id, struct hw_device_t** device) {
+  SensorContext* ctx = new SensorContext(module);
+  *device = &ctx->device.common;
+
+  return 0;
+}
+
+static struct hw_module_methods_t sensors_module_methods = {
+  .open = open_sensors,
+};
+
+static struct sensor_t kSensorList[] = {
+  { .name = "Broken Accelerometer",
+    .vendor = "Unknown",
+    .version = 1,
+    .handle = SensorContext::AvailableSensors::kAccelerometer,
+    .type = SENSOR_TYPE_ACCELEROMETER,
+    .maxRange = static_cast<float>(Accelerometer::kMaxRange),
+    .resolution = 100.0f,
+    .power = 0.0f,
+    .minDelay = 10000,
+    .fifoReservedEventCount = 0,
+    .fifoMaxEventCount = 0,
+    .stringType = SENSOR_STRING_TYPE_ACCELEROMETER,
+    .requiredPermission = "",
+    .maxDelay = 0,
+    .flags = SENSOR_FLAG_CONTINUOUS_MODE,
+    .reserved = {},
+  },
+  { .name = "Custom Hour of Day Sensor",
+    .vendor = "Unknown",
+    .version = 1,
+    .handle = SensorContext::AvailableSensors::kCustom,
+    .type = SENSOR_TYPE_CUSTOM,
+    .maxRange = 24.0f,
+    .resolution = 1.0f,
+    .power = 0.0f,
+    .minDelay = 1,
+    .fifoReservedEventCount = 0,
+    .fifoMaxEventCount = 0,
+    .stringType = SENSOR_STRING_TYPE_CUSTOM,
+    .requiredPermission = "",
+    .maxDelay = 0,
+    .flags = SENSOR_FLAG_CONTINUOUS_MODE,
+    .reserved = {},
+  },
+};
+
+static int get_sensors_list(struct sensors_module_t* module,
+                            struct sensor_t const** list) {
+  if (!list) return 0;
+  *list = kSensorList;
+  return sizeof(kSensorList) / sizeof(kSensorList[0]);
+}
+
+struct sensors_module_t HAL_MODULE_INFO_SYM = {
+    .common = {
+        .tag = HARDWARE_MODULE_TAG,
+        .version_major = 1,
+        .version_minor = 0,
+        .id = SENSORS_HARDWARE_MODULE_ID,
+        .name = "Example Sensor Module",
+        .author = "Google",
+        .methods = &sensors_module_methods,
+        .dso = NULL,
+        .reserved = {0},
+    },
+    .get_sensors_list = get_sensors_list,
+    .set_operation_mode = NULL
+};

diff --git a/common/sensors_example/sensors_hal.h b/common/sensors_example/sensors_hal.h
new file mode 100644
index 0000000..e563d7e
--- /dev/null
+++ b/common/sensors_example/sensors_hal.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SENSORS_SENSORS_HAL_H
+#define SENSORS_SENSORS_HAL_H
+
+/*
+ * SENSOR_TYPE_CUSTOM
+ * The custom sensor type must have a integer constant starting from 27.
+ * The string name of the custom type must also be defined.
+ */
+#define SENSOR_TYPE_CUSTOM         (27)
+#define SENSOR_STRING_TYPE_CUSTOM  "brillo.custom"
+
+#include <stdint.h>
+
+#include <hardware/sensors.h>
+
+#include "example_sensors.h"
+
+class SensorContext {
+ public:
+  sensors_poll_device_1_t device;
+
+  SensorContext(const hw_module_t* module);
+  ~SensorContext();
+
+  enum AvailableSensors {
+    kAccelerometer,
+    kCustom,
+    kNumSensors
+  };
+
+ private:
+  int activate(int handle, int enabled);
+  int setDelay(int handle, int64_t ns);
+  int pollEvents(sensors_event_t* data, int count);
+  int batch(int handle, int flags, int64_t period_ns, int64_t timeout);
+  int flush(int handle);
+
+  // The wrapper pass through to the specific instantiation of
+  // the SensorContext.
+  static int CloseWrapper(hw_device_t* dev);
+  static int ActivateWrapper(sensors_poll_device_t* dev, int handle,
+                             int enabled);
+  static int SetDelayWrapper(sensors_poll_device_t* dev, int handle,
+                             int64_t ns);
+  static int PollEventsWrapper(sensors_poll_device_t* dev,
+                               sensors_event_t* data, int count);
+  static int BatchWrapper(sensors_poll_device_1_t* dev, int handle, int flags,
+                          int64_t period_ns, int64_t timeout);
+  static int FlushWrapper(sensors_poll_device_1_t* dev, int handle);
+
+  SensorBase* sensors[AvailableSensors::kNumSensors];
+};
+
+#endif  // SENSORS_SENSORS_HAL_H

diff --git a/common/service_example/Android.mk b/common/service_example/Android.mk
new file mode 100644
index 0000000..31165a9
--- /dev/null
+++ b/common/service_example/Android.mk

@@ -0,0 +1,52 @@
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := brillo_example_service
+LOCAL_SRC_FILES := \
+    brillo_example_service.cpp \
+    android/brillo/example/IAlertCallback.aidl \
+    android/brillo/example/IExampleService.aidl
+LOCAL_AIDL_INCLUDES := $(LOCAL_PATH)
+LOCAL_CFLAGS := -Wall
+LOCAL_SHARED_LIBRARIES := \
+    libbinder \
+    libbrillo \
+    libbrillo-binder \
+    libchrome \
+    libutils
+# Uncomment the following line to have this service started automatically on
+# boot by init.
+#LOCAL_INIT_RC := example_service.rc
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := brillo_example_client
+LOCAL_SRC_FILES := \
+    brillo_example_client.cpp \
+    android/brillo/example/IAlertCallback.aidl \
+    android/brillo/example/IExampleService.aidl
+LOCAL_AIDL_INCLUDES := $(LOCAL_PATH)
+LOCAL_CFLAGS := -Wall
+LOCAL_SHARED_LIBRARIES := \
+    libbinder \
+    libbrillo \
+    libbrillo-binder \
+    libchrome \
+    libcutils \
+    libutils
+include $(BUILD_EXECUTABLE)

diff --git a/common/service_example/README.md b/common/service_example/README.md
new file mode 100644
index 0000000..47838d6
--- /dev/null
+++ b/common/service_example/README.md

@@ -0,0 +1,70 @@
+Brillo Example Service
+======================
+
+This folder contains an example Brillo service and client that use AIDL. This
+example is intended to show:
+
+1. Implementing an interface defined in AIDL.
+2. Registering a service with the service manager.
+3. Calling a service from a client.
+4. Registering a callback object from the client so the service can talk back
+     to the client.
+
+Folder layout
+-------------
+
+* android/brillo/example/IExampleService.aidl - AIDL interface for an example
+  service that accepts a string and logs it. The service also provides an
+  interface to let a client be notified once it has called the service n
+  times.
+* android/brillo/example/IAlertCallback.aidl - AIDL interface for the callback
+  object that the client registers with the service. Note the use of the
+  keyword oneway in the interface. This keyword prevents the service from
+  blocking on the client handling the callback.
+* brillo_example_service.cpp - The implementation of the AIDL service
+  interface. The service has to implement
+  android::brillo::example::BnExampleService which is done in ExampleService
+  class. The service also illustrates how to use brillo::BinderWatcher with a
+  message loop to drive the service.
+* brillo_example_client.cpp - Client application that calls the service and
+  receives callbacks. The client implements the callback object in
+  AlertCallback. AlertCallback by extending
+  android::brillo::example::BnAlertCallback. The client also uses
+  brillo::BinderWatcher and message loops to receive callbacks.
+
+The brillo_example_client reads std::in and passes that information to the
+brillo_example_service which logs it using logcat.
+
+Usage
+-----
+
+To use this example service/client:
+
+1. Open two terminals.
+2. In the first one, run
+
+        adb shell
+
+    and then start the example service in the background (not required if the
+    service is started by init)
+
+        brillo_example_service &
+
+3. Start logcat in the second terminal
+
+        adb logcat
+
+4. In the first terminal, start the example client as root.
+
+        brillo_example_client
+
+5. If you type "foo" in the first terminal followed by a newline, you should see
+   the following text in the logcat output:
+
+        brillo_example_service: foo
+
+6. After 3 messages have been sent to the service by the client, the following
+   statement will be logged by the client.
+
+        brillo_example_client: Received Callback from service: Received 3 log messages.
+

diff --git a/common/service_example/android/brillo/example/IAlertCallback.aidl b/common/service_example/android/brillo/example/IAlertCallback.aidl
new file mode 100644
index 0000000..a3eb9ee
--- /dev/null
+++ b/common/service_example/android/brillo/example/IAlertCallback.aidl

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.brillo.example;
+
+// Interface for a callback object that is to be registered with
+// IExampleService.
+interface IAlertCallback {
+  // This should be a oneway call since we don't want services to be blocked on
+  // clients.
+  oneway void OnNLogEventsReceivedCallback(int n);
+}

diff --git a/common/service_example/android/brillo/example/IExampleService.aidl b/common/service_example/android/brillo/example/IExampleService.aidl
new file mode 100644
index 0000000..d478abd
--- /dev/null
+++ b/common/service_example/android/brillo/example/IExampleService.aidl

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.brillo.example;
+
+import android.brillo.example.IAlertCallback;
+
+// Interface for an example service that accepts a string and logs it using
+// logcat. It also provides a method to register a callback.
+interface IExampleService {
+  // Registers a callback object of type IAlertCallback with the service. Once
+  // the service has recieved n calls to Log, then the method
+  // OnNEventsReceivedCallback on the callback object will be called.
+  void RegisterCallback(IAlertCallback callback, int n);
+
+  // Logs a string.
+  void Log(String s);
+}

diff --git a/common/service_example/brillo_example_client.cpp b/common/service_example/brillo_example_client.cpp
new file mode 100644
index 0000000..cb49720
--- /dev/null
+++ b/common/service_example/brillo_example_client.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+#include <string>
+
+#include <base/at_exit.h>
+#include <base/bind.h>
+#include <base/logging.h>
+#include <base/message_loop/message_loop.h>
+#include <binder/IInterface.h>
+#include <binder/IServiceManager.h>
+#include <brillo/binder_watcher.h>
+#include <brillo/message_loops/base_message_loop.h>
+#include <brillo/syslog_logging.h>
+#include <utils/String16.h>
+
+#include "android/brillo/example/BnAlertCallback.h"
+#include "android/brillo/example/IExampleService.h"
+
+namespace android {
+
+class AlertCallback : public android::brillo::example::BnAlertCallback {
+ public:
+  binder::Status OnNLogEventsReceivedCallback(int n) {
+    LOG(INFO) << "Received Callback from service: Received " << n << " log "
+              << "messages.";
+    return binder::Status::ok();
+  }
+};
+
+}  // namespace android
+
+// A function to read user input on the console and pass it along to the example
+// service for logging.
+void StdinCallback(
+    android::sp<android::brillo::example::IExampleService> service) {
+  std::string line;
+  std::getline(std::cin, line);
+  service->Log(android::String16(line.c_str()));
+}
+
+int main() {
+  // TODO(ralphnathan): Hide this in brillo::BaseMessageLoop.
+  base::AtExitManager at_exit_manager;
+  brillo::InitLog(brillo::kLogToSyslog);
+  // Get handle for the example service.
+  android::sp<android::brillo::example::IExampleService> service;
+  android::status_t status = android::getService(
+      android::String16("android.brillo.example.ExampleService"), &service);
+  CHECK(status == android::OK) <<
+      "Failed to get IExampleService binder from service manager!";
+
+  // Register a callback object with the service.
+  android::sp<android::AlertCallback> cbo = new android::AlertCallback();
+  service->RegisterCallback(cbo, 3);
+
+  // Create a message loop.
+  base::MessageLoopForIO message_loop_for_io;
+  brillo::BaseMessageLoop message_loop{&message_loop_for_io};
+
+  // Initialize a binder watcher.
+  brillo::BinderWatcher watcher(&message_loop);
+  watcher.Init();
+
+  // Poll stdin.
+  base::Closure stdin_callback = base::Bind(&StdinCallback, service);
+  message_loop.WatchFileDescriptor(
+      STDIN_FILENO, brillo::BaseMessageLoop::kWatchRead, true, stdin_callback);
+  // Start the message loop.
+  message_loop.Run();
+}

diff --git a/common/service_example/brillo_example_service.cpp b/common/service_example/brillo_example_service.cpp
new file mode 100644
index 0000000..fd24a7e
--- /dev/null
+++ b/common/service_example/brillo_example_service.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <base/at_exit.h>
+#include <base/logging.h>
+#include <base/message_loop/message_loop.h>
+#include <binder/IServiceManager.h>
+#include <binder/Status.h>
+#include <brillo/binder_watcher.h>
+#include <brillo/message_loops/base_message_loop.h>
+#include <brillo/syslog_logging.h>
+#include <utils/String16.h>
+
+#include "android/brillo/example/BnExampleService.h"
+#include "android/brillo/example/IAlertCallback.h"
+
+namespace android {
+
+class ExampleService : public android::brillo::example::BnExampleService {
+ public:
+  binder::Status Log(const String16& s) {
+    LOG(INFO) << String8(s).string();
+    count_++;
+    if (count_ == max_events_) {
+      cbo_->OnNLogEventsReceivedCallback(count_);
+      count_ = 0;
+    }
+    return binder::Status::ok();
+  }
+
+  binder::Status RegisterCallback(
+      const sp<android::brillo::example::IAlertCallback>& callback, int n) {
+    cbo_ = callback;
+    max_events_ = n;
+    count_ = 0;
+    return binder::Status::ok();
+  }
+
+ private:
+  sp<android::brillo::example::IAlertCallback> cbo_;
+  int count_ = 0;
+  int max_events_ = 0;
+};
+
+}  // namespace android
+
+int main() {
+  // TODO(ralphnathan): Hide this in brillo::BaseMessageLoop.
+  base::AtExitManager at_exit_manager;
+  brillo::InitLog(brillo::kLogToSyslog);
+  // Register service with the service manager.
+  android::status_t status = android::defaultServiceManager()->addService(
+      android::String16("android.brillo.example.ExampleService"),
+      new android::ExampleService());
+  CHECK(status == android::OK) <<
+      "Failed to get IExampleService binder from service manager!";
+
+  // Create a message loop.
+  base::MessageLoopForIO message_loop_for_io;
+  brillo::BaseMessageLoop message_loop{&message_loop_for_io};
+
+  // Initialize a binder watcher.
+  brillo::BinderWatcher watcher(&message_loop);
+  watcher.Init();
+
+  // Run the message loop.
+  message_loop.Run();
+}

diff --git a/common/service_example/example_service.rc b/common/service_example/example_service.rc
new file mode 100644
index 0000000..79200e8
--- /dev/null
+++ b/common/service_example/example_service.rc

@@ -0,0 +1,4 @@
+service example_service /system/bin/brillo_example_service
+    class main
+    user system
+    group system

diff --git a/common/service_example/sepolicy/brillo_example_service.te b/common/service_example/sepolicy/brillo_example_service.te
new file mode 100644
index 0000000..9586a40
--- /dev/null
+++ b/common/service_example/sepolicy/brillo_example_service.te

@@ -0,0 +1,12 @@
+# Domain for the Brillo example service.
+type brillo_example_service, domain;
+type brillo_example_service_exec, exec_type, file_type;
+
+# Allow domain transition from init, and access to D-Bus and Binder.
+brillo_domain(brillo_example_service)
+
+# Allow the example service to add itself to service_manager.
+allow brillo_example_service brilloexampleservice:service_manager add;
+
+# Allow crash_reporter access to core dump files.
+allow_crash_reporter(brillo_example_service)

diff --git a/common/service_example/sepolicy/file_contexts b/common/service_example/sepolicy/file_contexts
new file mode 100644
index 0000000..017e759
--- /dev/null
+++ b/common/service_example/sepolicy/file_contexts

@@ -0,0 +1,3 @@
+# Associate the example service's executable with the domain defined in
+# brillo_example_service.te.
+/system/bin/brillo_example_service     u:object_r:brillo_example_service_exec:s0

diff --git a/common/service_example/sepolicy/service.te b/common/service_example/sepolicy/service.te
new file mode 100644
index 0000000..6544432
--- /dev/null
+++ b/common/service_example/sepolicy/service.te

@@ -0,0 +1,2 @@
+# Add a context for the Brillo example service.
+type brilloexampleservice, service_manager_type;

diff --git a/common/service_example/sepolicy/service_contexts b/common/service_example/sepolicy/service_contexts
new file mode 100644
index 0000000..d78561e
--- /dev/null
+++ b/common/service_example/sepolicy/service_contexts

@@ -0,0 +1,3 @@
+# Associate the Brillo example service's name (as defined when it is added to
+# the service manager) with a context.
+android.brillo.example.ExampleService u:object_r:brilloexampleservice:s0