diff --git a/base/Android.bp b/base/Android.bp
new file mode 100644
index 0000000..d990140
--- /dev/null
+++ b/base/Android.bp
@@ -0,0 +1,46 @@
+// Copyright (C) 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.
+
+cc_library_shared {
+    name: "libhidlbase",
+    shared_libs: [
+        "libbase",
+        "liblog",
+        "libutils",
+        "libcutils",
+    ],
+    export_shared_lib_headers: [
+        "libbase",
+        "libutils",
+    ],
+    local_include_dirs: ["include"],
+    export_include_dirs: ["include"],
+
+    clang: true,
+    sanitize: {
+        misc_undefined: ["integer"],
+    },
+
+    srcs: [
+        "HidlSupport.cpp",
+        "Status.cpp",
+        "TaskRunner.cpp",
+    ],
+
+    product_variables: {
+        debuggable: {
+            cflags: ["-DLIBHIDL_TARGET_DEBUGGABLE"],
+        },
+    },
+}
diff --git a/base/HidlSupport.cpp b/base/HidlSupport.cpp
new file mode 100644
index 0000000..1d87d4c
--- /dev/null
+++ b/base/HidlSupport.cpp
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 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.
+ */
+
+#define LOG_TAG "HidlSupport"
+
+#include <hidl/HidlSupport.h>
+
+#include <android-base/logging.h>
+#ifdef LIBHIDL_TARGET_DEBUGGABLE
+#include <cutils/properties.h>
+#include <regex>
+#include <utility>
+#endif
+
+namespace android {
+namespace hardware {
+
+namespace details {
+
+void hidl_log_base::logAlwaysFatal(const char *message) {
+    LOG(FATAL) << message;
+}
+
+} // namespace details
+
+static const char *const kEmptyString = "";
+
+hidl_string::hidl_string()
+    : mBuffer(kEmptyString),
+      mSize(0),
+      mOwnsBuffer(false) {
+}
+
+hidl_string::~hidl_string() {
+    clear();
+}
+
+hidl_string::hidl_string(const char *s) : hidl_string() {
+    copyFrom(s, strlen(s));
+}
+
+hidl_string::hidl_string(const hidl_string &other): hidl_string() {
+    copyFrom(other.c_str(), other.size());
+}
+
+hidl_string::hidl_string(const std::string &s) : hidl_string() {
+    copyFrom(s.c_str(), s.size());
+}
+
+hidl_string::hidl_string(hidl_string &&other): hidl_string() {
+    moveFrom(std::forward<hidl_string>(other));
+}
+
+hidl_string &hidl_string::operator=(hidl_string &&other) {
+    if (this != &other) {
+        clear();
+        moveFrom(std::forward<hidl_string>(other));
+    }
+    return *this;
+}
+
+hidl_string &hidl_string::operator=(const hidl_string &other) {
+    if (this != &other) {
+        clear();
+        copyFrom(other.c_str(), other.size());
+    }
+
+    return *this;
+}
+
+hidl_string &hidl_string::operator=(const char *s) {
+    clear();
+    copyFrom(s, strlen(s));
+    return *this;
+}
+
+hidl_string &hidl_string::operator=(const std::string &s) {
+    clear();
+    copyFrom(s.c_str(), s.size());
+    return *this;
+}
+
+hidl_string::operator std::string() const {
+    return std::string(mBuffer, mSize);
+}
+
+hidl_string::operator const char *() const {
+    return mBuffer;
+}
+
+void hidl_string::copyFrom(const char *data, size_t size) {
+    // assume my resources are freed.
+
+    if (size > UINT32_MAX) {
+        LOG(FATAL) << "string size can't exceed 2^32 bytes.";
+    }
+    char *buf = (char *)malloc(size + 1);
+    memcpy(buf, data, size);
+    buf[size] = '\0';
+    mBuffer = buf;
+
+    mSize = static_cast<uint32_t>(size);
+    mOwnsBuffer = true;
+}
+
+void hidl_string::moveFrom(hidl_string &&other) {
+    // assume my resources are freed.
+
+    mBuffer = other.mBuffer;
+    mSize = other.mSize;
+    mOwnsBuffer = other.mOwnsBuffer;
+
+    other.mOwnsBuffer = false;
+}
+
+void hidl_string::clear() {
+    if (mOwnsBuffer && (mBuffer != kEmptyString)) {
+        free(const_cast<char *>(static_cast<const char *>(mBuffer)));
+    }
+
+    mBuffer = kEmptyString;
+    mSize = 0;
+    mOwnsBuffer = false;
+}
+
+void hidl_string::setToExternal(const char *data, size_t size) {
+    if (size > UINT32_MAX) {
+        LOG(FATAL) << "string size can't exceed 2^32 bytes.";
+    }
+    clear();
+
+    mBuffer = data;
+    mSize = static_cast<uint32_t>(size);
+    mOwnsBuffer = false;
+}
+
+const char *hidl_string::c_str() const {
+    return mBuffer;
+}
+
+size_t hidl_string::size() const {
+    return mSize;
+}
+
+bool hidl_string::empty() const {
+    return mSize == 0;
+}
+
+const char* IBase::descriptor = "android.hardware.base@0.0::IBase";
+
+// ----------------------------------------------------------------------
+// HidlInstrumentor implementation.
+HidlInstrumentor::HidlInstrumentor(const std::string &prefix) {
+    mEnableInstrumentation = property_get_bool("hal.instrumentation.enable",
+                                               false);
+    registerInstrumentationCallbacks(prefix, &mInstrumentationCallbacks);
+}
+
+HidlInstrumentor:: ~HidlInstrumentor() {}
+
+void HidlInstrumentor::registerInstrumentationCallbacks(
+        const std::string &profilerPrefix,
+        std::vector<InstrumentationCallback> *instrumentationCallbacks) {
+#ifdef LIBHIDL_TARGET_DEBUGGABLE
+    std::vector<std::string> instrumentationLibPaths;
+    char instrumentation_lib_path[PROPERTY_VALUE_MAX];
+    if (property_get("hal.instrumentation.lib.path",
+                     instrumentation_lib_path,
+                     "") > 0) {
+        instrumentationLibPaths.push_back(instrumentation_lib_path);
+    } else {
+        instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_SYSTEM);
+        instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_VENDOR);
+        instrumentationLibPaths.push_back(HAL_LIBRARY_PATH_ODM);
+    }
+
+    for (auto path : instrumentationLibPaths) {
+        DIR *dir = opendir(path.c_str());
+        if (dir == 0) {
+            LOG(WARNING) << path << " does not exist. ";
+            return;
+        }
+
+        struct dirent *file;
+        while ((file = readdir(dir)) != NULL) {
+            if (!isInstrumentationLib(profilerPrefix, file))
+                continue;
+
+            void *handle = dlopen((path + file->d_name).c_str(), RTLD_NOW);
+            if (handle == nullptr) {
+                LOG(WARNING) << "couldn't load file: " << file->d_name
+                    << " error: " << dlerror();
+                continue;
+            }
+            using cb_fun = void (*)(
+                    const InstrumentationEvent,
+                    const char *,
+                    const char *,
+                    const char *,
+                    const char *,
+                    std::vector<void *> *);
+            auto cb = (cb_fun)dlsym(handle, "HIDL_INSTRUMENTATION_FUNCTION");
+            if (cb == nullptr) {
+                LOG(WARNING)
+                    << "couldn't find symbol: HIDL_INSTRUMENTATION_FUNCTION, "
+                       "error: "
+                    << dlerror();
+                continue;
+            }
+            instrumentationCallbacks->push_back(cb);
+            LOG(INFO) << "Register instrumentation callback from "
+                << file->d_name;
+        }
+        closedir(dir);
+    }
+#else
+    // No-op for user builds.
+    return;
+#endif
+}
+
+bool HidlInstrumentor::isInstrumentationLib(
+        const std::string &profiler_prefix,
+        const dirent *file) {
+#ifdef LIBHIDL_TARGET_DEBUGGABLE
+    if (file->d_type != DT_REG) return false;
+    std::cmatch cm;
+    std::regex e("^" + profiler_prefix + "(.*).profiler.so$");
+    if (std::regex_match(file->d_name, cm, e)) return true;
+#endif
+    return false;
+}
+
+}  // namespace hardware
+}  // namespace android
+
+
diff --git a/base/Status.cpp b/base/Status.cpp
new file mode 100644
index 0000000..f018918
--- /dev/null
+++ b/base/Status.cpp
@@ -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 <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+
+Status Status::ok() {
+    return Status();
+}
+
+Status Status::fromExceptionCode(int32_t exceptionCode) {
+    return Status(exceptionCode, OK);
+}
+
+Status Status::fromExceptionCode(int32_t exceptionCode,
+                                 const String8& message) {
+    return Status(exceptionCode, OK, message);
+}
+
+Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode) {
+    return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode);
+}
+
+Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode,
+                                        const String8& message) {
+    return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode, message);
+}
+
+Status Status::fromStatusT(status_t status) {
+    Status ret;
+    ret.setFromStatusT(status);
+    return ret;
+}
+
+Status::Status(int32_t exceptionCode, int32_t errorCode)
+    : mException(exceptionCode),
+      mErrorCode(errorCode) {}
+
+Status::Status(int32_t exceptionCode, int32_t errorCode, const String8& message)
+    : mException(exceptionCode),
+      mErrorCode(errorCode),
+      mMessage(message) {}
+
+void Status::setException(int32_t ex, const String8& message) {
+    mException = ex;
+    mErrorCode = NO_ERROR;  // an exception, not a transaction failure.
+    mMessage.setTo(message);
+}
+
+void Status::setServiceSpecificError(int32_t errorCode, const String8& message) {
+    setException(EX_SERVICE_SPECIFIC, message);
+    mErrorCode = errorCode;
+}
+
+void Status::setFromStatusT(status_t status) {
+    mException = (status == NO_ERROR) ? EX_NONE : EX_TRANSACTION_FAILED;
+    mErrorCode = status;
+    mMessage.clear();
+}
+
+String8 Status::toString8() const {
+    String8 ret;
+    if (mException == EX_NONE) {
+        ret.append("No error");
+    } else {
+        ret.appendFormat("Status(%d): '", mException);
+        if (mException == EX_SERVICE_SPECIFIC ||
+            mException == EX_TRANSACTION_FAILED) {
+            ret.appendFormat("%d: ", mErrorCode);
+        }
+        ret.append(String8(mMessage));
+        ret.append("'");
+    }
+    return ret;
+}
+
+std::stringstream& operator<< (std::stringstream& stream, const Status& s) {
+    stream << s.toString8().string();
+    return stream;
+}
+
+}  // namespace hardware
+}  // namespace android
diff --git a/base/TaskRunner.cpp b/base/TaskRunner.cpp
new file mode 100644
index 0000000..2f7d89c
--- /dev/null
+++ b/base/TaskRunner.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 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 <hidl/TaskRunner.h>
+#include <thread>
+
+namespace android {
+namespace hardware {
+
+TaskRunner::TaskRunner() {
+    bool *running = mRunning = new bool();
+    SynchronizedQueue<std::function<void(void)>> *q
+            = mQueue = new SynchronizedQueue<std::function<void(void)>>();
+    mThread = new std::thread([running, q] {
+        *running = true;
+        while (*running) {
+            (q->wait_pop())();
+        }
+        delete q;
+        delete running;
+    });
+}
+TaskRunner::~TaskRunner() {
+    bool *running = mRunning;
+    std::thread *t = mThread;
+    mThread->detach();
+    mQueue->push([running, t] {
+        *running = false;
+        delete t;
+    });
+}
+
+} // namespace hardware
+} // namespace android
+
diff --git a/base/include/hidl/HidlSupport.h b/base/include/hidl/HidlSupport.h
new file mode 100644
index 0000000..c11d680
--- /dev/null
+++ b/base/include/hidl/HidlSupport.h
@@ -0,0 +1,584 @@
+/*
+ * Copyright (C) 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.
+ */
+
+#ifndef ANDROID_HIDL_SUPPORT_H
+#define ANDROID_HIDL_SUPPORT_H
+
+#include <algorithm>
+#include <dirent.h>
+#include <dlfcn.h>
+#include <cutils/properties.h>
+#include <functional>
+#include <hidl/Status.h>
+#include <map>
+#include <tuple>
+#include <utils/Errors.h>
+#include <utils/RefBase.h>
+#include <utils/StrongPointer.h>
+#include <vector>
+
+namespace android {
+namespace hardware {
+
+namespace details {
+
+// hidl_log_base is a base class that templatized
+// classes implemented in a header can inherit from,
+// to avoid creating dependencies on liblog.
+struct hidl_log_base {
+    void logAlwaysFatal(const char *message);
+};
+
+// HIDL client/server code should *NOT* use this class.
+//
+// hidl_pointer wraps a pointer without taking ownership,
+// and stores it in a union with a uint64_t. This ensures
+// that we always have enough space to store a pointer,
+// regardless of whether we're running in a 32-bit or 64-bit
+// process.
+template<typename T>
+struct hidl_pointer {
+    hidl_pointer()
+        : mPointer(nullptr) {
+    }
+    hidl_pointer(T* ptr)
+        : mPointer(ptr) {
+    }
+    hidl_pointer(const hidl_pointer<T>& other) {
+        mPointer = other.mPointer;
+    }
+    hidl_pointer(hidl_pointer<T>&& other) {
+        *this = std::move(other);
+    }
+
+    hidl_pointer &operator=(const hidl_pointer<T>& other) {
+        mPointer = other.mPointer;
+        return *this;
+    }
+    hidl_pointer &operator=(hidl_pointer<T>&& other) {
+        mPointer = other.mPointer;
+        other.mPointer = nullptr;
+        return *this;
+    }
+    hidl_pointer &operator=(T* ptr) {
+        mPointer = ptr;
+        return *this;
+    }
+
+    operator T*() const {
+        return mPointer;
+    }
+    explicit operator void*() const { // requires explicit cast to avoid ambiguity
+        return mPointer;
+    }
+    T& operator*() const {
+        return *mPointer;
+    }
+    T* operator->() const {
+        return mPointer;
+    }
+    T &operator[](size_t index) {
+        return mPointer[index];
+    }
+    const T &operator[](size_t index) const {
+        return mPointer[index];
+    }
+private:
+    union {
+        T* mPointer;
+        uint64_t _pad;
+    };
+};
+} // namespace details
+
+struct hidl_string {
+    hidl_string();
+    ~hidl_string();
+
+    // copy constructor.
+    hidl_string(const hidl_string &);
+    // copy from a C-style string.
+    hidl_string(const char *);
+    // copy from an std::string.
+    hidl_string(const std::string &);
+
+    // move constructor.
+    hidl_string(hidl_string &&);
+
+    const char *c_str() const;
+    size_t size() const;
+    bool empty() const;
+
+    // copy assignment operator.
+    hidl_string &operator=(const hidl_string &);
+    // copy from a C-style string.
+    hidl_string &operator=(const char *s);
+    // copy from an std::string.
+    hidl_string &operator=(const std::string &);
+    // move assignment operator.
+    hidl_string &operator=(hidl_string &&other);
+    // cast to std::string.
+    operator std::string() const;
+    // cast to C-style string. Caller is responsible
+    // to maintain this hidl_string alive.
+    operator const char *() const;
+
+    void clear();
+
+    // Reference an external char array. Ownership is _not_ transferred.
+    // Caller is responsible for ensuring that underlying memory is valid
+    // for the lifetime of this hidl_string.
+    void setToExternal(const char *data, size_t size);
+
+    // offsetof(hidl_string, mBuffer) exposed since mBuffer is private.
+    static const size_t kOffsetOfBuffer;
+
+private:
+    details::hidl_pointer<const char> mBuffer;
+    uint32_t mSize;  // NOT including the terminating '\0'.
+    bool mOwnsBuffer; // if true then mBuffer is a mutable char *
+
+    // copy from data with size. Assume that my memory is freed
+    // (through clear(), for example)
+    void copyFrom(const char *data, size_t size);
+    // move from another hidl_string
+    void moveFrom(hidl_string &&);
+};
+
+inline bool operator==(const hidl_string &hs, const char *s) {
+    return strcmp(hs.c_str(), s) == 0;
+}
+
+inline bool operator!=(const hidl_string &hs, const char *s) {
+    return !(hs == s);
+}
+
+inline bool operator==(const char *s, const hidl_string &hs) {
+    return strcmp(hs.c_str(), s) == 0;
+}
+
+inline bool operator!=(const char *s, const hidl_string &hs) {
+    return !(s == hs);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+struct hidl_vec : private details::hidl_log_base {
+    hidl_vec()
+        : mBuffer(NULL),
+          mSize(0),
+          mOwnsBuffer(true) {
+    }
+
+    hidl_vec(const hidl_vec<T> &other) : hidl_vec() {
+        *this = other;
+    }
+
+    hidl_vec(hidl_vec<T> &&other)
+    : mOwnsBuffer(false) {
+        *this = std::move(other);
+    }
+
+    hidl_vec(const std::initializer_list<T> list)
+            : mSize(list.size()),
+              mOwnsBuffer(true) {
+        mBuffer = new T[mSize];
+
+        size_t idx = 0;
+        for (auto it = list.begin(); it != list.end(); ++it) {
+            mBuffer[idx++] = *it;
+        }
+    }
+
+    hidl_vec(const std::vector<T> &other) : hidl_vec() {
+        *this = other;
+    }
+
+    ~hidl_vec() {
+        if (mOwnsBuffer) {
+            delete[] mBuffer;
+        }
+        mBuffer = NULL;
+    }
+
+    // Reference an existing array, optionally taking ownership. It is the
+    // caller's responsibility to ensure that the underlying memory stays
+    // valid for the lifetime of this hidl_vec.
+    void setToExternal(T *data, size_t size, bool shouldOwn = false) {
+        if (mOwnsBuffer) {
+            delete [] mBuffer;
+        }
+        mBuffer = data;
+        if (size > UINT32_MAX) {
+            logAlwaysFatal("external vector size exceeds 2^32 elements.");
+        }
+        mSize = static_cast<uint32_t>(size);
+        mOwnsBuffer = shouldOwn;
+    }
+
+    T *data() {
+        return mBuffer;
+    }
+
+    const T *data() const {
+        return mBuffer;
+    }
+
+    T *releaseData() {
+        if (!mOwnsBuffer && mSize > 0) {
+            resize(mSize);
+        }
+        mOwnsBuffer = false;
+        return mBuffer;
+    }
+
+    hidl_vec &operator=(hidl_vec &&other) {
+        if (mOwnsBuffer) {
+            delete[] mBuffer;
+        }
+        mBuffer = other.mBuffer;
+        mSize = other.mSize;
+        mOwnsBuffer = other.mOwnsBuffer;
+        other.mOwnsBuffer = false;
+        return *this;
+    }
+
+    hidl_vec &operator=(const hidl_vec &other) {
+        if (this != &other) {
+            if (mOwnsBuffer) {
+                delete[] mBuffer;
+            }
+            copyFrom(other, other.mSize);
+        }
+
+        return *this;
+    }
+
+    // copy from an std::vector.
+    hidl_vec &operator=(const std::vector<T> &other) {
+        if (mOwnsBuffer) {
+            delete[] mBuffer;
+        }
+        copyFrom(other, other.size());
+        return *this;
+    }
+
+    // cast to an std::vector.
+    operator std::vector<T>() const {
+        std::vector<T> v(mSize);
+        for (size_t i = 0; i < mSize; ++i) {
+            v[i] = mBuffer[i];
+        }
+        return v;
+    }
+
+    size_t size() const {
+        return mSize;
+    }
+
+    T &operator[](size_t index) {
+        return mBuffer[index];
+    }
+
+    const T &operator[](size_t index) const {
+        return mBuffer[index];
+    }
+
+    void resize(size_t size) {
+        if (size > UINT32_MAX) {
+            logAlwaysFatal("hidl_vec can't hold more than 2^32 elements.");
+        }
+        T *newBuffer = new T[size];
+
+        for (size_t i = 0; i < std::min(static_cast<uint32_t>(size), mSize); ++i) {
+            newBuffer[i] = mBuffer[i];
+        }
+
+        if (mOwnsBuffer) {
+            delete[] mBuffer;
+        }
+        mBuffer = newBuffer;
+
+        mSize = static_cast<uint32_t>(size);
+        mOwnsBuffer = true;
+    }
+
+    // offsetof(hidl_string, mBuffer) exposed since mBuffer is private.
+    static const size_t kOffsetOfBuffer;
+private:
+    details::hidl_pointer<T> mBuffer;
+    uint32_t mSize;
+    bool mOwnsBuffer;
+
+    // copy from an array-like object, assuming my resources are freed.
+    template <typename Array>
+    void copyFrom(const Array &data, size_t size) {
+        mSize = size;
+        mOwnsBuffer = true;
+        if (mSize > 0) {
+            mBuffer = new T[size];
+            for (size_t i = 0; i < size; ++i) {
+                mBuffer[i] = data[i];
+            }
+        } else {
+            mBuffer = NULL;
+        }
+    }
+};
+
+template <typename T>
+const size_t hidl_vec<T>::kOffsetOfBuffer = offsetof(hidl_vec<T>, mBuffer);
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace details {
+
+    template<size_t SIZE1, size_t... SIZES>
+    struct product {
+        static constexpr size_t value = SIZE1 * product<SIZES...>::value;
+    };
+
+    template<size_t SIZE1>
+    struct product<SIZE1> {
+        static constexpr size_t value = SIZE1;
+    };
+
+    template<typename T, size_t SIZE1, size_t... SIZES>
+    struct accessor {
+        explicit accessor(T *base)
+            : mBase(base) {
+        }
+
+        accessor<T, SIZES...> operator[](size_t index) {
+            return accessor<T, SIZES...>(
+                    &mBase[index * product<SIZES...>::value]);
+        }
+
+    private:
+        T *mBase;
+    };
+
+    template<typename T, size_t SIZE1>
+    struct accessor<T, SIZE1> {
+        explicit accessor(T *base)
+            : mBase(base) {
+        }
+
+        T &operator[](size_t index) {
+            return mBase[index];
+        }
+
+    private:
+        T *mBase;
+    };
+
+    template<typename T, size_t SIZE1, size_t... SIZES>
+    struct const_accessor {
+        explicit const_accessor(const T *base)
+            : mBase(base) {
+        }
+
+        const_accessor<T, SIZES...> operator[](size_t index) {
+            return const_accessor<T, SIZES...>(
+                    &mBase[index * product<SIZES...>::value]);
+        }
+
+    private:
+        const T *mBase;
+    };
+
+    template<typename T, size_t SIZE1>
+    struct const_accessor<T, SIZE1> {
+        explicit const_accessor(const T *base)
+            : mBase(base) {
+        }
+
+        const T &operator[](size_t index) const {
+            return mBase[index];
+        }
+
+    private:
+        const T *mBase;
+    };
+
+}  // namespace details
+
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename T, size_t SIZE1, size_t... SIZES>
+struct hidl_array {
+    hidl_array() = default;
+
+    T *data() { return mBuffer; }
+    const T *data() const { return mBuffer; }
+
+    details::accessor<T, SIZES...> operator[](size_t index) {
+        return details::accessor<T, SIZES...>(
+                &mBuffer[index * details::product<SIZES...>::value]);
+    }
+
+    details::const_accessor<T, SIZES...> operator[](size_t index) const {
+        return details::const_accessor<T, SIZES...>(
+                &mBuffer[index * details::product<SIZES...>::value]);
+    }
+
+    using size_tuple_type = std::tuple<decltype(SIZE1), decltype(SIZES)...>;
+
+    static constexpr size_tuple_type size() {
+        return std::make_tuple(SIZE1, SIZES...);
+    }
+
+private:
+    T mBuffer[details::product<SIZE1, SIZES...>::value];
+};
+
+template<typename T, size_t SIZE1>
+struct hidl_array<T, SIZE1> {
+    hidl_array() = default;
+
+    T *data() { return mBuffer; }
+    const T *data() const { return mBuffer; }
+
+    T &operator[](size_t index) {
+        return mBuffer[index];
+    }
+
+    const T &operator[](size_t index) const {
+        return mBuffer[index];
+    }
+
+    static constexpr size_t size() { return SIZE1; }
+
+private:
+    T mBuffer[SIZE1];
+};
+
+// ----------------------------------------------------------------------
+// Version functions
+struct hidl_version {
+public:
+    constexpr hidl_version(uint16_t major, uint16_t minor) : mMajor(major), mMinor(minor) {}
+
+    bool operator==(const hidl_version& other) const {
+        return (mMajor == other.get_major() && mMinor == other.get_minor());
+    }
+
+    constexpr uint16_t get_major() const { return mMajor; }
+    constexpr uint16_t get_minor() const { return mMinor; }
+
+private:
+    uint16_t mMajor;
+    uint16_t mMinor;
+};
+
+inline android::hardware::hidl_version make_hidl_version(uint16_t major, uint16_t minor) {
+    return hidl_version(major,minor);
+}
+
+struct IBase : virtual public RefBase {
+    virtual bool isRemote() const = 0;
+    // HIDL reserved methods follow.
+    virtual ::android::hardware::Return<void> interfaceChain(
+            std::function<void(const hidl_vec<hidl_string>&)> _hidl_cb) = 0;
+    // descriptor for HIDL reserved methods.
+    static const char* descriptor;
+};
+
+#if defined(__LP64__)
+#define HAL_LIBRARY_PATH_SYSTEM "/system/lib64/hw/"
+#define HAL_LIBRARY_PATH_VENDOR "/vendor/lib64/hw/"
+#define HAL_LIBRARY_PATH_ODM "/odm/lib64/hw/"
+#else
+#define HAL_LIBRARY_PATH_SYSTEM "/system/lib/hw/"
+#define HAL_LIBRARY_PATH_VENDOR "/vendor/lib/hw/"
+#define HAL_LIBRARY_PATH_ODM "/odm/lib/hw/"
+#endif
+
+#define DECLARE_SERVICE_MANAGER_INTERACTIONS(INTERFACE)                                  \
+    static ::android::sp<I##INTERFACE> getService(                                       \
+            const std::string &serviceName, bool getStub=false);                         \
+    ::android::status_t registerAsService(const std::string &serviceName);               \
+    static bool registerForNotifications(                                                \
+        const std::string &serviceName,                                                  \
+        const ::android::sp<::android::hidl::manager::V1_0::IServiceNotification>        \
+                  &notification);                                                        \
+
+// ----------------------------------------------------------------------
+// Class that provides Hidl instrumentation utilities.
+struct HidlInstrumentor {
+    // Event that triggers the instrumentation. e.g. enter of an API call on
+    // the server/client side, exit of an API call on the server/client side
+    // etc.
+    enum InstrumentationEvent {
+        SERVER_API_ENTRY = 0,
+        SERVER_API_EXIT,
+        CLIENT_API_ENTRY,
+        CLIENT_API_EXIT,
+        SYNC_CALLBACK_ENTRY,
+        SYNC_CALLBACK_EXIT,
+        ASYNC_CALLBACK_ENTRY,
+        ASYNC_CALLBACK_EXIT,
+        PASSTHROUGH_ENTRY,
+        PASSTHROUGH_EXIT,
+    };
+
+    // Signature of the instrumentation callback function.
+    using InstrumentationCallback = std::function<void(
+            const InstrumentationEvent event,
+            const char *package,
+            const char *version,
+            const char *interface,
+            const char *method,
+            std::vector<void *> *args)>;
+
+    explicit HidlInstrumentor(const std::string &prefix);
+    virtual ~HidlInstrumentor();
+
+ protected:
+    // Function that lookup and dynamically loads the hidl instrumentation
+    // libraries and registers the instrumentation callback functions.
+    //
+    // The instrumentation libraries should be stored under any of the following
+    // directories: HAL_LIBRARY_PATH_SYSTEM, HAL_LIBRARY_PATH_VENDOR and
+    // HAL_LIBRARY_PATH_ODM. The name of instrumentation libraries should
+    // follow pattern: ^profilerPrefix(.*).profiler.so$
+    //
+    // Each instrumentation library is expected to implement the instrumentation
+    // function called HIDL_INSTRUMENTATION_FUNCTION.
+    //
+    // A no-op for user build.
+    void registerInstrumentationCallbacks(
+            const std::string &profilerPrefix,
+            std::vector<InstrumentationCallback> *instrumentationCallbacks);
+
+    // Utility function to determine whether a give file is a instrumentation
+    // library (i.e. the file name follow the expected pattern).
+    bool isInstrumentationLib(
+            const std::string &profilerPrefix,
+            const dirent *file);
+    // A list of registered instrumentation callbacks.
+    std::vector<InstrumentationCallback> mInstrumentationCallbacks;
+    // Flag whether to enable instrumentation.
+    bool mEnableInstrumentation;
+};
+
+}  // namespace hardware
+}  // namespace android
+
+
+#endif  // ANDROID_HIDL_SUPPORT_H
+
diff --git a/base/include/hidl/MQDescriptor.h b/base/include/hidl/MQDescriptor.h
new file mode 100644
index 0000000..8292035
--- /dev/null
+++ b/base/include/hidl/MQDescriptor.h
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 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.
+ */
+
+#ifndef _FMSGQ_DESCRIPTOR_H
+#define _FMSGQ_DESCRIPTOR_H
+
+#include <android-base/macros.h>
+#include <cutils/native_handle.h>
+#include <hidl/HidlSupport.h>
+#include <utils/NativeHandle.h>
+
+namespace android {
+namespace hardware {
+
+typedef uint64_t RingBufferPosition;
+
+struct GrantorDescriptor {
+    uint32_t flags;
+    uint32_t fdIndex;
+    uint32_t offset;
+    size_t extent;
+};
+
+enum MQFlavor : uint32_t {
+  /*
+   * kSynchronizedReadWrite represents the wait-free synchronized flavor of the
+   * FMQ. It is intended to be have a single reader and single writer.
+   * Attempts to overflow/underflow returns a failure.
+   */
+  kSynchronizedReadWrite = 0x01,
+  /*
+   * kUnsynchronizedWrite represents the flavor of FMQ where writes always
+   * succeed. This flavor allows one writer and many readers. A read operation
+   * can detect an overwrite and reset the read counter.
+   */
+  kUnsynchronizedWrite = 0x02
+};
+
+template <MQFlavor flavor>
+struct MQDescriptor {
+    MQDescriptor(
+            const std::vector<GrantorDescriptor>& grantors,
+            native_handle_t* nHandle, size_t size);
+
+    MQDescriptor(size_t bufferSize, native_handle_t* nHandle,
+                 size_t messageSize);
+
+    ~MQDescriptor();
+
+    explicit MQDescriptor(const MQDescriptor &other);
+    MQDescriptor &operator=(const MQDescriptor &other) = delete;
+
+    size_t getSize() const;
+
+    size_t getQuantum() const;
+
+    int32_t getFlags() const;
+
+    bool isHandleValid() const { return mHandle != nullptr; }
+    size_t countGrantors() const { return mGrantors.size(); }
+    std::vector<GrantorDescriptor> getGrantors() const;
+    const sp<NativeHandle> getNativeHandle() const;
+
+    inline const ::android::hardware::hidl_vec<GrantorDescriptor> &grantors() const {
+        return mGrantors;
+    }
+
+    inline ::android::hardware::hidl_vec<GrantorDescriptor> &grantors() {
+        return mGrantors;
+    }
+
+    inline const ::native_handle_t *handle() const {
+        return mHandle;
+    }
+
+    inline ::native_handle_t *handle() {
+        return mHandle;
+    }
+
+    static const size_t kOffsetOfGrantors;
+    static const size_t kOffsetOfHandle;
+    /*
+     * There should atleast be GrantorDescriptors for the read counter, write
+     * counter and data buffer.
+     */
+    static constexpr int32_t kMinGrantorCount = 3;
+    enum GrantorType : int { READPTRPOS = 0, WRITEPTRPOS, DATAPTRPOS };
+private:
+    ::android::hardware::hidl_vec<GrantorDescriptor> mGrantors;
+    ::native_handle_t *mHandle;
+    uint32_t mQuantum;
+    uint32_t mFlags;
+};
+
+template<MQFlavor flavor>
+const size_t MQDescriptor<flavor>::kOffsetOfGrantors = offsetof(MQDescriptor<flavor>, mGrantors);
+
+template<MQFlavor flavor>
+const size_t MQDescriptor<flavor>::kOffsetOfHandle = offsetof(MQDescriptor<flavor>, mHandle);
+
+/*
+ * MQDescriptorSync will describe the wait-free synchronized
+ * flavor of FMQ.
+ */
+using MQDescriptorSync = MQDescriptor<kSynchronizedReadWrite>;
+
+/*
+ * MQDescriptorUnsync will describe the unsynchronized write
+ * flavor of FMQ.
+ */
+using MQDescriptorUnsync = MQDescriptor<kUnsynchronizedWrite>;
+
+template<MQFlavor flavor>
+MQDescriptor<flavor>::MQDescriptor(
+        const std::vector<GrantorDescriptor>& grantors,
+        native_handle_t* nhandle,
+        size_t size)
+    : mHandle(nhandle),
+      mQuantum(size),
+      mFlags(flavor) {
+    mGrantors.resize(grantors.size());
+    for (size_t i = 0; i < grantors.size(); ++i) {
+        mGrantors[i] = grantors[i];
+    }
+}
+
+template<MQFlavor flavor>
+MQDescriptor<flavor>::MQDescriptor(size_t bufferSize, native_handle_t *nHandle,
+                           size_t messageSize)
+    : mHandle(nHandle), mQuantum(messageSize), mFlags(flavor) {
+    mGrantors.resize(kMinGrantorCount);
+    /*
+     * Create a default grantor descriptor for read, write pointers and
+     * the data buffer. fdIndex parameter is set to 0 by default and
+     * the offset for each grantor is contiguous.
+     */
+    mGrantors[READPTRPOS] = {
+        0 /* grantor flags */, 0 /* fdIndex */, 0 /* offset */,
+        sizeof(RingBufferPosition) /* extent */
+    };
+
+    mGrantors[WRITEPTRPOS] = {
+        0 /* grantor flags */,
+        0 /* fdIndex */,
+        sizeof(RingBufferPosition) /* offset */,
+        sizeof(RingBufferPosition) /* extent */
+    };
+    mGrantors[DATAPTRPOS] = {
+        0 /* grantor flags */, 0 /* fdIndex */,
+        2 * sizeof(RingBufferPosition) /* offset */, bufferSize /* extent */
+    };
+}
+
+template<MQFlavor flavor>
+MQDescriptor<flavor>::MQDescriptor(const MQDescriptor<flavor> &other)
+    : mGrantors(other.mGrantors),
+      mHandle(nullptr),
+      mQuantum(other.mQuantum),
+      mFlags(other.mFlags) {
+    if (other.mHandle != nullptr) {
+        mHandle = native_handle_create(
+                other.mHandle->numFds, other.mHandle->numInts);
+
+        for (int i = 0; i < other.mHandle->numFds; ++i) {
+            const_cast<native_handle_t *>(mHandle)->data[i] =
+                dup(other.mHandle->data[i]);
+        }
+
+        memcpy(&const_cast<native_handle_t *>(mHandle)->data[other.mHandle->numFds],
+               &other.mHandle->data[other.mHandle->numFds],
+               other.mHandle->numInts * sizeof(int));
+    }
+}
+
+template<MQFlavor flavor>
+MQDescriptor<flavor>::~MQDescriptor() {
+    if (mHandle != nullptr) {
+        native_handle_close(const_cast<native_handle_t *>(mHandle));
+        native_handle_delete(const_cast<native_handle_t *>(mHandle));
+    }
+}
+
+template<MQFlavor flavor>
+size_t MQDescriptor<flavor>::getSize() const {
+  return mGrantors[DATAPTRPOS].extent;
+}
+
+template<MQFlavor flavor>
+size_t MQDescriptor<flavor>::getQuantum() const { return mQuantum; }
+
+template<MQFlavor flavor>
+int32_t MQDescriptor<flavor>::getFlags() const { return mFlags; }
+
+template<MQFlavor flavor>
+std::vector<GrantorDescriptor> MQDescriptor<flavor>::getGrantors() const {
+  size_t grantor_count = mGrantors.size();
+  std::vector<GrantorDescriptor> grantors(grantor_count);
+  for (size_t i = 0; i < grantor_count; i++) {
+    grantors[i] = mGrantors[i];
+  }
+  return grantors;
+}
+
+template<MQFlavor flavor>
+const sp<NativeHandle> MQDescriptor<flavor>::getNativeHandle() const {
+  /*
+   * Create an sp<NativeHandle> from mHandle.
+   */
+  return NativeHandle::create(mHandle, false /* ownsHandle */);
+}
+}  // namespace hardware
+}  // namespace android
+
+#endif  // FMSGQ_DESCRIPTOR_H
diff --git a/base/include/hidl/Status.h b/base/include/hidl/Status.h
new file mode 100644
index 0000000..248d51c
--- /dev/null
+++ b/base/include/hidl/Status.h
@@ -0,0 +1,174 @@
+/*
+ * 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 ANDROID_HARDWARE_BINDER_STATUS_H
+#define ANDROID_HARDWARE_BINDER_STATUS_H
+
+#include <cstdint>
+#include <sstream>
+
+#include <utils/String8.h>
+#include <android-base/macros.h>
+
+namespace android {
+namespace hardware {
+
+// An object similar in function to a status_t except that it understands
+// how exceptions are encoded in the prefix of a Parcel. Used like:
+//
+//     Parcel data;
+//     Parcel reply;
+//     status_t status;
+//     binder::Status remote_exception;
+//     if ((status = data.writeInterfaceToken(interface_descriptor)) != OK ||
+//         (status = data.writeInt32(function_input)) != OK) {
+//         // We failed to write into the memory of our local parcel?
+//     }
+//     if ((status = remote()->transact(transaction, data, &reply)) != OK) {
+//        // Something has gone wrong in the binder driver or libbinder.
+//     }
+//     if ((status = remote_exception.readFromParcel(reply)) != OK) {
+//         // The remote didn't correctly write the exception header to the
+//         // reply.
+//     }
+//     if (!remote_exception.isOk()) {
+//         // The transaction went through correctly, but the remote reported an
+//         // exception during handling.
+//     }
+//
+class Status final {
+public:
+    // Keep the exception codes in sync with android/os/Parcel.java.
+    enum Exception {
+        EX_NONE = 0,
+        EX_SECURITY = -1,
+        EX_BAD_PARCELABLE = -2,
+        EX_ILLEGAL_ARGUMENT = -3,
+        EX_NULL_POINTER = -4,
+        EX_ILLEGAL_STATE = -5,
+        EX_NETWORK_MAIN_THREAD = -6,
+        EX_UNSUPPORTED_OPERATION = -7,
+        EX_SERVICE_SPECIFIC = -8,
+
+        // This is special and Java specific; see Parcel.java.
+        EX_HAS_REPLY_HEADER = -128,
+        // This is special, and indicates to C++ binder proxies that the
+        // transaction has failed at a low level.
+        EX_TRANSACTION_FAILED = -129,
+    };
+
+    // A more readable alias for the default constructor.
+    static Status ok();
+    // Authors should explicitly pick whether their integer is:
+    //  - an exception code (EX_* above)
+    //  - service specific error code
+    //  - status_t
+    //
+    //  Prefer a generic exception code when possible, then a service specific
+    //  code, and finally a status_t for low level failures or legacy support.
+    //  Exception codes and service specific errors map to nicer exceptions for
+    //  Java clients.
+    static Status fromExceptionCode(int32_t exceptionCode);
+    static Status fromExceptionCode(int32_t exceptionCode,
+                                    const String8& message);
+    static Status fromServiceSpecificError(int32_t serviceSpecificErrorCode);
+    static Status fromServiceSpecificError(int32_t serviceSpecificErrorCode,
+                                           const String8& message);
+    static Status fromStatusT(status_t status);
+
+    Status() = default;
+    ~Status() = default;
+
+    // Status objects are copyable and contain just simple data.
+    Status(const Status& status) = default;
+    Status(Status&& status) = default;
+    Status& operator=(const Status& status) = default;
+
+    // Set one of the pre-defined exception types defined above.
+    void setException(int32_t ex, const String8& message);
+    // Set a service specific exception with error code.
+    void setServiceSpecificError(int32_t errorCode, const String8& message);
+    // Setting a |status| != OK causes generated code to return |status|
+    // from Binder transactions, rather than writing an exception into the
+    // reply Parcel.  This is the least preferable way of reporting errors.
+    void setFromStatusT(status_t status);
+
+    // Get information about an exception.
+    int32_t exceptionCode() const  { return mException; }
+    const String8& exceptionMessage() const { return mMessage; }
+    status_t transactionError() const {
+        return mException == EX_TRANSACTION_FAILED ? mErrorCode : OK;
+    }
+    int32_t serviceSpecificErrorCode() const {
+        return mException == EX_SERVICE_SPECIFIC ? mErrorCode : 0;
+    }
+
+    bool isOk() const { return mException == EX_NONE; }
+
+    // For logging.
+    String8 toString8() const;
+
+private:
+    Status(int32_t exceptionCode, int32_t errorCode);
+    Status(int32_t exceptionCode, int32_t errorCode, const String8& message);
+
+    // If |mException| == EX_TRANSACTION_FAILED, generated code will return
+    // |mErrorCode| as the result of the transaction rather than write an
+    // exception to the reply parcel.
+    //
+    // Otherwise, we always write |mException| to the parcel.
+    // If |mException| !=  EX_NONE, we write |mMessage| as well.
+    // If |mException| == EX_SERVICE_SPECIFIC we write |mErrorCode| as well.
+    int32_t mException = EX_NONE;
+    int32_t mErrorCode = 0;
+    String8 mMessage;
+};  // class Status
+
+// For gtest output logging
+std::stringstream& operator<< (std::stringstream& stream, const Status& s);
+
+template<typename T> class Return {
+private:
+      T val {};
+      Status status {};
+public:
+      Return(T v) : val{v} {}
+      Return(Status s) : status(s) {}
+      operator T() const { return val; }
+      const Status& getStatus() const {
+          return status;
+      }
+};
+
+template<> class Return<void> {
+private:
+      Status status {};
+public:
+      Return() = default;
+      Return(Status s) : status(s) {}
+      const Status& getStatus() const {
+          return status;
+      }
+};
+
+static inline Return<void> Void() {
+    return Return<void>();
+}
+
+}  // namespace hardware
+}  // namespace android
+
+#endif // ANDROID_HARDWARE_BINDER_STATUS_H
diff --git a/base/include/hidl/SynchronizedQueue.h b/base/include/hidl/SynchronizedQueue.h
new file mode 100644
index 0000000..80123ba
--- /dev/null
+++ b/base/include/hidl/SynchronizedQueue.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 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.
+ */
+
+#ifndef ANDROID_SYNCHRONIZED_QUEUE_H
+#define ANDROID_SYNCHRONIZED_QUEUE_H
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+namespace android {
+namespace hardware {
+/* Threadsafe queue.
+ */
+template <typename T>
+struct SynchronizedQueue {
+
+    /* Gets an item from the front of the queue.
+     *
+     * Blocks until the item is available.
+     */
+    T wait_pop();
+
+    /* Puts an item onto the end of the queue.
+     */
+    bool push(const T& item);
+
+    /* Gets the size of the array.
+     */
+    size_t size();
+
+    /* Sets the limit to the queue. Will fail
+     * the push operation if the limit is reached.
+     */
+    void setLimit(size_t limit);
+
+private:
+    std::condition_variable mCondition;
+    std::mutex mMutex;
+    std::queue<T> mQueue;
+    size_t mQueueLimit = SIZE_MAX;
+};
+
+template <typename T>
+T SynchronizedQueue<T>::wait_pop() {
+    std::unique_lock<std::mutex> lock(mMutex);
+
+    mCondition.wait(lock, [this]{
+        return !this->mQueue.empty();
+    });
+
+    T item = mQueue.front();
+    mQueue.pop();
+
+    return item;
+}
+
+template <typename T>
+bool SynchronizedQueue<T>::push(const T &item) {
+    bool success;
+    {
+        std::unique_lock<std::mutex> lock(mMutex);
+        if (mQueue.size() < mQueueLimit) {
+            mQueue.push(item);
+            success = true;
+        } else {
+            success = false;
+        }
+    }
+
+    mCondition.notify_one();
+    return success;
+}
+
+template <typename T>
+size_t SynchronizedQueue<T>::size() {
+    std::unique_lock<std::mutex> lock(mMutex);
+
+    return mQueue.size();
+}
+
+template <typename T>
+void SynchronizedQueue<T>::setLimit(size_t limit) {
+    std::unique_lock<std::mutex> lock(mMutex);
+
+    mQueueLimit = limit;
+}
+
+} // namespace hardware
+} // namespace android
+
+#endif
diff --git a/base/include/hidl/TaskRunner.h b/base/include/hidl/TaskRunner.h
new file mode 100644
index 0000000..bc9087f
--- /dev/null
+++ b/base/include/hidl/TaskRunner.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 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.
+ */
+#ifndef ANDROID_TASK_RUNNER_H
+#define ANDROID_TASK_RUNNER_H
+
+#include "SynchronizedQueue.h"
+#include <thread>
+
+namespace android {
+namespace hardware {
+
+/*
+ * A background infinite loop that runs the Tasks push()'ed.
+ * Just a simple single-threaded thread pool.
+ */
+class TaskRunner {
+public:
+
+    /* Kicks off the loop immediately. */
+    TaskRunner();
+
+    /*
+     * Detaches the background thread and return immediately.
+     * Tasks in the queue will continue to be done sequentially, and _after_
+     * all tasks are done, the background thread releases the resources
+     * (the queue, the std::thread object, etc.)
+     */
+    ~TaskRunner();
+
+    /*
+     * Add a task. Return true if successful, false if
+     * the queue's size exceeds limit.
+     */
+    inline bool push(const std::function<void(void)> &t) {
+        return this->mQueue->push(t);
+    }
+
+    /*
+     * Sets the queue limit. Fails the push operation once the limit is reached.
+     */
+    inline void setLimit(size_t limit) {
+        this->mQueue->setLimit(limit);
+    }
+private:
+
+    // resources managed by the background thread.
+    bool *mRunning;
+    SynchronizedQueue<std::function<void(void)>> *mQueue;
+    std::thread *mThread;
+};
+
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_TASK_RUNNER_H