Merge "Hid Utilities for HID based dynamic sensor" into oc-dev

am: 2577ac2cad

Change-Id: I037c9d5fc4bcefa0ee83cbb6f0f9fcb973333485

modules/sensors/dynamic_sensor/Android.mk

@@ -32,7 +32,7 @@ COMMON_CFLAGS := -Wall -Werror -Wextra
 include $(CLEAR_VARS)
 LOCAL_MODULE := libdynamic_sensor_ext
 LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_OWNER := google
+# intended to be integrated into hal, thus proprietary
 LOCAL_PROPRIETARY_MODULE := true
 
 LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"DynamicSensorExt\"
@@ -61,7 +61,7 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := sensors.dynamic_sensor_hal
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_OWNER := google
+# hal module, thus proprietary
 LOCAL_PROPRIETARY_MODULE := true
 
 LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"DynamicSensorHal\"
@@ -83,3 +83,6 @@ LOCAL_SHARED_LIBRARIES := \
 LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
 
 include $(BUILD_SHARED_LIBRARY)
+
+include $(LOCAL_PATH)/HidUtils/Android.mk
+

modules/sensors/dynamic_sensor/HidUtils/Android.mk

@@ -0,0 +1,99 @@
+# Copyright (C) 2017 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)
+COMMON_CFLAGS := -Wall -Werror -Wextra
+
+hidparser_src := \
+    HidGlobal.cpp \
+    HidItem.cpp \
+    HidLocal.cpp \
+    HidParser.cpp \
+    HidReport.cpp \
+    HidTree.cpp
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libhidparser
+LOCAL_MODULE_TAGS := optional
+# indended to be used by hal components, thus propietary
+LOCAL_PROPRIETARY_MODULE := true
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS) -DLOG_TAG=\"HidUtil\"
+LOCAL_SRC_FILES := $(hidparser_src)
+LOCAL_SHARED_LIBRARIES := libbase
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+include $(BUILD_SHARED_LIBRARY)
+
+#
+# host side shared library (for host test, example, etc)
+#
+include $(CLEAR_VARS)
+LOCAL_MODULE := libhidparser_host
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS)
+
+LOCAL_SRC_FILES := $(hidparser_src)
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+include $(BUILD_HOST_SHARED_LIBRARY)
+
+#
+# Example of HidParser
+#
+include $(CLEAR_VARS)
+LOCAL_MODULE := hidparser_example
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS)
+LOCAL_SRC_FILES := \
+    $(hidparser_src) \
+    test/HidParserExample.cpp \
+    test/TestHidDescriptor.cpp
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/test
+include $(BUILD_HOST_EXECUTABLE)
+
+#
+# Another example of HidParser
+#
+include $(CLEAR_VARS)
+LOCAL_MODULE := hidparser_example2
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS)
+LOCAL_SRC_FILES := \
+    $(hidparser_src) \
+    test/HidParserExample2.cpp \
+    test/TestHidDescriptor.cpp
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/test
+include $(BUILD_HOST_EXECUTABLE)
+
+#
+# Test for TriState template
+#
+include $(CLEAR_VARS)
+LOCAL_MODULE := tristate_test
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_CFLAGS += $(COMMON_CFLAGS)
+LOCAL_SRC_FILES := test/TriStateTest.cpp
+
+LOCAL_STATIC_LIBRARIES := \
+     libgtest \
+     libgtest_main
+
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/test
+include $(BUILD_HOST_NATIVE_TEST)

modules/sensors/dynamic_sensor/HidUtils/HidDefs.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDDEFS_H_
+#define HIDUTIL_HIDDEFS_H_
+
+namespace HidUtil {
+
+// HID specification constants definition
+//
+// Definitions are from HID specification v1.11, which can be obtained from http://www.usb.org
+//
+// Preferred namespace for namespace restriction than enum class as enum class has strong type
+// which is inconvenient in a parser, in which input binary values has to be compared with these
+// definitions frequnetly.
+namespace HidDef {
+// Hid spec 6.2.2.3
+namespace TagType {
+enum {
+    MAIN,
+    GLOBAL,
+    LOCAL,
+    RESERVED
+};
+} // namespace TagType
+
+// HID spec 6.2.2.4
+namespace ReportFlag {
+enum {
+    DATA_CONST = 1,
+    ARRAY_VARIABLE = 2,
+    WRAP = 4,
+    NONLINEAR = 8,
+    NO_PREFERRED = 0x10,
+    NULL_STATE = 0x20,
+    VOLATILE = 0x40,
+    // bit 7 reserved
+    BUFFERED_BYTES = 0x100
+};
+} // namespace ReportFlag
+
+// HID spec 6.2.2.5
+namespace MainTag {
+enum {
+    INPUT = 8,
+    OUTPUT = 9,
+    COLLECTION = 10,
+    FEATURE = 11,
+    END_COLLECTION = 12,
+    LONG_ITEM = 15,
+};
+} // namespace MainTag
+
+// HID spec 6.2.2.6
+namespace CollectionType {
+enum {
+    PHYSICAL = 0,
+    APPLICATION,
+    LOGICAL,
+    REPORT,
+    NAMED_ARRAY,
+    USAGE_SWITCH,
+    USAGE_MODIFIER
+};
+} // namespace CollectionType
+
+// HID spec 6.2.2.7
+namespace GlobalTag {
+enum {
+    USAGE_PAGE,
+    LOGICAL_MINIMUM,
+    LOGICAL_MAXIMUM,
+    PHYSICAL_MINIMUM,
+    PHYSICAL_MAXIMUM,
+    UNIT_EXPONENT,
+    UNIT,
+    REPORT_SIZE,
+    REPORT_ID,
+    REPORT_COUNT,
+    PUSH,
+    POP
+};
+} //namespace GlobalTag
+
+// HID spec 6.2.2.8
+namespace LocalTag {
+enum HidLocalTag {
+    USAGE,
+    USAGE_MINIMUM,
+    USAGE_MAXIMUM,
+    DESIGNATOR_INDEX,
+    DESIGNATOR_MINIMUM,
+    DESIGNATOR_MAXIMUM,
+    // there is a hole here in the spec
+    STRING_INDEX = 7,
+    STRING_MINIMUM,
+    STRING_MAXIMUM,
+    DELIMITOR
+};
+} // namespace LocalTag
+
+} //namespace HidDef
+} //namespace HidUtil
+
+#endif // HIDUTIL_HIDDEFS_H_

modules/sensors/dynamic_sensor/HidUtils/HidGlobal.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2017 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 "HidDefs.h"
+#include "HidGlobal.h"
+#include "HidLog.h"
+
+namespace HidUtil {
+using namespace HidDef::GlobalTag;
+
+bool HidGlobal::append(const HidItem &i) {
+    using namespace HidDef::TagType;
+    if (i.type != GLOBAL) {
+        LOG_E << "HidGlobal::append cannot process tag that is not global, " << i << LOG_ENDL;
+        return false;
+    }
+
+    if (i.tag == PUSH || i.tag == POP) {
+        LOG_E << "PUSH and POP should be handled in HidGlobalStack, " << i << LOG_ENDL;
+        return false;
+    }
+
+    int signedInteger;
+    unsigned unsignedInteger;
+    bool signedError = !i.dataAsSigned(&signedInteger);
+    bool unsignedError = !i.dataAsUnsigned(&unsignedInteger);
+
+    bool valueError = false;
+    bool ret = true;
+    switch (i.tag) {
+        case USAGE_PAGE:
+            usagePage = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case LOGICAL_MINIMUM:
+            logicalMin = signedInteger;
+            valueError = signedError;
+            break;
+        case LOGICAL_MAXIMUM:
+            logicalMax = signedInteger;
+            valueError = signedError;
+            break;
+        case PHYSICAL_MINIMUM:
+            physicalMin = signedInteger;
+            valueError = signedError;
+            break;
+        case PHYSICAL_MAXIMUM:
+            physicalMax = signedInteger;
+            valueError = signedError;
+            break;
+        case UNIT_EXPONENT:
+            exponent = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case UNIT:
+            unit = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case REPORT_SIZE:
+            reportSize = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case REPORT_ID:
+            reportId = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case REPORT_COUNT:
+            reportCount = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        default:
+            LOG_E << "unknown global tag, " << i << LOG_ENDL;
+            ret = false;
+    }
+
+    if (valueError) {
+        LOG_E << "Cannot get signed / unsigned data at " << i << LOG_ENDL;
+        ret = false;
+    }
+    return ret;
+}
+
+bool HidGlobalStack::append(const HidItem &i) {
+    using namespace HidDef::TagType;
+    if (i.type != GLOBAL) {
+        return false;
+    }
+
+    bool ret = true;
+    if (i.tag == PUSH) {
+        mStack.push_back(top());
+    } else if (i.tag == POP) {
+        mStack.pop_back();
+        if (mStack.size() == 0) {
+            mStack.push_back(HidGlobal()); // fail-safe
+            ret = false;
+        }
+    } else {
+        ret = mStack.back().append(i);
+    }
+    return ret;
+}
+
+HidGlobalStack::HidGlobalStack() {
+    // default element
+    mStack.push_back(HidGlobal());
+}
+
+const HidGlobal& HidGlobalStack::top() const {
+    return mStack.back();
+}
+
+} // namespace HidUtil

modules/sensors/dynamic_sensor/HidUtils/HidGlobal.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDGLOBAL_H_
+#define HIDUTIL_HIDGLOBAL_H_
+
+#include "HidItem.h"
+#include "TriState.h"
+
+namespace HidUtil {
+// A set of global states that parser has to keep track during parsing.
+// They are all specified in HID spec v1.11 section 6.2.2.7
+struct HidGlobal {
+    // add a token and change global states, returns value indicates if operation is successful
+    bool append(const HidItem &i);
+
+    tri_uint usagePage;
+    tri_int  logicalMin;
+    tri_int  logicalMax;
+    tri_int  physicalMin;
+    tri_int  physicalMax;
+    tri_uint exponent;
+    tri_uint unit;
+    tri_uint reportSize;
+    tri_uint reportId;
+    tri_uint reportCount;
+};
+
+// HID specs allows PUSH and POP to save a snapshot of current global states and come back to the
+// saved sates later. HidStack manages this logic. Note that PUSH and POP are also HidItems, so
+// there is no explicit push and pop function in this stack implementation.
+class HidGlobalStack {
+public:
+    HidGlobalStack();
+
+    // add a token and change global states, returns value indicates if operation is successful
+    // it the token is push/pop, the stack push/pop accordingly.
+    bool append(const HidItem &i);
+
+    // get reference to top element on the stack
+    const HidGlobal& top() const;
+private:
+    std::vector<HidGlobal> mStack;
+};
+
+} //namespace HidUtil
+
+#endif // HIDUTIL_HIDGLOABL_H_

modules/sensors/dynamic_sensor/HidUtils/HidItem.cpp

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2017 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 "HidItem.h"
+#include "HidDefs.h"
+#include "StreamIoUtil.h"
+#include <iostream>
+
+namespace HidUtil {
+
+bool HidItem::dataAsUnsigned(unsigned int *out) const  {
+    if (data.size() > 4 || data.size() == 0) {
+        return false;
+    }
+
+    *out = 0;
+    int shift = 0;
+
+    for (auto i : data) {
+        *out |= (i << shift);
+        shift += 8;
+    }
+    return true;
+}
+
+bool HidItem::dataAsSigned(int *out) const {
+    unsigned int u;
+    if (!dataAsUnsigned(&u)) {
+        return false;
+    }
+    size_t bitSize_1 = data.size() * 8 - 1;
+    unsigned int sign = u & (1 << bitSize_1);
+    *out = u | ((sign == 0) ? 0 : ( ~0 << bitSize_1));
+    return true;
+}
+
+std::vector<HidItem> HidItem::tokenize(const uint8_t *begin, size_t size) {
+    // construct a stream
+    charvectorbuf<unsigned char> buf(begin, size);
+    std::istream is(&buf);
+    return tokenize(is);
+}
+
+std::vector<HidItem> HidItem::tokenize(const std::vector<uint8_t> &descriptor) {
+    // construct a stream
+    charvectorbuf<unsigned char> buf(descriptor);
+    std::istream is(&buf);
+    return tokenize(is);
+}
+
+std::vector<HidItem> HidItem::tokenize(std::istream &is) {
+    std::vector<HidItem> hidToken;
+
+    // this is important to avoid skipping characters
+    is.unsetf(std::ios_base::skipws);
+    while (!is.eof()) {
+        HidItem i;
+        is >> i;
+        if (i.valid) {
+            hidToken.push_back(i);
+        } else {
+            break;
+        }
+    }
+    return hidToken;
+}
+
+std::istream& operator>>(std::istream &is, HidUtil::HidItem &h) {
+    using namespace HidUtil::HidDef::MainTag;
+    using namespace HidUtil::HidDef::TagType;
+
+    h.valid = false;
+    h.offset = is.tellg();
+    h.byteSize = 0;
+    unsigned char first;
+    is >> first;
+    if (!is.eof()) {
+        static const size_t lenTable[] = { 0, 1, 2, 4 };
+        size_t len = lenTable[first & 0x3]; // low 2 bits are length descriptor
+        h.tag = (first >> 4);
+        h.type = (first & 0xC) >> 2;
+
+        if (h.tag == LONG_ITEM && h.type == RESERVED) { // long item
+            //long item
+            unsigned char b = 0;
+            is >> b;
+            len = b;
+            is >> b;
+            h.tag = b;
+        }
+
+        h.data.resize(len);
+        for (auto &i : h.data) {
+            if (is.eof()) {
+                break;
+            }
+            is >> i;
+        }
+        h.byteSize = (ssize_t) is.tellg() - h.offset;
+        h.valid = !is.eof();
+    }
+
+    return is;
+}
+
+std::ostream& operator<<(std::ostream &os, const HidUtil::HidItem &h) {
+    os << "offset: " << h.offset << ", size: " << h.byteSize
+       << ", tag: " << h.tag << ", type: " << h.type << ", data: ";
+    if (h.data.empty()) {
+        os << "[empty]";
+    } else {
+        os << h.data.size() << " byte(s) {";
+        for (auto i : h.data) {
+            os << (int) i << ", ";
+        }
+        os << "}";
+    }
+    return os;
+}
+} // namespace HidUtil

modules/sensors/dynamic_sensor/HidUtils/HidItem.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDITEM_H_
+#define HIDUTIL_HIDITEM_H_
+
+#include <cstdlib>
+#include <vector>
+#include <istream>
+#include <ostream>
+
+namespace HidUtil {
+
+struct HidItem {
+    bool valid;
+    unsigned int type;
+    unsigned int tag;
+    ssize_t offset;
+    ssize_t byteSize;
+    std::vector<uint8_t> data;
+
+    bool dataAsUnsigned(unsigned int *out) const;
+    bool dataAsSigned(int *out) const;
+
+    // friend stream functions
+    friend std::istream& operator>>(std::istream &is, HidItem &h);
+    friend std::ostream& operator<<(std::ostream &os, const HidItem &h);
+
+    // tokenize from a unsigned char vector
+    static std::vector<HidItem> tokenize(const std::vector<uint8_t> &descriptor);
+    static std::vector<HidItem> tokenize(const uint8_t *begin, size_t size);
+    static std::vector<HidItem> tokenize(std::istream &is);
+};
+
+// parsing in from binary stream
+std::istream& operator>>(std::istream &is, HidUtil::HidItem &h);
+
+// output as human readable string to stream
+std::ostream& operator<<(std::ostream &os, const HidUtil::HidItem &h);
+} //namespace HidUtil
+
+#endif // HIDUTIL_HIDITEM_H_

modules/sensors/dynamic_sensor/HidUtils/HidLocal.cpp

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2017 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 "HidDefs.h"
+#include "HidLocal.h"
+#include "HidLog.h"
+#include <cstddef>
+
+namespace HidUtil {
+
+constexpr uint32_t INVALID_USAGE = 0xFFFF;
+constexpr uint32_t INVALID_DESIGNATOR = 0xFFFF;
+constexpr uint32_t INVALID_STRING = 0xFFFF;
+
+uint32_t HidLocal::getUsage(size_t index) const {
+    if (usage.empty()) {
+        return INVALID_USAGE;
+    }
+    return (index >= usage.size()) ? usage.back() : usage[index];
+}
+
+uint32_t HidLocal::getDesignator(size_t index) const {
+    if (designator.empty()) {
+        return INVALID_DESIGNATOR;
+    }
+    return (index >= designator.size()) ? designator.back() : designator[index];
+}
+
+uint32_t HidLocal::getString(size_t index) const {
+    if (string.empty()) {
+        return INVALID_STRING;
+    }
+    return (index >= string.size()) ? string.back() : string[index];
+}
+
+void HidLocal::clear() {
+    *this = HidLocal();
+}
+
+bool HidLocal::append(const HidItem &i) {
+    using namespace HidDef::LocalTag;
+
+    bool ret = true;
+    unsigned unsignedInteger;
+    bool unsignedError = !i.dataAsUnsigned(&unsignedInteger);
+    bool valueError = false;
+
+    switch (i.tag) {
+        case USAGE:
+            usage.push_back(unsignedInteger);
+            valueError = unsignedError;
+            break;
+        case USAGE_MINIMUM:
+            usageMin = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case USAGE_MAXIMUM:
+            if (!usageMin.isSet()) {
+                LOG_E << "usage min not set when saw usage max " << i << LOG_ENDL;
+                ret = false;
+            } else {
+                uint32_t usagemax = unsignedInteger;
+                valueError = unsignedError;
+                for (size_t j = usageMin.get(0); j <= usagemax; ++j) {
+                    usage.push_back(j);
+                }
+                usageMin.clear();
+            }
+            break;
+        case STRING_INDEX:
+            string.push_back(unsignedInteger);
+            valueError = unsignedError;
+            break;
+        case STRING_MINIMUM:
+            stringMin = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        case STRING_MAXIMUM: {
+            if (!usageMin.isSet()) {
+                LOG_E << "string min not set when saw string max " << i << LOG_ENDL;
+                ret = false;
+            } else {
+                uint32_t stringMax = unsignedInteger;
+                valueError = unsignedError;
+                for (size_t j = stringMin.get(0); j <= stringMax; ++j) {
+                    string.push_back(j);
+                }
+                stringMin.clear();
+            }
+            break;
+        }
+        case DELIMITOR:
+            delimeter = unsignedInteger;
+            valueError = unsignedError;
+            break;
+        default:
+            LOG_E << "unknown local tag, " << i << LOG_ENDL;
+            ret = false;
+    }
+    if (valueError) {
+        LOG_E << "Cannot get unsigned data at " << i << LOG_ENDL;
+        ret = false;
+    }
+    return ret;
+}
+} //namespace HidUtil

modules/sensors/dynamic_sensor/HidUtils/HidLocal.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDLOCAL_H_
+#define HIDUTIL_HIDLOCAL_H_
+
+#include "HidItem.h"
+#include "TriState.h"
+#include <cstddef>
+#include <vector>
+
+namespace HidUtil {
+
+// A set of local states that parser has to keep track during parsing.
+// They are all specified in HID spec v1.11 section 6.2.2.8
+struct HidLocal {
+    // add a token to change local states, return value indicates if operation is successful
+    bool append(const HidItem &i);
+    // clear all local states. This need to be done after each main tag
+    void clear();
+
+    // multiple usage, designator or strings may exist for single input/output/feature report
+    uint32_t getUsage(size_t index) const;
+    uint32_t getDesignator(size_t index) const;
+    uint32_t getString(size_t index) const;
+
+    std::vector<uint32_t> usage;
+    // keep track of usage min when expecting a usage max
+    tri_uint usageMin;
+
+    std::vector<uint32_t> designator;
+    // keep track of designator min when expecting designator max
+    tri_uint designatorMin;
+
+    std::vector<uint32_t> string;
+    // keep track of string min when expecting string max
+    tri_uint stringMin;
+
+    tri_uint delimeter;
+};
+} // namespace HidUtil
+
+#endif // HIDUTIL_HIDLOCAL_H_

modules/sensors/dynamic_sensor/HidUtils/HidLog.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDLOG_H_
+#define HIDUTIL_HIDLOG_H_
+
+#if defined(__ANDROID__) && !defined(LOG_TO_CONSOLE)
+#include <android-base/logging.h>
+#define LOG_ENDL ""
+#define LOG_E LOG(ERROR)
+#define LOG_W LOG(WARNING)
+#define LOG_I LOG(INFO)
+#define LOG_D LOG(DEBUG)
+#define LOG_V LOG(VERBOSE)
+#else
+#include <iostream>
+#define LOG_ENDL std::endl
+#define LOG_E (std::cerr << "E: ")
+#define LOG_W (std::cerr << "W: ")
+#define LOG_I (std::cerr << "I: ")
+#define LOG_D (std::cerr << "D: ")
+#define LOG_V (std::cerr << "V: ")
+#endif
+
+#endif // HIDUTIL_HIDLOG_H_

modules/sensors/dynamic_sensor/HidUtils/HidParser.cpp

@@ -0,0 +1,319 @@
+/*
+ * Copyright (C) 2017 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 "HidDefs.h"
+#include "HidParser.h"
+#include "HidLog.h"
+#include <iostream>
+#include <iomanip>
+
+namespace HidUtil {
+
+void HidParser::reset() {
+    mGlobalStack = HidGlobalStack();
+    mLocal = HidLocal();
+    mTree = std::make_shared<HidTreeNode>();
+    mCurrent = mTree;
+}
+
+bool HidParser::parse(const std::vector<HidItem> &token) {
+    // Clean up internal states of the parser for a new stream of descriptor token
+    reset();
+
+    bool ret = true;
+    using namespace HidDef::TagType;
+
+    for (auto &i : token) {
+        switch (i.type) {
+            case MAIN:
+                ret = processMainTag(i);
+                break;
+            case GLOBAL:
+                ret = mGlobalStack.append(i);
+                break;
+            case LOCAL:
+                ret = mLocal.append(i);
+                break;
+            default:
+                LOG_E << "HidParser found illegal HidItem: " << i << LOG_ENDL;
+                ret = false;
+        }
+
+        // in case a parse failure, quit prematurely
+        if (!ret) {
+            break;
+        }
+    }
+    return ret;
+}
+
+bool HidParser::processMainTag(const HidItem &i) {
+    using namespace HidDef::MainTag;
+    using namespace HidDef::ReportFlag;
+
+    bool ret = true;
+    switch (i.tag) {
+        case COLLECTION: {
+            unsigned int collectionType;
+            if (!i.dataAsUnsigned(&collectionType)) {
+                LOG_E << "Cannot get collection type at offset " << i.offset << LOG_ENDL;
+                ret = false;
+                break;
+            }
+            unsigned int fullUsage =
+                    mGlobalStack.top().usagePage.get(0) << 16 | mLocal.getUsage(0);
+            mCurrent = mCurrent->addChild(
+                    std::make_shared<HidTreeNode>(mCurrent, collectionType, fullUsage));
+            break;
+        }
+        case END_COLLECTION:
+            mCurrent = mCurrent->getParent();
+            if (!mCurrent) {
+                // trigger parse failure so that mCurrent will not be accessed
+                LOG_E << "unmatched END_COLLECTION at " << i.offset << LOG_ENDL;
+                ret = false;
+            }
+            break;
+        case INPUT:
+        case OUTPUT:
+        case FEATURE: {
+            unsigned int reportType = i.tag;
+            unsigned int flag;
+            if (!i.dataAsUnsigned(&flag)) {
+                LOG_E << "Cannot get report flag at offset " << i.offset << LOG_ENDL;
+                ret = false;
+                break;
+            }
+            const HidGlobal &top = mGlobalStack.top();
+
+            // usage page, local min/max, report size and count have to be defined at report
+            // definition.
+            if (!(top.usagePage.isSet() && top.logicalMin.isSet() && top.logicalMax.isSet()
+                  && top.reportSize.isSet() && top.reportCount.isSet())) {
+                LOG_E << "Report defined at " << i.offset
+                      << " does not have all mandatory fields set" << LOG_ENDL;
+                ret = false;
+                break;
+            }
+            if (top.reportSize.get(0) > 32) {
+                LOG_E << "Report defined at " << i.offset
+                      << " has unsupported report size(> 32 bit)" << LOG_ENDL;
+                ret = false;
+                break;
+            }
+
+            HidReport report(reportType, flag, top, mLocal);
+            mReport.push_back(report);
+            std::shared_ptr<HidTreeNode> node(new HidReportNode(mCurrent, report));
+            mCurrent->addChild(node);
+            break;
+        }
+        default:
+            LOG_E << "unknown main tag, " << i << LOG_ENDL;
+            ret = false;
+    }
+    // locals is cleared after any main tag according to HID spec
+    mLocal.clear();
+    return ret;
+}
+
+bool HidParser::parse(const unsigned char *begin, size_t size) {
+    std::vector<HidItem> hidItemVector = HidItem::tokenize(begin, size);
+    return parse(hidItemVector);
+}
+
+void HidParser::filterTree() {
+    if (mTree != nullptr) {
+        filterTree(mTree);
+    }
+}
+
+void HidParser::filterTree(std::shared_ptr<HidTreeNode> &node) {
+    if (node->isReportCollection()) {
+        std::shared_ptr<HidReportNode> reportNode =
+                std::static_pointer_cast<HidReportNode>(node->getChildren().front());
+        if (reportNode != nullptr) {
+            reportNode->collapse(node->getFullUsage());
+            node = reportNode;
+        }
+    } else {
+        for (auto &i : node->getChildren()) {
+            filterTree(i);
+        }
+    }
+}
+
+HidParser::DigestVector HidParser::generateDigest(
+        const std::unordered_set<unsigned int> &interestedUsage) {
+    DigestVector digestVector;
+    digest(&digestVector, mTree, interestedUsage);
+    return digestVector;
+}
+
+void HidParser::digest(HidParser::DigestVector *digestVector,
+                       const std::shared_ptr<HidTreeNode> &node,
+                       const std::unordered_set<unsigned int> &interestedUsage) {
+    if (digestVector == nullptr) {
+        return;
+    }
+
+    if (node->isUsageCollection()
+            && interestedUsage.find(node->getFullUsage()) != interestedUsage.end()) {
+        // this collection contains the usage interested
+        ReportSetGroup reportSetGroup;
+
+        // one layer deep search
+        for (auto &i : node->getChildren()) {
+            // skip all nodes that is not a report node
+            if (i->getNodeType() != HidTreeNode::TYPE_REPORT) {
+                continue;
+            }
+            const HidReport &report =
+                    std::static_pointer_cast<HidReportNode>(i)->getReport();
+
+            unsigned int id = report.getReportId();;
+            if (reportSetGroup.find(id) == reportSetGroup.end()) {
+                // create an id group if it is not created
+                reportSetGroup.emplace(id, ReportSet());
+            }
+
+            ReportSet &reportGroup = reportSetGroup[id];
+            switch(report.getType()) {
+                using namespace HidDef::MainTag;
+                case FEATURE:
+                    reportGroup[REPORT_TYPE_FEATURE].push_back(report);
+                    break;
+                case INPUT:
+                    reportGroup[REPORT_TYPE_INPUT].push_back(report);
+                    break;
+                case OUTPUT:
+                    reportGroup[REPORT_TYPE_OUTPUT].push_back(report);
+                    break;
+            }
+        }
+        ReportDigest digest = {
+            .fullUsage = node->getFullUsage(),
+            .packets = convertGroupToPacket(reportSetGroup)
+        };
+        digestVector->emplace_back(digest);
+    } else {
+        for (const auto &child : node->getChildren()) {
+            if (child->getNodeType() == HidTreeNode::TYPE_NORMAL) {
+                // only follow into collection nodes
+                digest(digestVector, child, interestedUsage);
+            }
+        }
+    }
+}
+
+std::vector<HidParser::ReportPacket> HidParser::convertGroupToPacket(
+        const HidParser::ReportSetGroup &group) {
+    std::vector<ReportPacket> packets;
+
+    const std::vector<int> types = {REPORT_TYPE_FEATURE, REPORT_TYPE_INPUT, REPORT_TYPE_OUTPUT};
+
+    for (const auto &setPair : group) {
+        unsigned int id = setPair.first;
+        for (auto type : types) {
+            const auto &reports = setPair.second[type]; // feature
+
+            // template
+            ReportPacket packet = {
+                .type = type,
+                .id = id,
+                .bitSize = 0
+            };
+
+            for (const auto &r : reports) {
+                auto logical = r.getLogicalRange();
+                auto physical = r.getPhysicalRange();
+
+                int64_t offset = physical.first - logical.first;
+                double scale = static_cast<double>((physical.second - physical.first))
+                        / (logical.second - logical.first);
+                scale *= r.getExponentValue();
+
+                ReportItem digest = {
+                    .usage = r.getFullUsage(),
+                    .id = id,
+                    .minRaw = logical.first,
+                    .maxRaw = logical.second,
+                    .a = scale,
+                    .b = offset,
+                    .bitOffset = packet.bitSize,
+                    .bitSize = r.getSize(),
+                    .count = r.getCount(),
+                    .unit = r.getUnit(),
+                };
+                packet.reports.push_back(digest);
+                packet.bitSize += digest.bitSize * digest.count;
+            }
+            if (!packet.reports.empty()) {
+                packets.push_back(std::move(packet));
+            }
+        }
+    }
+    return packets;
+}
+
+static std::string reportTypeToString(int reportType) {
+    switch (reportType) {
+        case HidParser::REPORT_TYPE_INPUT:
+            return "INPUT";
+        case HidParser::REPORT_TYPE_OUTPUT:
+            return "OUTPUT";
+        case HidParser::REPORT_TYPE_FEATURE:
+            return "FEATURE";
+        default:
+            return "INVALID REPORT";
+    }
+}
+
+std::ostream& operator<<(std::ostream &os, const HidParser::DigestVector &digests) {
+    for (const auto &i : digests) {
+        os << "Usage: 0x" << std::hex  << i.fullUsage << std::dec
+           << ", " << i.packets.size() << " report packet:" << LOG_ENDL;
+        for (const auto &packet : i.packets) {
+            os << reportTypeToString(packet.type) << " id: " << packet.id
+               << " size: " << packet.bitSize
+               << "b(" << packet.getByteSize() << "B), "
+               << packet.reports.size() << " entries" << LOG_ENDL;
+
+            for (const auto &report : packet.reports) {
+                double min, max;
+                report.decode(report.mask(report.minRaw), &min);
+                report.decode(report.mask(report.maxRaw), &max);
+
+                os << "  " << report.bitOffset << " size: " << report.bitSize
+                   << ", count: " << report.count
+                   << ", usage: " << std::hex << std::setfill('0') << std::setw(8)
+                   << report.usage << std::dec
+                   << ", min: " << report.minRaw << ", max: " << report.maxRaw
+                   << ", minDecoded: " << min
+                   << ", maxDecoded: " << max
+                   << ", a: " << report.a << ", b: " << report.b
+                   << std::hex
+                   << ", minRawHex: 0x" << report.mask(report.minRaw)
+                   << ", maxRawHex: 0x" << report.mask(report.maxRaw)
+                   << ", rawMasked: 0x" << report.rawMask()
+                   << std::dec << LOG_ENDL;
+            }
+        }
+        os << LOG_ENDL;
+    }
+    os << LOG_ENDL;
+    return os;
+}
+} // namespace HidUtil

modules/sensors/dynamic_sensor/HidUtils/HidParser.h

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDPARSER_H_
+#define HIDUTIL_HIDPARSER_H_
+
+#include "HidItem.h"
+#include "HidTree.h"
+#include "HidGlobal.h"
+#include "HidLocal.h"
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <array>
+#include <ostream>
+
+namespace HidUtil {
+class HidParser {
+public:
+    enum {
+        REPORT_TYPE_FEATURE = 0,
+        REPORT_TYPE_INPUT = 1,
+        REPORT_TYPE_OUTPUT = 2
+    };
+
+    struct ReportItem;
+    struct ReportPacket;
+
+    // report (including input output and feature) grouped by full usage
+    struct ReportDigest {
+        unsigned int fullUsage;
+        std::vector<ReportPacket> packets;
+    };
+
+    typedef std::vector<ReportDigest> DigestVector;
+
+    // parse HID descriptor
+    bool parse(const std::vector<HidItem> &token);
+    bool parse(const unsigned char *begin, size_t size);
+
+    // filter the tree to eliminate single child report leaf node causes by usage array type
+    // reports
+    void filterTree();
+
+    // generate a list of report digest for all interested usage. It will automatically
+    // call filterTree().
+    DigestVector generateDigest(const std::unordered_set<unsigned int> &interestedUsage);
+
+    // get parsed tree (filtered or not filtered)
+    const std::shared_ptr<HidTreeNode> getTree() const { return mTree; }
+
+    // get all parsed report in a parsed form.
+    const std::vector<HidReport>& getReport() const { return mReport; }
+
+private:
+    typedef std::array<std::vector<HidReport>, 3> ReportSet;
+    typedef std::unordered_map<unsigned int /* reportId */, ReportSet> ReportSetGroup;
+
+    // helper subroutines
+    void reset();
+    bool processMainTag(const HidItem &i);
+    static void filterTree(std::shared_ptr<HidTreeNode> &node);
+    static void digest(
+            DigestVector *digestVector,
+            const std::shared_ptr<HidTreeNode> &node,
+            const std::unordered_set<unsigned int> &interestedUsage);
+    static std::vector<ReportPacket> convertGroupToPacket(const ReportSetGroup &group);
+
+    HidGlobalStack mGlobalStack;
+    HidLocal mLocal;
+    std::shared_ptr<HidTreeNode> mTree;
+    std::shared_ptr<HidTreeNode> mCurrent;
+    std::vector<HidReport> mReport;
+};
+
+struct HidParser::ReportItem {
+    unsigned int usage;
+    unsigned int id;
+    int type; // feature, input or output
+
+    int64_t minRaw;
+    int64_t maxRaw;
+
+    // conversion for float point values
+    // real value = (signExtendIfNeeded(raw) + b) * a
+    // raw value = mask(real/a - b);
+    //
+    // conversion for integer values
+    // real value = signExtendedIfNeeded(raw) + b;
+    // raw value = mask(real - b);
+    double a; // scaling
+    int64_t b; // offset
+    unsigned int unit;
+
+    size_t bitOffset;
+    size_t bitSize; // bit length per unit
+    size_t count;
+
+    // helper function
+    bool isSigned() const {
+        return minRaw < 0;
+    }
+
+    bool isByteAligned() const {
+        return (bitOffset & 7) == 0 && (bitSize & 7) == 0;
+    }
+
+    // convert raw values to unsigned format
+    uint32_t mask(int64_t input) const {
+        return static_cast<uint32_t>(input & rawMask());
+    }
+
+    bool decode(uint32_t input, double *output) const {
+        if (output == nullptr) {
+            return false;
+        }
+        int64_t s = signExtendIfNeeded(input);
+        if (s < minRaw || s > maxRaw) {
+            return false;
+        }
+        *output = (s + b) * a;
+        return true;
+    }
+
+    bool encode(double input, uint32_t *output) const {
+        if (output == nullptr) {
+            return false;
+        }
+        input = input / a - b;
+        if (input < minRaw || input > maxRaw) {
+            return false;
+        }
+        *output = static_cast<uint32_t>(static_cast<int64_t>(input) & rawMask());
+        return true;
+    }
+
+    int64_t rawMask() const {
+        constexpr int64_t one = 1;
+        return (one << bitSize) - 1;
+    }
+
+    int64_t signExtendIfNeeded(int64_t value) const {
+        return value | ((isSigned() && isNegative(value)) ? ~rawMask() : 0);
+    }
+
+    bool isNegative(int64_t value) const {
+        constexpr int64_t one = 1;
+        return ((one << (bitSize - 1)) & value) != 0;
+    }
+};
+
+// a collection of report item that forms a packet
+// this is the input output unit with HID hardware
+struct HidParser::ReportPacket {
+    std::vector<ReportItem> reports;
+    size_t bitSize;
+    int type; // REPORT_TYPE_FEATURE/INPUT/OUTPUT
+    unsigned int id;
+
+    size_t getByteSize() const { return (bitSize + 7) / 8; };
+};
+
+std::ostream& operator<<(std::ostream &os, const HidParser::DigestVector &digest2);
+} // namespace HidUtil
+
+#endif // HIDUTIL_HIDPARSER_H_

modules/sensors/dynamic_sensor/HidUtils/HidReport.cpp

@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2017 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 "HidReport.h"
+#include "HidDefs.h"
+#include <cmath>
+#include <sstream>
+#include <iomanip>
+
+namespace HidUtil {
+HidReport::HidReport(uint32_t type, uint32_t data,
+                     const HidGlobal &global, const HidLocal &local)
+        : mReportType(type),
+          mFlag(data),
+          mUsagePage(global.usagePage.get(0)),   // default value 0
+          mUsage(local.getUsage(0)),
+          mUsageVector(local.usage),
+          mLogicalMin(global.logicalMin.get(0)), // default value 0
+          mLogicalMax(global.logicalMax.get(0)),
+          mReportSize(global.reportSize),
+          mReportCount(global.reportCount),
+          mPhysicalMin(global.physicalMin),
+          mPhysicalMax(global.physicalMax),
+          mExponent(global.exponent),
+          mUnit(global.unit),
+          mReportId(global.reportId) { }
+
+std::string HidReport::getStringType() const {
+    return reportTypeToString(mReportType);
+}
+
+std::string HidReport::reportTypeToString(int type) {
+    using namespace HidDef::MainTag;
+    switch(type) {
+        case INPUT:
+            return "INPUT";
+        case OUTPUT:
+            return "OUTPUT";
+        case FEATURE:
+            return "FEATURE";
+        default:
+            return "<<UNKNOWN>>";
+    }
+}
+
+double HidReport::getExponentValue() const {
+    if (!mExponent.isSet()) {
+        return 1;
+    }
+    // default exponent is 0
+    int exponentInt = mExponent.get(0);
+    if (exponentInt > 15 || exponentInt < 0) {
+        return NAN;
+    }
+    return pow(10.0, static_cast<double>((exponentInt <= 7) ? exponentInt : exponentInt - 16));
+}
+
+std::string HidReport::getExponentString() const {
+    int exponentInt = mExponent.get(0);
+    if (exponentInt > 15 || exponentInt < 0) {
+        return "[error]";
+    }
+    return std::string("x10^")
+            + std::to_string((exponentInt <= 7) ? exponentInt : exponentInt - 16);
+}
+
+std::string HidReport::getUnitString() const {
+    if (!mUnit.isSet()) {
+        return "default";
+    }
+    return "[not implemented]";
+
+    std::ostringstream ret;
+    ret << std::hex << std::setfill('0') << std::setw(2) << mUnit.get(0);
+    return ret.str();
+}
+
+std::string HidReport::getFlagString() const {
+    using namespace HidDef::ReportFlag;
+    std::string ret;
+    ret += (mFlag & DATA_CONST) ? "Const " : "Data ";
+    ret += (mFlag & ARRAY_VARIABLE) ? "Variable " : "Array ";
+    ret += (mFlag & WRAP) ? "Wrap " : "";
+    ret += (mFlag & NONLINEAR) ? "Nonlinear " : "";
+    ret += (mFlag & NO_PREFERRED) ? "NoPreferred " : "";
+    ret += (mFlag & NULL_STATE) ? "NullState " : "";
+    ret += (mFlag & VOLATILE) ? "Volatile " : "";
+    ret += (mFlag & BUFFERED_BYTES) ? "BufferedBytes " : "";
+    return ret;
+}
+
+// isArray() will return true for reports that may contains multiple values, e.g. keyboard scan
+// code, which can have multiple value, each denoting a key pressed down at the same time. It will
+// return false if repor represent a vector or matrix.
+//
+// This slightly deviates from HID's definition, it is more convenient this way as matrix/vector
+// input is treated similarly as variables.
+bool HidReport::isArray() const {
+    using namespace HidDef::ReportFlag;
+    return (mFlag & ARRAY_VARIABLE) == 0 && mIsCollapsed;
+}
+
+bool HidReport::isVariable() const {
+    return !isArray();
+}
+
+bool HidReport::isData() const {
+    using namespace HidDef::ReportFlag;
+    return (mFlag & DATA_CONST) == 0;
+}
+
+std::ostream& operator<<(std::ostream& os, const HidReport& h) {
+    os << h.getStringType() << ", "
+       << "usage: " << std::hex << h.getFullUsage() << std::dec << ", ";
+
+    if (h.isData()) {
+        auto range = h.getLogicalRange();
+        os << "logMin: " << range.first << ", "
+           << "logMax: " << range.second << ", ";
+
+        if (range == h.getPhysicalRange()) {
+            os << "phy===log, ";
+        } else {
+            range = h.getPhysicalRange();
+            os << "phyMin: " << range.first << ", "
+               << "phyMax: " << range.second << ", ";
+        }
+
+        if (h.isArray()) {
+            os << "map: (" << std::hex;
+            for (auto i : h.getUsageVector()) {
+                os << i << ",";
+            }
+            os << "), " << std::dec;
+        }
+
+        os << "exponent: " << h.getExponentString() << ", "
+           << "unit: " << h.getUnitString() << ", ";
+    } else {
+        os << "constant: ";
+    }
+    os << "size: " << h.getSize() << "bit x " << h.getCount() << ", "
+       << "id: " << h.mReportId;
+
+    return os;
+}
+
+std::pair<int64_t, int64_t> HidReport::getLogicalRange() const {
+    int64_t a = mLogicalMin;
+    int64_t b = mLogicalMax;
+
+    if (a > b) {
+        // might be unsigned
+        a = a & ((static_cast<int64_t>(1) << getSize()) - 1);
+        b = b & ((static_cast<int64_t>(1) << getSize()) - 1);
+        if (a > b) {
+            // bad hid descriptor
+            return {0, 0};
+        }
+    }
+    return {a, b};
+}
+
+std::pair<int64_t, int64_t> HidReport::getPhysicalRange() const {
+    if (!(mPhysicalMin.isSet() && mPhysicalMax.isSet())) {
+        // physical range undefined, use logical range
+        return getLogicalRange();
+    }
+
+    int64_t a = mPhysicalMin.get(0);
+    int64_t b = mPhysicalMax.get(0);
+
+    if (a > b) {
+        a = a & ((static_cast<int64_t>(1) << getSize()) - 1);
+        b = b & ((static_cast<int64_t>(1) << getSize()) - 1);
+        if (a > b) {
+            return {0, 0};
+        }
+    }
+    return {a, b};
+}
+
+unsigned int HidReport::getFullUsage() const {
+    return mUsage | (mUsagePage << 16);
+}
+
+size_t HidReport::getSize() const {
+    return mReportSize;
+}
+
+size_t HidReport::getCount() const {
+    return mReportCount;
+}
+
+unsigned int HidReport::getUnit() const {
+    return mUnit.get(0); // default unit is 0 means default unit
+}
+
+unsigned HidReport::getReportId() const {
+    // if report id is not specified, it defaults to zero
+    return mReportId.get(0);
+}
+
+unsigned HidReport::getType() const {
+    return mReportType;
+}
+
+void HidReport::setCollapsed(uint32_t fullUsage) {
+    mUsage = fullUsage & 0xFFFF;
+    mUsagePage = fullUsage >> 16;
+    mIsCollapsed = true;
+}
+
+const std::vector<unsigned int>& HidReport::getUsageVector() const {
+    return mUsageVector;
+}
+} // namespace HidUtil

modules/sensors/dynamic_sensor/HidUtils/HidReport.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDREPORT_H_
+#define HIDUTIL_HIDREPORT_H_
+
+#include "HidGlobal.h"
+#include "HidLocal.h"
+#include "TriState.h"
+#include <cstdint>
+#include <memory>
+#include <iostream>
+#include <utility>
+
+namespace HidUtil {
+
+class HidParser;
+class HidTreeNode;
+
+// HidReport represent an input, output or feature report
+class HidReport {
+    friend std::ostream& operator<<(std::ostream& os, const HidReport& h);
+public:
+    HidReport(uint32_t type_, uint32_t data, const HidGlobal &global, const HidLocal &local);
+
+    // This is called during parsing process when the parser regroups multi-valued report into one
+    void setCollapsed(uint32_t fullUsage);
+
+    // get report id
+    unsigned int getReportId() const;
+    // get type of report, return constant of HidDef::MainTag
+    unsigned int getType() const;
+    // Full sensor usage
+    unsigned int getFullUsage() const;
+
+    // binary properties
+    bool isArray() const;
+    bool isData() const;
+    bool isVariable() const;
+
+    // logical and physical value range
+    std::pair<int64_t, int64_t> getLogicalRange() const;
+    std::pair<int64_t, int64_t> getPhysicalRange() const;
+    double getExponentValue() const;
+
+    // return HID unit nibbles in an unsigned int
+    unsigned int getUnit() const;
+
+    // size in bits
+    size_t getSize() const;
+    // dimension (if it is vector/matrix) or number of concurrent input values
+    // it is also used to calculate memory foot print
+    size_t getCount() const;
+
+    // for output to stream
+    static std::string reportTypeToString(int type);
+    std::string getStringType() const;
+    std::string getExponentString() const;
+    std::string getUnitString() const;
+    std::string getFlagString() const;
+    const std::vector<unsigned int>& getUsageVector() const;
+private:
+    bool mIsCollapsed;
+
+    // mandatary fields
+    unsigned int mReportType;
+    unsigned int mFlag;
+    unsigned int mUsagePage;
+    unsigned int mUsage;
+    std::vector<unsigned int> mUsageVector;
+
+    int mLogicalMin;        // 32 bit is enough
+    int mLogicalMax;
+    unsigned int mReportSize;
+    unsigned int mReportCount;
+
+    // these below are optional
+    tri_int mPhysicalMin;
+    tri_int mPhysicalMax;
+
+    tri_uint mExponent;
+    tri_uint mUnit;
+    tri_uint mReportId;
+};
+
+std::ostream& operator<<(std::ostream& os, const HidReport& h);
+} // namespace HidUtil
+#endif // HIDUTIL_HIDREPORT_H_

modules/sensors/dynamic_sensor/HidUtils/HidTree.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2017 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 "HidDefs.h"
+#include "HidLog.h"
+#include "HidTree.h"
+#include <memory>
+
+namespace HidUtil {
+
+// HidTreeNode
+HidTreeNode::HidTreeNode() : mNodeType(TYPE_UNINITIALIZED), mData(0), mFullUsage(0) {
+}
+
+HidTreeNode::HidTreeNode(std::shared_ptr<HidTreeNode> parent,
+                         uint32_t data, uint32_t fullUsage, int nodeType)
+        : mNodeType(nodeType), mData(data),
+        mFullUsage(fullUsage), mParent(parent) {
+}
+
+HidTreeNode::HidTreeNode(std::shared_ptr<HidTreeNode> parent,
+                         uint32_t data, uint32_t fullUsage)
+        : mNodeType(TYPE_NORMAL), mData(data),
+        mFullUsage(fullUsage), mParent(parent) {
+}
+
+void HidTreeNode::outputRecursive(std::ostream &os, int level) const {
+    insertIndentation(os, level);
+    os << "Node data: " << mData
+       << ", usage " << std::hex << mFullUsage << std::dec << LOG_ENDL;
+
+    for (auto &child : mChildren) {
+        child->outputRecursive(os, level + 1);
+    }
+}
+
+std::shared_ptr<HidTreeNode> HidTreeNode::deepCopy(
+        std::shared_ptr<HidTreeNode> parent) const {
+    std::shared_ptr<HidTreeNode> copy(new HidTreeNode(parent, mData, mFullUsage, mNodeType));
+    for (auto &i : mChildren) {
+        copy->mChildren.push_back(i->deepCopy(copy));
+    }
+    return copy;
+}
+
+void HidTreeNode::insertIndentation(std::ostream &os, int level) const {
+    constexpr char indentCharacter = '\t';
+    std::fill_n(std::ostreambuf_iterator<char>(os), level, indentCharacter);
+}
+
+std::shared_ptr<HidTreeNode> HidTreeNode::addChild(std::shared_ptr<HidTreeNode> child) {
+    mChildren.push_back(child);
+    return child;
+}
+
+std::shared_ptr<HidTreeNode> HidTreeNode::getParent() const {
+    return mParent.lock();
+}
+
+bool HidTreeNode::isReportCollection() const {
+    return mNodeType == TYPE_NORMAL && mChildren.size() == 1
+            && mChildren.front()->mNodeType == TYPE_REPORT;
+}
+
+unsigned int HidTreeNode::getFullUsage() const {
+    return mFullUsage;
+}
+
+std::vector<std::shared_ptr<HidTreeNode>>& HidTreeNode::getChildren() {
+    return mChildren;
+}
+
+const std::vector<std::shared_ptr<HidTreeNode>>& HidTreeNode::getChildren() const {
+    return mChildren;
+}
+
+bool HidTreeNode::isUsageCollection() const {
+    using namespace HidDef::CollectionType;
+    return mNodeType == TYPE_NORMAL && (mData == PHYSICAL || mData == APPLICATION);
+}
+
+int HidTreeNode::getNodeType() const {
+    return mNodeType;
+}
+
+std::ostream& operator<<(std::ostream& os, const HidTreeNode& n) {
+    n.outputRecursive(os, 0);
+    return os;
+}
+
+// HidReportNode
+HidReportNode::HidReportNode(std::shared_ptr<HidTreeNode> parent, const HidReport &report)
+    : HidTreeNode(parent, 0 /*data*/, 0 /*fullUsage*/, TYPE_REPORT), mReport(report) {
+}
+
+void HidReportNode::outputRecursive(std::ostream &os, int level) const {
+    insertIndentation(os, level);
+    os << mReport << LOG_ENDL;
+}
+
+std::shared_ptr<HidTreeNode> HidReportNode::deepCopy(
+        std::shared_ptr<HidTreeNode> parent) const {
+    std::shared_ptr<HidTreeNode> copy(new HidReportNode(parent, mReport));
+    return copy;
+}
+
+const HidReport& HidReportNode::getReport() const {
+    return mReport;
+}
+
+void HidReportNode::collapse(unsigned int newUsage) {
+    mReport.setCollapsed(newUsage);
+}
+
+} //namespace HidUtil

modules/sensors/dynamic_sensor/HidUtils/HidTree.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_HIDTREE_H_
+#define HIDUTIL_HIDTREE_H_
+
+#include "HidReport.h"
+
+#include <cstddef>
+#include <vector>
+#include <iostream>
+
+namespace HidUtil {
+
+// HID report parser output tree node
+class HidTreeNode {
+    friend std::ostream& operator<<(std::ostream& os, const HidTreeNode& n);
+public:
+    enum {
+        TYPE_UNINITIALIZED = 0,
+        TYPE_NORMAL = 1,
+        TYPE_REPORT = 2     // can be cast to HidReportNode
+    };
+    HidTreeNode();
+    HidTreeNode(std::shared_ptr<HidTreeNode> parent, uint32_t data, uint32_t fullUsage);
+
+    virtual ~HidTreeNode() = default;
+
+    // make a deep copy of tree at and below this node and attach it to specified parent node
+    virtual std::shared_ptr<HidTreeNode> deepCopy(
+          std::shared_ptr<HidTreeNode> parent = nullptr) const;
+
+    // add child to this node
+    std::shared_ptr<HidTreeNode> addChild(std::shared_ptr<HidTreeNode> child);
+
+    // get all children of a node
+    std::vector<std::shared_ptr<HidTreeNode>>& getChildren();
+    const std::vector<std::shared_ptr<HidTreeNode>>& getChildren() const;
+
+    // get parent (nullptr if it is root node or if lock weak_ptr failed)
+    std::shared_ptr<HidTreeNode> getParent() const;
+
+    // access usage of this node
+    unsigned int getFullUsage() const;
+
+    bool isReportCollection() const;
+    bool isUsageCollection() const;
+    int getNodeType() const;
+protected:
+    // for derived class to define different nodeType
+    HidTreeNode(std::shared_ptr<HidTreeNode> parent,
+              uint32_t data, uint32_t fullUsage, int nodeType);
+
+    // helper for stream output
+    void insertIndentation(std::ostream &os, int level) const;
+private:
+    // helper for stream output
+    virtual void outputRecursive(std::ostream& os, int level) const;
+
+    int mNodeType;
+    uint32_t mData;
+    uint32_t mFullUsage;
+
+    std::vector<std::shared_ptr<HidTreeNode>> mChildren;
+    std::weak_ptr<HidTreeNode> mParent;
+};
+
+// Tree node that corresponds to an input, output or feature report
+class HidReportNode : public HidTreeNode {
+public:
+    HidReportNode(std::shared_ptr<HidTreeNode> parent, const HidReport &report);
+
+    virtual std::shared_ptr<HidTreeNode> deepCopy(
+          std::shared_ptr<HidTreeNode> parent = nullptr) const override;
+
+    // obtain HidReport attached to this node
+    const HidReport& getReport() const;
+
+    // reset usage of node and set underlying report to collapsed
+    void collapse(unsigned int newUsage);
+private:
+    virtual void outputRecursive(std::ostream &os, int level) const override;
+
+    HidReport mReport;
+};
+
+std::ostream& operator<<(std::ostream& os, const HidTreeNode& n);
+
+} // namespace HidUtil
+
+#endif // HIDUTIL_HIDTREE_H_

modules/sensors/dynamic_sensor/HidUtils/StreamIoUtil.h

@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_STREAM_IO_UTIL_H_
+#define HIDUTIL_STREAM_IO_UTIL_H_
+
+#include "HidLog.h"
+#include <istream>
+#include <iomanip>
+#include <sstream>
+#include <vector>
+#include <cassert>
+
+namespace HidUtil {
+
+template<typename CharT>
+class charvectorbuf : public std::streambuf { // class name is consistent with std lib
+    static_assert(std::is_const<CharT>::value == false, "cannot use const type");
+public:
+    // r/w buffer constructors
+    charvectorbuf(std::vector<CharT> &vec) {
+        init(vec.data(), vec.size());
+    }
+
+    charvectorbuf(CharT *begin, CharT *end) {
+        assert(end >= begin);
+        init(begin, end - begin);
+    }
+
+    charvectorbuf(CharT *begin, size_t size) {
+        init(begin, size);
+    }
+
+    // r/o buffer constructor
+    charvectorbuf(const std::vector<CharT> &vec) {
+        init(vec.data(), vec.size());
+    }
+
+    charvectorbuf(const CharT *begin, const CharT *end) {
+        assert(end >= begin);
+        init(begin, end - begin);
+    }
+
+    charvectorbuf(const CharT *begin, size_t size) {
+        init(begin, size);
+    }
+ protected:
+    virtual std::streampos seekpos(
+            std::streampos sp, std::ios_base::openmode which =
+            std::ios_base::in | std::ios_base::out) override {
+        return seekoff(std::streamoff(sp), std::ios_base::beg, which);
+    }
+
+    // this is needed to use ftell() on stream
+    virtual std::streampos seekoff(
+            std::streamoff off, std::ios_base::seekdir way,
+            std::ios_base::openmode which =
+            std::ios_base::in | std::ios_base::out) override {
+
+        // pptr() == nullptr: read-only
+        assert(pptr() == nullptr || egptr() - eback() == epptr() - pbase());
+        bool in = which & std::ios_base::in;
+        bool out = which & std::ios_base::out;
+        pos_type end = egptr() - eback();
+
+        if (!in && !out) {
+            return pos_type(-1);
+        }
+
+        if (in && out && way == std::ios_base::cur) {
+            return pos_type(-1);
+        }
+
+        off_type noff;
+        switch (way) {
+            case std::ios_base::beg:
+                noff = 0;
+                break;
+            case std::ios_base::cur:
+                if (in) {
+                    noff = gptr() - eback();
+                } else {
+                    noff = pptr() - pbase();
+                }
+                break;
+            case std::ios_base::end:
+                noff = end;
+                break;
+            default:
+                return pos_type(-1);
+        }
+        noff += off;
+        if (noff < 0 ||  noff > end) {
+            return pos_type(-1);
+        }
+
+        if (noff != 0 && ((in && gptr() == nullptr) || (out && pptr() == nullptr))) {
+            return pos_type(-1);
+        }
+
+        if (in) {
+            setg(eback(), eback() + noff, egptr());
+        }
+
+        if (out) {
+            setp(pbase(), epptr());
+            pbump(noff);
+        }
+
+        return pos_type(noff);
+    }
+private:
+    // read only buffer init
+    void init(const CharT *base, size_t size) {
+        setg((char*)base, (char*)base, (char*)(base + size));
+    }
+
+    // read write buffer init
+    void init(CharT *base, size_t size) {
+        setg((char*)base, (char*)base, (char*)(base + size));
+        setp((char*)base, (char*)(base + size));
+    }
+};
+
+// dump binary values
+template <class ForwardIterator>
+void hexdumpToStream(std::ostream &os, const ForwardIterator &first, const ForwardIterator &last) {
+    static_assert(
+            std::is_convertible<
+                typename std::iterator_traits<ForwardIterator>::iterator_category,
+                std::forward_iterator_tag>::value
+            && std::is_convertible<
+                typename std::iterator_traits<ForwardIterator>::value_type,
+                unsigned char>::value
+            && sizeof(typename std::iterator_traits<ForwardIterator>::value_type)
+                == sizeof(unsigned char),
+            "Only accepts forward iterator of a type of size 1 "
+                "that can be convert to unsigned char.\n");
+    size_t c = 0;
+    std::ostringstream ss;
+    for (ForwardIterator i = first; i != last; ++i, ++c) {
+        unsigned char v = *i;
+        // formatting
+        switch (c & 0xf) {
+            case 0:
+                // address
+                os << ss.str() << LOG_ENDL;
+                ss.str("");
+                ss << std::hex;
+                ss << std::setfill('0') << std::setw(4) << c << ": ";
+                break;
+            case 8:
+                // space
+                ss << " ";
+                break;
+        }
+        ss << std::setfill('0') << std::setw(2)
+           << static_cast<unsigned>(static_cast<unsigned char>(v)) << " ";
+    }
+    os << ss.str() << LOG_ENDL;
+}
+} //namespace HidUtil
+
+#endif // HIDUTIL_STREAM_IO_UTIL_H_
+

modules/sensors/dynamic_sensor/HidUtils/TriState.h

@@ -0,0 +1,254 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_TRISTATE_H_
+#define HIDUTIL_TRISTATE_H_
+
+#include <cassert>
+#include <iostream>
+
+namespace HidUtil {
+template<typename T>
+class TriState {
+public:
+    // constructor
+    TriState() : mIsSet(false) { }
+    TriState(const TriState<T> &other) : mIsSet(other.mIsSet), mValue(other.mValue) { }
+    explicit TriState(const T &value) : mIsSet(true), mValue(value) { }
+
+    void clear() {
+        mValue = T();
+        mIsSet = false;
+    }
+    bool isSet() const {
+        return mIsSet;
+    }
+
+    const T get(const T &defaultValue) const {
+        return isSet() ? mValue : defaultValue;
+    }
+
+    // operator overloading
+    explicit operator T () const {
+        assert(mIsSet);
+        return mValue;
+    }
+
+    TriState<T>& operator=(const TriState<T> &other) {
+        mIsSet = other.mIsSet;
+        mValue = other.mValue;
+        return *this;
+    }
+
+    TriState<T>& operator=(const T& value) {
+        mIsSet = true;
+        mValue = value;
+        return *this;
+    }
+
+    TriState<T>& operator++()  {
+        if (mIsSet) {
+            mValue++;
+        }
+        return *this;
+    }
+
+    TriState<T> operator++(int) {
+        TriState<T> tmp(*this);
+        operator++();
+        return tmp;
+    }
+
+    TriState<T>& operator--()  {
+        if (mIsSet) {
+            mValue--;
+        }
+        return *this;
+    }
+
+    TriState<T> operator--(int) {
+        TriState<T> tmp(*this);
+        operator--();
+        return tmp;
+    }
+
+#define UNARY_OP(op) \
+    TriState<T> operator op() { \
+        TriState<T> tmp(*this); \
+        if (mIsSet) { \
+            tmp.mValue = op tmp.mValue; \
+        } \
+        return tmp; \
+    }
+
+    UNARY_OP(!);
+    UNARY_OP(-);
+    UNARY_OP(~);
+#undef UNARY_OP
+
+#define COMPOUND_ASSIGN_OP(op) \
+    TriState<T>& operator op (const TriState<T>& rhs) { \
+        if (mIsSet && rhs.mIsSet) { \
+            mValue op rhs.mValue; \
+        } else { \
+            mIsSet = false; \
+        } \
+        return *this; \
+    } \
+    TriState<T>& operator op(const T& rhs) { \
+        if (mIsSet) { \
+            mValue op rhs; \
+        } \
+        return *this; \
+    }
+
+    COMPOUND_ASSIGN_OP(+=);
+    COMPOUND_ASSIGN_OP(-=);
+    COMPOUND_ASSIGN_OP(*=);
+    COMPOUND_ASSIGN_OP(/=);
+    COMPOUND_ASSIGN_OP(%=);
+    COMPOUND_ASSIGN_OP(&=);
+    COMPOUND_ASSIGN_OP(|=);
+    COMPOUND_ASSIGN_OP(^=);
+#undef COMPOUND_ASSIGN_OP
+
+    TriState<T>& operator >>=(int i) {
+        if (mIsSet) {
+            mValue >>= i;
+        }
+        return *this; \
+    }
+
+    TriState<T>& operator <<=(int i) {
+        if (mIsSet) {
+            mValue <<= i;
+        }
+        return *this; \
+    }
+
+    TriState<T> operator <<(int i) { \
+        TriState<T> tmp(*this);
+        operator<<(i);
+        return tmp;
+    }
+
+    TriState<T> operator >>(int i) { \
+        TriState<T> tmp(*this);
+        operator>>(i);
+        return tmp;
+    }
+
+#define BINARY_OP(op, compound_op) \
+    friend TriState<T> operator op(TriState<T> lhs, const TriState<T>& rhs) { \
+        lhs compound_op rhs; \
+    return lhs; \
+    }\
+        friend TriState<T> operator op(TriState<T> lhs, const T& rhs) { \
+    lhs compound_op rhs; \
+        return lhs; \
+    }\
+    friend TriState<T> operator op(const T &lhs, const TriState<T>& rhs) { \
+        TriState<T> tmp(lhs); \
+        return tmp op rhs; \
+    }
+
+    BINARY_OP(+, +=);
+    BINARY_OP(-, -=);
+    BINARY_OP(*, *=);
+    BINARY_OP(/, /=);
+    BINARY_OP(%, %=);
+    BINARY_OP(&, &=);
+    BINARY_OP(|, |=);
+    BINARY_OP(^, ^=);
+#undef BINARY_OP
+
+#define RELATION_OP(op) \
+    friend TriState<bool> operator op(const TriState<T>& lhs, const TriState<T>& rhs) { \
+        if (lhs.mIsSet && rhs.mIsSet) { \
+            return TriState<bool>(lhs.mValue op rhs.mValue); \
+        } else { \
+        return TriState<bool>(); \
+        } \
+    } \
+    friend TriState<bool> operator op(const TriState<T>& lhs, const T& rhs) { \
+        if (lhs.mIsSet) { \
+            return TriState<bool>(lhs.mValue op rhs); \
+        } else { \
+            return TriState<bool>(); \
+        } \
+    } \
+    friend TriState<bool> operator op(const T& lhs, const TriState<T>& rhs) { \
+        if (rhs.mIsSet) { \
+            return TriState<bool>(lhs op rhs.mValue); \
+        } else { \
+            return TriState<bool>(); \
+        } \
+    }
+
+    RELATION_OP(==);
+    RELATION_OP(!=);
+    RELATION_OP(>=);
+    RELATION_OP(<=);
+    RELATION_OP(>);
+    RELATION_OP(<);
+#undef RELATION_OP
+
+    friend TriState<bool> operator &&(TriState<T>& lhs, const TriState<T>& rhs) {
+        if (lhs.mIsSet && rhs.mIsSet) {
+            return TriState<bool>(lhs.mValue && rhs.mValue);
+        } else {
+            return TriState<bool>();
+        }
+    }
+
+    friend TriState<bool> operator ||(TriState<T>& lhs, const TriState<T>& rhs) {
+        if (lhs.mIsSet && rhs.mIsSet) {
+            return TriState<bool>(lhs.mValue || rhs.mValue);
+        } else {
+            return TriState<bool>();
+        }
+    }
+
+    friend std::ostream& operator <<(std::ostream &os, const TriState<T> &v) {
+        if (v.mIsSet) {
+            os << v.mValue;
+        } else {
+            os << "[not set]";
+        }
+        return os;
+    }
+
+    friend std::istream& operator >>(std::istream &is, const TriState<T> &v) {
+        T a;
+        is >> a;
+        v = TriState<T>(a);
+        return is;
+    }
+private:
+    bool mIsSet;
+    T mValue;
+};
+
+// commonly used ones
+typedef TriState<unsigned> tri_uint;
+typedef TriState<int> tri_int;
+
+typedef TriState<uint32_t> tri_uint32_t;
+typedef TriState<int32_t> tri_int32_t;
+typedef TriState<uint8_t> tri_uint8_t;
+typedef TriState<uint16_t> tri_uint16_t;
+}
+
+#endif // HIDUTIL_TRISTATE_H_

modules/sensors/dynamic_sensor/HidUtils/test/HidParserExample.cpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 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 "HidLog.h"
+#include "HidParser.h"
+#include "TestHidDescriptor.h"
+#include <errno.h>
+
+using HidUtil::HidParser;
+
+bool doParse() {
+    HidParser hidParser;
+    bool ret = true;
+
+    for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) {
+        if (p->data == nullptr || p->len == 0) {
+            break;
+        }
+        const char *name = p->name != nullptr ? p->name : "unnamed";
+        bool parseResult = hidParser.parse(p->data, p->len);
+
+        if (parseResult) {
+            LOG_V << name << "  filtered tree: " << LOG_ENDL;
+            LOG_V << *(hidParser.getTree());
+        } else {
+            ret = false;
+            LOG_E << name << " parsing error!" << LOG_ENDL;
+        }
+    }
+    return ret;
+}
+
+bool doParseAndFilter() {
+    HidParser hidParser;
+    bool ret = true;
+
+    for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) {
+        if (p->data == nullptr || p->len == 0) {
+            break;
+        }
+        const char *name = p->name != nullptr ? p->name : "unnamed";
+        bool parseResult = hidParser.parse(p->data, p->len);
+
+        if (parseResult) {
+            hidParser.filterTree();
+            LOG_V << name << "  filtered tree: " << LOG_ENDL;
+            LOG_V << *(hidParser.getTree());
+        } else {
+            ret = false;
+            LOG_E << name << " parsing error!" << LOG_ENDL;
+        }
+    }
+    return ret;
+}
+
+bool doDigest() {
+    HidParser hidParser;
+    bool ret = true;
+
+    // value from HID sensor usage page spec
+    std::unordered_set<unsigned int> interestedUsage = {
+        0x200073, // accelerometer 3d
+        0x200076, // gyro 3d
+        0x200083, // mag 3d
+        0x20008a, // device orientation (rotation vector)
+    };
+
+    for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) {
+        if (p->data == nullptr || p->len == 0) {
+            break;
+        }
+        const char *name = p->name != nullptr ? p->name : "unnamed";
+        bool parseResult = hidParser.parse(p->data, p->len);
+
+        if (!parseResult) {
+            LOG_E << name << " parsing error!" << LOG_ENDL;
+            ret = false;
+            continue;
+        }
+
+        hidParser.filterTree();
+        LOG_V << name << "  digest: " << LOG_ENDL;
+        HidParser::DigestVector digestVector = hidParser.generateDigest(interestedUsage);
+        LOG_V << digestVector;
+    }
+    return ret;
+}
+
+void printUsage(char *argv0) {
+    LOG_V << "Usage: " << argv0 << " test_name" << LOG_ENDL;
+    LOG_V << "  test_name can be parse, parse_filter, digest." << LOG_ENDL;
+}
+
+int main(int argc, char* argv[]) {
+    int ret;
+
+    if (argc != 2) {
+        LOG_E << "Error: need param" << LOG_ENDL;
+        printUsage(argv[0]);
+        return -EINVAL;
+    }
+
+    if (strcmp(argv[1], "parse") == 0) {
+        ret = doParse() ? 0 : 1;
+    } else if (strcmp(argv[1], "parse_filter") == 0) {
+        ret = doParseAndFilter() ? 0 : 1;
+    } else if (strcmp(argv[1], "digest") == 0) {
+        ret = doDigest() ? 0 : 1;
+    } else {
+        LOG_E << "Error: unknown test name" << LOG_ENDL;
+        printUsage(argv[0]);
+        ret = -ENOENT;
+    }
+
+    return ret;
+}

modules/sensors/dynamic_sensor/HidUtils/test/HidParserExample2.cpp

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2017 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 "TestHidDescriptor.h"
+#include "HidLog.h"
+#include "HidParser.h"
+#include "StreamIoUtil.h"
+
+using namespace HidUtil;
+
+void printRawValue(const std::vector<unsigned char> &descriptor) {
+    LOG_D << "Descriptor [" << descriptor.size() << "]: " << std::hex;
+    hexdumpToStream(LOG_D, descriptor.begin(), descriptor.end());
+}
+
+void printToken(const std::vector<HidItem> &hidItemVector) {
+    LOG_V << "Total " << hidItemVector.size() << " tokens" << LOG_ENDL;
+    for (auto &i : hidItemVector) {
+        LOG_V << i << LOG_ENDL;
+    }
+}
+
+int main() {
+    const TestHidDescriptor *t = findTestDescriptor("accel3");
+    constexpr unsigned int ACCEL_3D_USAGE = 0x200073;
+
+    assert(t != nullptr);
+    std::vector<unsigned char> descriptor(t->data, t->data + t->len);
+
+    // parse can be done in one step with HidParser::parse(const unsigned char *begin, size_t size);
+    // here it is done in multiple steps for illustration purpose
+    HidParser hidParser;
+    // print out raw value
+    printRawValue(descriptor);
+
+    // tokenize it
+    std::vector<HidItem> hidItemVector = HidItem::tokenize(descriptor);
+
+    // print out tokens
+    printToken(hidItemVector);
+
+    // parse it
+    if (hidParser.parse(hidItemVector)) {
+        // making a deepcopy of tree (not necessary, but for illustration)
+        std::shared_ptr<HidTreeNode> tree = hidParser.getTree()->deepCopy();
+
+        LOG_V << "Tree: " << LOG_ENDL;
+        LOG_V << *tree;
+        LOG_V << LOG_ENDL;
+
+        hidParser.filterTree();
+        LOG_V << "FilteredTree: " << LOG_ENDL;
+        LOG_V << *(hidParser.getTree());
+
+        LOG_V << "DigestVector: " << LOG_ENDL;
+        std::unordered_set<unsigned int> interested = {ACCEL_3D_USAGE};
+        HidParser::DigestVector digestVector = hidParser.generateDigest(interested);
+        LOG_V << digestVector;
+
+    } else {
+        LOG_V << "Parsing Error" << LOG_ENDL;
+    }
+
+    return 0;
+}
+

modules/sensors/dynamic_sensor/HidUtils/test/TestHidDescriptor.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_TEST_HIDDESCRIPTOR_H_
+#define HIDUTIL_TEST_HIDDESCRIPTOR_H_
+
+#include <cstddef>
+
+struct TestHidDescriptor {
+    const unsigned char *data;
+    size_t len;
+    const char *name;
+};
+
+extern const TestHidDescriptor gDescriptorArray[];
+const TestHidDescriptor *findTestDescriptor(const char *name);
+
+#endif // HIDUTIL_TEST_HIDDESCRIPTOR_H_

modules/sensors/dynamic_sensor/HidUtils/test/TestHidSensorSpec.h

@@ -0,0 +1,859 @@
+/*
+ * Copyright (C) 2017 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 HIDUTIL_TEST_HIDSENSORSPEC_H
+#define HIDUTIL_TEST_HIDSENSORSPEC_H
+/**
+ * Example HID sensor definition in from published document "HID Sensors Usage"
+ * (hid-sensors-usage.docx). This file is added as part of the test case.
+ *
+ * It is slightly modified in order to compile.
+ */
+#define HID_USAGE_PAGE_SENSOR                                                           0x05,0x20
+
+//sensor category usages
+#define HID_USAGE_SENSOR_TYPE_COLLECTION                                                0x09,0x01
+//sensor category biometric
+#define HID_USAGE_SENSOR_CATEGORY_BIOMETRIC                                             0x09,0x10
+#define HID_USAGE_SENSOR_TYPE_BIOMETRIC_PRESENCE                                        0x09,0x11
+#define HID_USAGE_SENSOR_TYPE_BIOMETRIC_PROXIMITY                                       0x09,0x12
+#define HID_USAGE_SENSOR_TYPE_BIOMETRIC_TOUCH                                           0x09,0x13
+//sensor category electrical
+#define HID_USAGE_SENSOR_CATEGORY_ELECTRICAL                                            0x09,0x20
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_CAPACITANCE                                    0x09,0x21
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_CURRENT                                        0x09,0x22
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_POWER                                          0x09,0x23
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_INDUCTANCE                                     0x09,0x24
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_RESISTANCE                                     0x09,0x25
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_VOLTAGE                                        0x09,0x26
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_POTENTIOMETER                                  0x09,0x27
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_FREQUENCY                                      0x09,0x28
+#define HID_USAGE_SENSOR_TYPE_ELECTRICAL_PERIOD                                         0x09,0x29
+//sensor category environmental
+#define HID_USAGE_SENSOR_CATEGORY_ENVIRONMENTAL                                         0x09,0x30
+#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_ATMOSPHERIC_PRESSURE                        0x09,0x31
+#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_HUMIDITY                                    0x09,0x32
+#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_TEMPERATURE                                 0x09,0x33
+#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_WIND_DIRECTION                              0x09,0x34
+#define HID_USAGE_SENSOR_TYPE_ENVIRONMENTAL_WIND_SPEED                                  0x09,0x35
+//sensor category light
+#define HID_USAGE_SENSOR_CATEGORY_LIGHT                                                 0x09,0x40
+#define HID_USAGE_SENSOR_TYPE_LIGHT_AMBIENTLIGHT                                        0x09,0x41
+#define HID_USAGE_SENSOR_TYPE_LIGHT_CONSUMER_INFRARED                                   0x09,0x42
+//sensor category location
+#define HID_USAGE_SENSOR_CATEGORY_LOCATION                                              0x09,0x50
+#define HID_USAGE_SENSOR_TYPE_LOCATION_BROADCAST                                        0x09,0x51
+#define HID_USAGE_SENSOR_TYPE_LOCATION_DEAD_RECKONING                                   0x09,0x52
+#define HID_USAGE_SENSOR_TYPE_LOCATION_GPS                                              0x09,0x53
+#define HID_USAGE_SENSOR_TYPE_LOCATION_LOOKUP                                           0x09,0x54
+#define HID_USAGE_SENSOR_TYPE_LOCATION_OTHER                                            0x09,0x55
+#define HID_USAGE_SENSOR_TYPE_LOCATION_STATIC                                           0x09,0x56
+#define HID_USAGE_SENSOR_TYPE_LOCATION_TRIANGULATION                                    0x09,0x57
+//sensor category mechanical
+#define HID_USAGE_SENSOR_CATEGORY_MECHANICAL                                            0x09,0x60
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_BOOLEAN_SWITCH                                 0x09,0x61
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_BOOLEAN_SWITCH_ARRAY                           0x09,0x62
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_MULTIVALUE_SWITCH                              0x09,0x63
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_FORCE                                          0x09,0x64
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_PRESSURE                                       0x09,0x65
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_STRAIN                                         0x09,0x66
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_SCALE_WEIGHT                                   0x09,0x67
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_VIBRATOR                                       0x09,0x68
+#define HID_USAGE_SENSOR_TYPE_MECHANICAL_HALL_EFFECT_SWITCH                             0x09,0x69
+//sensor category motion
+#define HID_USAGE_SENSOR_CATEGORY_MOTION                                                0x09,0x70
+#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER_1D                                   0x09,0x71
+#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER_2D                                   0x09,0x72
+#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER_3D                                   0x09,0x73
+#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER_1D                                       0x09,0x74
+#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER_2D                                       0x09,0x75
+#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER_3D                                       0x09,0x76
+#define HID_USAGE_SENSOR_TYPE_MOTION_MOTION_DETECTOR                                    0x09,0x77
+#define HID_USAGE_SENSOR_TYPE_MOTION_SPEEDOMETER                                        0x09,0x78
+#define HID_USAGE_SENSOR_TYPE_MOTION_ACCELEROMETER                                      0x09,0x79
+#define HID_USAGE_SENSOR_TYPE_MOTION_GYROMETER                                          0x09,0x7A
+//sensor category orientation
+#define HID_USAGE_SENSOR_CATEGORY_ORIENTATION                                           0x09,0x80
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS_1D                                    0x09,0x81
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS_2D                                    0x09,0x82
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS_3D                                    0x09,0x83
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER_1D                               0x09,0x84
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER_2D                               0x09,0x85
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER_3D                               0x09,0x86
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE_1D                                   0x09,0x87
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE_2D                                   0x09,0x88
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE_3D                                   0x09,0x89
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DEVICE_ORIENTATION                            0x09,0x8A
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_COMPASS                                       0x09,0x8B
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_INCLINOMETER                                  0x09,0x8C
+#define HID_USAGE_SENSOR_TYPE_ORIENTATION_DISTANCE                                      0x09,0x8D
+//sensor category scanner
+#define HID_USAGE_SENSOR_CATEGORY_SCANNER                                               0x09,0x90
+#define HID_USAGE_SENSOR_TYPE_SCANNER_BARCODE                                           0x09,0x91
+#define HID_USAGE_SENSOR_TYPE_SCANNER_RFID                                              0x09,0x92
+#define HID_USAGE_SENSOR_TYPE_SCANNER_NFC                                               0x09,0x93
+//sensor category time
+#define HID_USAGE_SENSOR_CATEGORY_TIME                                                  0x09,0xA0
+#define HID_USAGE_SENSOR_TYPE_TIME_ALARM                                                0x09,0xA1
+#define HID_USAGE_SENSOR_TYPE_TIME_RTC                                                  0x09,0xA2
+//sensor category other
+#define HID_USAGE_SENSOR_CATEGORY_OTHER                                                 0x09,0xE0
+#define HID_USAGE_SENSOR_TYPE_OTHER_CUSTOM                                              0x09,0xE1
+#define HID_USAGE_SENSOR_TYPE_OTHER_GENERIC                                             0x09,0xE2
+#define HID_USAGE_SENSOR_TYPE_OTHER_GENERIC_ENUMERATOR                                  0x09,0xE3
+
+//unit usages
+#define HID_USAGE_SENSOR_UNITS_NOT_SPECIFIED                                            0x65,0x00                // Unit
+#define HID_USAGE_SENSOR_UNITS_LUX                                                      0x67,0xE1,0x00,0x00,0x01 // Unit
+#define HID_USAGE_SENSOR_UNITS_KELVIN                                                   0x67,0x01,0x00,0x01,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_FAHRENHEIT                                               0x67,0x03,0x00,0x01,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_PASCAL                                                   0x66,0xF1,0xE1           // Unit
+#define HID_USAGE_SENSOR_UNITS_NEWTON                                                   0x66,0x11,0xE1           // Unit
+#define HID_USAGE_SENSOR_UNITS_METERS_PER_SECOND                                        0x66,0x11,0xF0           // Unit
+#define HID_USAGE_SENSOR_UNITS_METERS_PER_SEC_SQRD                                      0x66,0x11,0xE0           // Unit
+#define HID_USAGE_SENSOR_UNITS_FARAD                                                    0x67,0xE1,0x4F,0x20,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_AMPERE                                                   0x67,0x01,0x00,0x10,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_WATT                                                     0x66,0x21,0xD1           // Unit
+#define HID_USAGE_SENSOR_UNITS_HENRY                                                    0x67,0x21,0xE1,0xE0,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_OHM                                                      0x67,0x21,0xD1,0xE0,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_VOLT                                                     0x67,0x21,0xD1,0xF0,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_HERTZ                                                    0x66,0x01,0xF0           // Unit
+#define HID_USAGE_SENSOR_UNITS_DEGREES                                                  0x65,0x14                // Unit
+#define HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND                                       0x66,0x14,0xF0           // Unit
+#define HID_USAGE_SENSOR_UNITS_DEGREES_PER_SEC_SQRD                                     0x66,0x14,0xE0           // Unit
+#define HID_USAGE_SENSOR_UNITS_RADIANS                                                  0x65,0x12                // Unit
+#define HID_USAGE_SENSOR_UNITS_RADIANS_PER_SECOND                                       0x66,0x12,0xF0           // Unit
+#define HID_USAGE_SENSOR_UNITS_RADIANS_PER_SEC_SQRD                                     0x66,0x12,0xE0           // Unit
+#define HID_USAGE_SENSOR_UNITS_SECOND                                                   0x66,0x01,0x10           // Unit
+#define HID_USAGE_SENSOR_UNITS_GAUSS                                                    0x67,0x01,0xE1,0xF0,0x00 // Unit
+#define HID_USAGE_SENSOR_UNITS_GRAM                                                     0x66,0x01,0x01           // Unit
+#define HID_USAGE_SENSOR_UNITS_CENTIMETER                                               0x65,0x11                // Unit
+#ifdef DEFINE_NON_HID_UNITS
+#define HID_USAGE_SENSOR_UNITS_CELSIUS              "Use Unit(Kelvin) and subtract 273.15"
+#define HID_USAGE_SENSOR_UNITS_KILOGRAM             "Use Unit(gram) and UnitExponent(0x03)"
+#define HID_USAGE_SENSOR_UNITS_METER                "Use Unit(centimeter) and UnitExponent(0x02)"
+#define HID_USAGE_SENSOR_UNITS_BAR                  "Use Unit(Pascal) and UnitExponent(0x05)"
+#define HID_USAGE_SENSOR_UNITS_KNOT                 "Use Unit(m/s) and multiply by 1852/3600"
+#define HID_USAGE_SENSOR_UNITS_PERCENT              "Use Unit(Not_Specified)"
+#define HID_USAGE_SENSOR_UNITS_G                    "Use Unit(m/s2) and divide by 9.8"
+#define HID_USAGE_SENSOR_UNITS_MILLISECOND          "Use Unit(second) and UnitExponent(0x0D)"
+#define HID_USAGE_SENSOR_UNITS_MILLIGAUSS           "Use Unit(Gauss) and UnitExponent(0x0D)"
+#endif
+//unit deprecated usages
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_LUX                                           0x01
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_KELVIN                                        0x02
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_CELSIUS                                       0x03
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_PASCAL                                        0x04
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_NEWTON                                        0x05
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_METERS_PER_SECOND                             0x06
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_KILOGRAM                                      0x07
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_METER                                         0x08
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_METERS_PER_SEC_SQRD                           0x09
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_FARAD                                         0x0A
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_AMPERE                                        0x0B
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_WATT                                          0x0C
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_HENRY                                         0x0D
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_OHM                                           0x0E
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_VOLT                                          0x0F
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_HERTZ                                         0x10
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_BAR                                           0x11
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREES_ANTI_CLOCKWISE                        0x12
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREES_CLOCKWISE                             0x13
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREE                                        0x14
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_DEGREES_PER_SECOND                            0x15
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_KNOT                                          0x16
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_PERCENT                                       0x17
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_SECOND                                        0x18
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_MILLISECOND                                   0x19
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_G                                             0x1A
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_BYTES                                         0x1B
+#define HID_USAGE_SENSOR_UNITS_DEPRECATED_MILLIGAUSS                                    0x1C
+
+//data type usage modifiers -- we use them as modifiers for sensor properties & data fields
+//to create thresholds, for example.
+//NOTE: the usage tables actually define these as two bytes, but in order
+//to get the define macros to work so these are ‘or-ed’ these are defined
+//here as only one byte.
+#define HID_USAGE_SENSOR_DATA_MOD_NONE                                                  0x00 // US
+#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS                                0x10 // US
+#define HID_USAGE_SENSOR_DATA_MOD_MAX                                                   0x20 // US
+#define HID_USAGE_SENSOR_DATA_MOD_MIN                                                   0x30 // US
+#define HID_USAGE_SENSOR_DATA_MOD_ACCURACY                                              0x40 // US
+#define HID_USAGE_SENSOR_DATA_MOD_RESOLUTION                                            0x50 // US
+#define HID_USAGE_SENSOR_DATA_MOD_THRESHOLD_HIGH                                        0x60 // US
+#define HID_USAGE_SENSOR_DATA_MOD_THRESHOLD_LOW                                         0x70 // US
+#define HID_USAGE_SENSOR_DATA_MOD_CALIBRATION_OFFSET                                    0x80 // US
+#define HID_USAGE_SENSOR_DATA_MOD_CALIBRATION_MULTIPLIER                                0x90 // US
+#define HID_USAGE_SENSOR_DATA_MOD_REPORT_INTERVAL                                       0xA0 // US
+#define HID_USAGE_SENSOR_DATA_MOD_FREQUENCY_MAX                                         0xB0 // US
+#define HID_USAGE_SENSOR_DATA_MOD_PERIOD_MAX                                            0xC0 // US
+#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_RANGE_PCT                          0xD0 // US
+#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_REL_PCT                            0xE0 // US
+#define HID_USAGE_SENSOR_DATA_MOD_VENDOR_RESERVED                                       0xF0 // US
+
+
+//state usages
+#define HID_USAGE_SENSOR_STATE                                                          0x0A,0x01,0x02 // NAry
+//state selectors
+#define HID_USAGE_SENSOR_STATE_UNKNOWN_SEL                                              0x0A,0x00,0x08 // Sel
+#define HID_USAGE_SENSOR_STATE_READY_SEL                                                0x0A,0x01,0x08 // Sel
+#define HID_USAGE_SENSOR_STATE_NOT_AVAILABLE_SEL                                        0x0A,0x02,0x08 // Sel
+#define HID_USAGE_SENSOR_STATE_NO_DATA_SEL                                              0x0A,0x03,0x08 // Sel
+#define HID_USAGE_SENSOR_STATE_INITIALIZING_SEL                                         0x0A,0x04,0x08 // Sel
+#define HID_USAGE_SENSOR_STATE_ACCESS_DENIED_SEL                                        0x0A,0x05,0x08 // Sel
+#define HID_USAGE_SENSOR_STATE_ERROR_SEL                                                0x0A,0x06,0x08 // Sel
+//state enums
+#define HID_USAGE_SENSOR_STATE_UNKNOWN_ENUM                                             0x01 // Enum
+#define HID_USAGE_SENSOR_STATE_READY_ENUM                                               0x02 // Enum
+#define HID_USAGE_SENSOR_STATE_NOT_AVAILABLE_ENUM                                       0x03 // Enum
+#define HID_USAGE_SENSOR_STATE_NO_DATA_ENUM                                             0x04 // Enum
+#define HID_USAGE_SENSOR_STATE_INITIALIZING_ENUM                                        0x05 // Enum
+#define HID_USAGE_SENSOR_STATE_ACCESS_DENIED_ENUM                                       0x06 // Enum
+#define HID_USAGE_SENSOR_STATE_ERROR_ENUM                                               0x07 // Enum
+//state deprecated enums
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_UNKNOWN_ENUM                                  0x00
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_NOT_AVAILABLE_ENUM                            0x01
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_READY_ENUM                                    0x02
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_NO_DATA_ENUM                                  0x03
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_INITIALIZING_ENUM                             0x04
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_ACCESS_DENIED_ENUM                            0x05
+#define HID_USAGE_SENSOR_STATE_DEPRECATED_ERROR_ENUM                                    0x06
+
+//event usages
+#define HID_USAGE_SENSOR_EVENT                                                          0x0A,0x02,0x02 // NAry
+//event selectors
+#define HID_USAGE_SENSOR_EVENT_UNKNOWN_SEL                                              0x0A,0x10,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_STATE_CHANGED_SEL                                        0x0A,0x11,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_PROPERTY_CHANGED_SEL                                     0x0A,0x12,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_DATA_UPDATED_SEL                                         0x0A,0x13,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_POLL_RESPONSE_SEL                                        0x0A,0x14,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_CHANGE_SENSITIVITY_SEL                                   0x0A,0x15,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_MAX_REACHED_SEL                                          0x0A,0x16,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_MIN_REACHED_SEL                                          0x0A,0x17,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_SEL                          0x0A,0x18,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_HIGH_THESHOLD_CROSS_ABOVE_SEL        HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_SEL
+#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_SEL                        0x0A,0x19,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_BELOW_SEL       HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_SEL
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_SEL                           0x0A,0x1A,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_ABOVE_SEL        HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_SEL
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_SEL                         0x0A,0x1B,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_BELOW_SEL        HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_SEL
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_SEL                          0x0A,0x1C,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_ABOVE_SEL       HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_SEL
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_SEL                        0x0A,0x1D,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_BELOW_SEL       HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_SEL
+#define HID_USAGE_SENSOR_EVENT_PERIOD_EXCEEDED_SEL                                      0x0A,0x1E,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_FREQUENCY_EXCEEDED_SEL                                   0x0A,0x1F,0x08 // Sel
+#define HID_USAGE_SENSOR_EVENT_COMPLEX_TRIGGER_SEL                                      0x0A,0x20,0x08 // Sel
+//event enums
+#define HID_USAGE_SENSOR_EVENT_UNKNOWN_ENUM                                             0x01 // Enum
+#define HID_USAGE_SENSOR_EVENT_STATE_CHANGED_ENUM                                       0x02 // Enum
+#define HID_USAGE_SENSOR_EVENT_PROPERTY_CHANGED_ENUM                                    0x03 // Enum
+#define HID_USAGE_SENSOR_EVENT_DATA_UPDATED_ENUM                                        0x04 // Enum
+#define HID_USAGE_SENSOR_EVENT_POLL_RESPONSE_ENUM                                       0x05 // Enum
+#define HID_USAGE_SENSOR_EVENT_CHANGE_SENSITIVITY_ENUM                                  0x06 // Enum
+#define HID_USAGE_SENSOR_EVENT_MAX_REACHED_ENUM                                         0x07 // Enum
+#define HID_USAGE_SENSOR_EVENT_MIN_REACHED_ENUM                                         0x08 // Enum
+#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_ENUM                         0x09 // Enum
+#define HID_USAGE_SENSOR_EVENT_HIGH_THESHOLD_CROSS_ABOVE_ENUM   HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_UPWARD_ENUM
+#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_ENUM                       0x0A // Enum
+#define HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_BELOW_ENUM  HID_USAGE_SENSOR_EVENT_HIGH_THRESHOLD_CROSS_DOWNWARD_ENUM
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_ENUM                          0x0B // Enum
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_ABOVE_ENUM   HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_UPWARD_ENUM
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_ENUM                        0x0C // Enum
+#define HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_BELOW_ENUM   HID_USAGE_SENSOR_EVENT_LOW_THRESHOLD_CROSS_DOWNWARD_ENUM
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_ENUM                         0x0D // Enum
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_ABOVE_ENUM  HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_UPWARD_ENUM
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_ENUM                       0x0E // Enum
+#define HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_BELOW_ENUM  HID_USAGE_SENSOR_EVENT_ZERO_THRESHOLD_CROSS_DOWNWARD_ENUM
+#define HID_USAGE_SENSOR_EVENT_PERIOD_EXCEEDED_ENUM                                     0x0F // Enum
+#define HID_USAGE_SENSOR_EVENT_FREQUENCY_EXCEEDED_ENUM                                  0x10 // Enum
+#define HID_USAGE_SENSOR_EVENT_COMPLEX_TRIGGER_ENUM                                     0x11 // Enum
+//event deprecated enums
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_UNKNOWN_ENUM                                  0x00
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_STATE_CHANGED_ENUM                            0x01
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_PROPERTY_CHANGED_ENUM                         0x02
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_DATA_UPDATE_ENUM                              0x03
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_POLL_RESPONSE_ENUM                            0x04
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_CHANGE_SENSITIVITY_ENUM                       0x05
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_MAX_REACHED_ENUM                              0x06
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_MIN_REACHED_ENUM                              0x07
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_HIGH_THRESHHOLD_CROSS_ABOVE_ENUM              0x08
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_HIGH_THRESHHOLD_CROSS_BELOW_ENUM              0x09
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_LOW_THRESHHOLD_CROSS_ABOVE_ENUM               0x0A
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_LOW_THRESHHOLD_CROSS_BELOW_ENUM               0x0B
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_ZERO_THRESHOLD_CROSS_ABOVE_ENUM               0x0C
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_ZERO_THRESHOLD_CROSS_BELOW_ENUM               0x0D
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_PERIOD_EXCEEDED_ENUM                          0x0E
+#define HID_USAGE_SENSOR_EVENT_DEPRECATED_FREQUENCY_EXCEEDED_ENUM                       0x0F
+
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY                                                       0x0A,0x00,0x03
+#define HID_USAGE_SENSOR_PROPERTY_FRIENDLY_NAME                                         0x0A,0x01,0x03
+#define HID_USAGE_SENSOR_PROPERTY_PERSISTENT_UNIQUE_ID                                  0x0A,0x02,0x03
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_STATUS                                         0x0A,0x03,0x03
+#define HID_USAGE_SENSOR_PROPERTY_MINIMUM_REPORT_INTERVAL                               0x0A,0x04,0x03
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_MANUFACTURER                                   0x0A,0x05,0x03
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_MODEL                                          0x0A,0x06,0x03
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_SERIAL_NUMBER                                  0x0A,0x07,0x03
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_DESCRIPTION                                    0x0A,0x08,0x03
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_CONNECTION_TYPE                                0x0A,0x09,0x03 // NAry
+//begin connection type selectors
+#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_INTEGRATED_SEL                     0x0A,0x30,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_ATTACHED_SEL                       0x0A,0x31,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_EXTERNAL_SEL                       0x0A,0x32,0x08 // Sel
+//end connection type selectors
+//begin connection type enums
+#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_INTEGRATED_ENUM                    0x01 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_ATTACHED_ENUM                      0x02 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_CONNECTION_TYPE_PC_EXTERNAL_ENUM                      0x03 // Enum
+//end connection type enums
+//begin connection type deprecated enums
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_CONNECTION_TYPE_PC_INTEGRATED_ENUM         0x00 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_CONNECTION_TYPE_PC_ATTACHED_ENUM           0x01 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_CONNECTION_TYPE_PC_EXTERNAL_ENUM           0x02 // Enum
+//end connection type deprecated enums
+#define HID_USAGE_SENSOR_PROPERTY_SENSOR_DEVICE_PATH                                    0x0A,0x0A,0x03
+#define HID_USAGE_SENSOR_PROPERTY_HARDWARE_REVISION                                     0x0A,0x0B,0x03
+#define HID_USAGE_SENSOR_PROPERTY_FIRMWARE_VERSION                                      0x0A,0x0C,0x03
+#define HID_USAGE_SENSOR_PROPERTY_RELEASE_DATE                                          0x0A,0x0D,0x03
+#define HID_USAGE_SENSOR_PROPERTY_REPORT_INTERVAL                                       0x0A,0x0E,0x03
+#define HID_USAGE_SENSOR_PROPERTY_CHANGE_SENSITIVITY_ABS                                0x0A,0x0F,0x03
+#define HID_USAGE_SENSOR_PROPERTY_CHANGE_SENSITIVITY_RANGE_PCT                          0x0A,0x10,0x03
+#define HID_USAGE_SENSOR_PROPERTY_CHANGE_SENSITIVITY_REL_PCT                            0x0A,0x11,0x03
+#define HID_USAGE_SENSOR_PROPERTY_ACCURACY                                              0x0A,0x12,0x03
+#define HID_USAGE_SENSOR_PROPERTY_RESOLUTION                                            0x0A,0x13,0x03
+#define HID_USAGE_SENSOR_PROPERTY_RANGE_MAXIMUM                                         0x0A,0x14,0x03
+#define HID_USAGE_SENSOR_PROPERTY_RANGE_MINIMUM                                         0x0A,0x15,0x03
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE                                       0x0A,0x16,0x03 // NAry
+//begin reporting state selectors
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_SEL                         0x0A,0x40,0x08 // Sel
+#define HID_USAGE_REPORTING_STATE_ON_NONE_SEL       HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_SEL
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_SEL                        0x0A,0x41,0x08 // Sel
+#define HID_USAGE_REPORTING_STATE_ON_ALL_SEL        HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_SEL
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_SEL                  0x0A,0x42,0x08 // Sel
+#define HID_USAGE_REPORTING_STATE_ON_THRESHOLD_SEL  HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_SEL
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_WAKE_SEL                    0x0A,0x43,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_WAKE_SEL                   0x0A,0x44,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_WAKE_SEL             0x0A,0x45,0x08 // Sel
+//end reporting state selectors
+//begin reporting state enums
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_ENUM                        0x01 // Enum
+#define HID_USAGE_REPORTING_STATE_ON_NONE_ENUM      HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_ENUM
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_ENUM                       0x02 // Enum
+#define HID_USAGE_REPORTING_STATE_ON_ALL_ENUM       HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_ENUM
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_ENUM                 0x03 // Enum
+#define HID_USAGE_REPORTING_STATE_ON_THRESHOLD_ENUM HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_ENUM
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_NO_EVENTS_SEL_WAKE_ENUM                   0x04 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_ALL_EVENTS_SEL_WAKE_ENUM                  0x05 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_REPORTING_STATE_THRESHOLD_EVENTS_WAKE_ENUM            0x06 // Enum
+//end reporting state enums
+//begin reporting state deprecated enums
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_NO_EVENTS_ENUM             0x00 // Enum
+#define HID_USAGE_DEPRECATED_REPORTING_STATE_ON_NONE_ENUM      HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_NO_EVENTS_ENUM
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_ALL_EVENTS_ENUM            0x01 // Enum
+#define HID_USAGE_DEPRECATED_REPORTING_STATE_ON_ALL_ENUM       HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_ALL_EVENTS_ENUM
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_THRESHOLD_EVENTS_ENUM      0x02 // Enum
+#define HID_USAGE_DEPRECATED_REPORTING_STATE_ON_THRESHOLD_ENUM HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_THRESHOLD_EVENTS_ENUM
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_NO_EVENTS_WAKE_ENUM        0x03 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_ALL_EVENTS_WAKE_ENUM       0x04 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_REPORTING_STATE_THRESHOLD_EVENTS_WAKE_ENUM 0x05 // Enum
+//end reporting state deprecated enums
+#define HID_USAGE_SENSOR_PROPERTY_SAMPLING_RATE                                         0x0A,0x17,0x03
+#define HID_USAGE_SENSOR_PROPERTY_RESPONSE_CURVE                                        0x0A,0x18,0x03
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE                                           0x0A,0x19,0x03 // NAry
+//begin power state selectors
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_UNDEFINED_SEL                             0x0A,0x50,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D0_FULL_POWER_SEL                         0x0A,0x51,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D1_LOW_POWER_SEL                          0x0A,0x52,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D2_STANDBY_WITH_WAKE_SEL                  0x0A,0x53,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D3_SLEEP_WITH_WAKE_SEL                    0x0A,0x54,0x08 // Sel
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D4_POWER_OFF_SEL                          0x0A,0x55,0x08 // Sel
+//end power state selectors
+//begin power state enums
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_UNDEFINED_ENUM                            0x01 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D0_FULL_POWER_ENUM                        0x02 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D1_LOW_POWER_ENUM                         0x03 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D2_STANDBY_WITH_WAKE_ENUM                 0x04 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D3_SLEEP_WITH_WAKE_ENUM                   0x05 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_POWER_STATE_D4_POWER_OFF_ENUM                         0x06 // Enum
+//end power state enums
+//begin deprecated power state enums
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_UNDEFINED_ENUM                 0x00 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D0_FULL_POWER_ENUM             0x01 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D1_LOW_POWER_ENUM              0x02 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D2_STANDBY_WITH_WAKE_ENUM      0x03 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D3_SLEEP_WITH_WAKE_ENUM        0x04 // Enum
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_POWER_STATE_D4_POWER_OFF_ENUM              0x05 // Enum
+//end deprecated power state enums
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_FEATURE_PAGE_COUNT                         0x0A,0x1A,0x03
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_FEATURE_PAGE_ID                            0x0A,0x1B,0x03
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_INPUT_PAGE_COUNT                           0x0A,0x1C,0x03
+#define HID_USAGE_SENSOR_PROPERTY_DEPRECATED_INPUT_PAGE_ID                              0x0A,0x1D,0x03
+
+//data type location
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_LOCATION                                                  0x0A,0x00,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_DESIRED_ACCURACY                                 0x0A,0x01,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITUDE_ANTENNA_SEALEVEL                        0x0A,0x02,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_DIFFERENTIAL_REFERENCE_STATION_ID                0x0A,0x03,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITIDE_ELIPSOID_ERROR                          0x0A,0x04,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITIDE_ELIPSOID                                0x0A,0x05,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITUDE_SEALEVEL_ERROR                          0x0A,0x06,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ALTITUDE_SEALEVEL                                0x0A,0x07,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_DGPS_DATA_AGE                                    0x0A,0x08,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ERROR_RADIUS                                     0x0A,0x09,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_FIX_QUALITY                                      0x0A,0x0A,0x04 // NAry
+//begin fix quality selectors
+#define HID_USAGE_SENSOR_DATA_FIX_QUALITY_NO_FIX                                        0x0A,0x70,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_QUALITY_GPS                                           0x0A,0x71,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_QUALITY_DGPS                                          0x0A,0x72,0x08 // Sel
+//end fix quality selectors
+#define HID_USAGE_SENSOR_DATA_LOCATION_FIX_TYPE                                         0x0A,0x0B,0x04 // NAry
+//begin fix type selectors
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_NO_FIX                                           0x0A,0x80,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_GPS_SPS_MODE_FIX_VALID                           0x0A,0x81,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_DGPS_SPS_MODE_FIX_VALID                          0x0A,0x82,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_GPS_PPS_MODE_FIX_VALID                           0x0A,0x83,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_REAL_TIME_KINEMATIC                              0x0A,0x84,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_FLOAT_RTK                                        0x0A,0x85,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_ESTIMATED_DEAD_RECKONING                         0x0A,0x86,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_MANUAL_INPUT_MODE                                0x0A,0x87,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_FIX_TYPE_SIMULATOR_MODE                                   0x0A,0x88,0x08 // Sel
+//end fix type selectors
+#define HID_USAGE_SENSOR_DATA_LOCATION_GEOIDAL_SEPARATION                               0x0A,0x0C,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_GPS_OPERATION_MODE                               0x0A,0x0D,0x04 // NAry
+//begin gps operation mode selectors
+#define HID_USAGE_SENSOR_DATA_GPS_OP_MODE_MANUAL                                        0x0A,0x90,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_OP_MODE_AUTOMATIC                                     0x0A,0x91,0x08 // Sel
+//end gps operation mode selectors
+#define HID_USAGE_SENSOR_DATA_LOCATION_GPS_SELECTION_MODE                               0x0A,0x0E,0x04 // NAry
+//begin gps selection mode selectors
+#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_AUTONOMOUS                                   0x0A,0xA0,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_DGPS                                         0x0A,0xA1,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_ESTIMATED_DEAD_RECKONING                     0x0A,0xA2,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_MANUAL_INPUT                                 0x0A,0xA3,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_SIMULATOR                                    0x0A,0xA4,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_SEL_MODE_DATA_NOT_VALID                               0x0A,0xA5,0x08 // Sel
+//end gps selection mode selectors
+#define HID_USAGE_SENSOR_DATA_LOCATION_GPS_STATUS                                       0x0A,0x0F,0x04 // NAry
+//begin gps status selectors
+#define HID_USAGE_SENSOR_DATA_GPS_STATUS_DATA_VALID                                     0x0A,0xB0,0x08 // Sel
+#define HID_USAGE_SENSOR_DATA_GPS_STATUS_DATA_NOT_VALID                                 0x0A,0xB1,0x08 // Sel
+//end gps status selectors
+#define HID_USAGE_SENSOR_DATA_LOCATION_POSITION_DILUTION_OF_PRECISION                   0x0A,0x10,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_HORIZONTAL_DILUTION_OF_PRECISION                 0x0A,0x11,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_VERTICAL_DILUTION_OF_PRECISION                   0x0A,0x12,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_LATITUDE                                         0x0A,0x13,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_LONGITUDE                                        0x0A,0x14,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_TRUE_HEADING                                     0x0A,0x15,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_MAGNETIC_HEADING                                 0x0A,0x16,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_MAGNETIC_VARIATION                               0x0A,0x17,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SPEED                                            0x0A,0x18,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW                               0x0A,0x19,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_AZIMUTH                       0x0A,0x1A,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_ELEVATION                     0x0A,0x1B,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_ID                            0x0A,0x1C,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_PRNs                          0x0A,0x1D,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_IN_VIEW_STN_RATIO                     0x0A,0x1E,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_USED_COUNT                            0x0A,0x1F,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_SATELLITES_USED_PRNs                             0x0A,0x20,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_NMEA_SENTENCE                                    0x0A,0x21,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ADDRESS_LINE_1                                   0x0A,0x22,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_ADDRESS_LINE_2                                   0x0A,0x23,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_CITY                                             0x0A,0x24,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_STATE_OR_PROVINCE                                0x0A,0x25,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_COUNTRY_OR_REGION                                0x0A,0x26,0x04
+#define HID_USAGE_SENSOR_DATA_LOCATION_POSTAL_CODE                                      0x0A,0x27,0x04
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_LOCATION                                              0x0A,0x2A,0x04
+#define HID_USAGE_SENSOR_PROPERTY_LOCATION_DESIRED_ACCURACY                             0x0A,0x2B,0x04 // NAry
+//begin location desired accuracy selectors
+#define HID_USAGE_SENSOR_DESIRED_ACCURACY_DEFAULT                                       0x0A,0x60,0x08 // Sel
+#define HID_USAGE_SENSOR_DESIRED_ACCURACY_HIGH                                          0x0A,0x61,0x08 // Sel
+#define HID_USAGE_SENSOR_DESIRED_ACCURACY_MEDIUM                                        0x0A,0x62,0x08 // Sel
+#define HID_USAGE_SENSOR_DESIRED_ACCURACY_LOW                                           0x0A,0x63,0x08 // Sel
+//end location desired accuracy selectors
+
+//data type environmental
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL                                             0x0A,0x30,0x04
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_ATMOSPHERIC_PRESSURE                        0x0A,0x31,0x04
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_REFERENCE_PRESSURE                          0x0A,0x32,0x04
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_RELATIVE_HUMIDITY                           0x0A,0x33,0x04
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_TEMPERATURE                                 0x0A,0x34,0x04
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_WIND_DIRECTION                              0x0A,0x35,0x04
+#define HID_USAGE_SENSOR_DATA_ENVIRONMENTAL_WIND_SPEED                                  0x0A,0x36,0x04
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_ENVIRONMENTAL                                         0x0A,0x40,0x04
+#define HID_USAGE_SENSOR_PROPERTY_ENVIRONMENTAL_REFERENCE_PRESSURE                      0x0A,0x41,0x04
+
+//data type motion
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_MOTION                                                    0x0A,0x50,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_STATE                                              0x0A,0x51,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION                                       0x0A,0x52,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION_X_AXIS                                0x0A,0x53,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION_Y_AXIS                                0x0A,0x54,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ACCELERATION_Z_AXIS                                0x0A,0x55,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY                                   0x0A,0x56,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY_X_AXIS                            0x0A,0x57,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY_Y_AXIS                            0x0A,0x58,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_VELOCITY_Z_AXIS                            0x0A,0x59,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION                                   0x0A,0x5A,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION_X_AXIS                            0x0A,0x5B,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION_Y_AXIS                            0x0A,0x5C,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_ANGULAR_POSITION_Z_AXIS                            0x0A,0x5D,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_SPEED                                              0x0A,0x5E,0x04
+#define HID_USAGE_SENSOR_DATA_MOTION_INTENSITY                                          0x0A,0x5F,0x04
+
+//data type orientation
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_ORIENTATION                                               0x0A,0x70,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING                              0x0A,0x71,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING_X                            0x0A,0x72,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING_Y                            0x0A,0x73,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_HEADING_Z                            0x0A,0x74,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_COMPENSATED_MAGNETIC_NORTH                    0x0A,0x75,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_COMPENSATED_TRUE_NORTH                        0x0A,0x76,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_NORTH                                0x0A,0x77,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_TRUE_NORTH                                    0x0A,0x78,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE                                      0x0A,0x79,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_X                                    0x0A,0x7A,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_Y                                    0x0A,0x7B,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_Z                                    0x0A,0x7C,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_DISTANCE_OUT_OF_RANGE                         0x0A,0x7D,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT                                          0x0A,0x7E,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT_X                                        0x0A,0x7F,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT_Y                                        0x0A,0x80,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_TILT_Z                                        0x0A,0x81,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_ROTATION_MATRIX                               0x0A,0x82,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_QUATERNION                                    0x0A,0x83,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX                                 0x0A,0x84,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX_X_AXIS                          0x0A,0x85,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX_Y_AXIS                          0x0A,0x86,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETIC_FLUX_Z_AXIS                          0x0A,0x87,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY                             0x0A,0x88,0x04
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY_LOW                         0x0A,0xE0,0x08
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY_MEDIUM                      0x0A,0xE1,0x08
+#define HID_USAGE_SENSOR_DATA_ORIENTATION_MAGNETOMETER_ACCURACY_HIGH                        0x0A,0xE2,0x08
+
+//data type mechanical
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_MECHANICAL                                                0x0A,0x90,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_BOOLEAN_SWITCH_STATE                           0x0A,0x91,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_BOOLEAN_SWITCH_ARRAY_STATES                    0x0A,0x92,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_MULTIVALUE_SWITCH_VALUE                        0x0A,0x93,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_FORCE                                          0x0A,0x94,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_ABSOLUTE_PRESSURE                              0x0A,0x95,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_GAUGE_PRESSURE                                 0x0A,0x96,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_STRAIN                                         0x0A,0x97,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_WEIGHT                                         0x0A,0x98,0x04
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_MECHANICAL                                            0x0A,0xA0,0x04
+#define HID_USAGE_SENSOR_PROPERTY_MECHANICAL_VIBRATION_STATE                            0x0A,0xA1,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_VIBRATION_SPEED_FORWARD                        0x0A,0xA2,0x04
+#define HID_USAGE_SENSOR_DATA_MECHANICAL_VIBRATION_SPEED_BACKWARD                       0x0A,0xA3,0x04
+
+//data type biometric
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_BIOMETRIC                                                 0x0A,0xB0,0x04
+#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_PRESENCE                                  0x0A,0xB1,0x04
+#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_PROXIMITY_RANGE                           0x0A,0xB2,0x04
+#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_PROXIMITY_OUT_OF_RANGE                    0x0A,0xB3,0x04
+#define HID_USAGE_SENSOR_DATA_BIOMETRIC_HUMAN_TOUCH_STATE                               0x0A,0xB4,0x04
+
+//data type light sensor
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_LIGHT                                                     0x0A,0xD0,0x04
+#define HID_USAGE_SENSOR_DATA_LIGHT_ILLUMINANCE                                         0x0A,0xD1,0x04
+#define HID_USAGE_SENSOR_DATA_LIGHT_COLOR_TEMPERATURE                                   0x0A,0xD2,0x04
+#define HID_USAGE_SENSOR_DATA_LIGHT_CHROMATICITY                                        0x0A,0xD3,0x04
+#define HID_USAGE_SENSOR_DATA_LIGHT_CHROMATICITY_X                                      0x0A,0xD4,0x04
+#define HID_USAGE_SENSOR_DATA_LIGHT_CHROMATICITY_Y                                      0x0A,0xD5,0x04
+#define HID_USAGE_SENSOR_DATA_LIGHT_CONSUMER_IR_SENTENCE_RECEIVE                        0x0A,0xD6,0x04
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_LIGHT                                                 0x0A,0xE0,0x04
+#define HID_USAGE_SENSOR_PROPERTY_LIGHT_CONSUMER_IR_SENTENCE_SEND                       0x0A,0xE1,0x04
+
+//data type scanner
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_SCANNER                                                   0x0A,0xF0,0x04
+#define HID_USAGE_SENSOR_DATA_SCANNER_RFID_TAG                                          0x0A,0xF1,0x04
+#define HID_USAGE_SENSOR_DATA_SCANNER_NFC_SENTENCE_RECEIVE                              0x0A,0xF2,0x04
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_SCANNER                                               0x0A,0xF8,0x04
+#define HID_USAGE_SENSOR_PROPERTY_SCANNER_NFC_SENTENCE_SEND                             0x0A,0xF9,0x04
+
+//data type electrical
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL                                                0x0A,0x00,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_CAPACITANCE                                    0x0A,0x01,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_CURRENT                                        0x0A,0x02,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_POWER                                          0x0A,0x03,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_INDUCTANCE                                     0x0A,0x04,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_RESISTANCE                                     0x0A,0x05,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_VOLTAGE                                        0x0A,0x06,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_FREQUENCY                                      0x0A,0x07,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_PERIOD                                         0x0A,0x08,0x05
+#define HID_USAGE_SENSOR_DATA_ELECTRICAL_PERCENT_OF_RANGE                               0x0A,0x09,0x05
+
+//data type time
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_TIME                                                      0x0A,0x20,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_YEAR                                                 0x0A,0x21,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_MONTH                                                0x0A,0x22,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_DAY                                                  0x0A,0x23,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_DAY_OF_WEEK                                          0x0A,0x24,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_HOUR                                                 0x0A,0x25,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_MINUTE                                               0x0A,0x26,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_SECOND                                               0x0A,0x27,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_MILLISECOND                                          0x0A,0x28,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_TIMESTAMP                                            0x0A,0x29,0x05
+#define HID_USAGE_SENSOR_DATA_TIME_JULIAN_DAY_OF_YEAR                                   0x0A,0x2A,0x05
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_TIME                                                  0x0A,0x30,0x05
+#define HID_USAGE_SENSOR_PROPERTY_TIME_TIME_ZONE_OFFSET_FROM_UTC                        0x0A,0x31,0x05
+#define HID_USAGE_SENSOR_PROPERTY_TIME_TIME_ZONE_NAME                                   0x0A,0x32,0x05
+#define HID_USAGE_SENSOR_PROPERTY_TIME_DAYLIGHT_SAVINGS_TIME_OBSERVED                   0x0A,0x33,0x05
+#define HID_USAGE_SENSOR_PROPERTY_TIME_TIME_TRIM_ADJUSTMENT                             0x0A,0x34,0x05
+#define HID_USAGE_SENSOR_PROPERTY_TIME_ARM_ALARM                                        0x0A,0x35,0x05
+
+//data type custom
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_CUSTOM                                                    0x0A,0x40,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_USAGE                                              0x0A,0x41,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_BOOLEAN_ARRAY                                      0x0A,0x42,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE                                              0x0A,0x43,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_1                                            0x0A,0x44,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_2                                            0x0A,0x45,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_3                                            0x0A,0x46,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_4                                            0x0A,0x47,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_5                                            0x0A,0x48,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_6                                            0x0A,0x49,0x05
+
+#if 1 //define vendor-specific (non-spec) custom datafields
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_7                                            0x0A,0x4A,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_8                                            0x0A,0x4B,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_9                                            0x0A,0x4C,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_10                                           0x0A,0x4D,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_11                                           0x0A,0x4E,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_12                                           0x0A,0x4F,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_13                                           0x0A,0x50,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_14                                           0x0A,0x51,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_15                                           0x0A,0x52,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_16                                           0x0A,0x53,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_17                                           0x0A,0x54,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_18                                           0x0A,0x55,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_19                                           0x0A,0x56,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_20                                           0x0A,0x57,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_21                                           0x0A,0x58,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_22                                           0x0A,0x59,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_23                                           0x0A,0x5A,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_24                                           0x0A,0x5B,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_25                                           0x0A,0x5C,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_26                                           0x0A,0x5D,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_27                                           0x0A,0x5E,0x05
+#define HID_USAGE_SENSOR_DATA_CUSTOM_VALUE_28                                           0x0A,0x5F,0x05
+#endif
+
+//data type generic
+//data field usages (input report)
+#define HID_USAGE_SENSOR_DATA_GENERIC                                                   0x0A,0x60,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_GUID_OR_PROPERTYKEY                               0x0A,0x61,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_CATEGORY_GUID                                     0x0A,0x62,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_TYPE_GUID                                         0x0A,0x63,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_EVENT_PROPERTYKEY                                 0x0A,0x64,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_PROPERTY_PROPERTYKEY                              0x0A,0x65,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_DATAFIELD_PROPERTYKEY                             0x0A,0x66,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_EVENT                                             0x0A,0x67,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_PROPERTY                                          0x0A,0x68,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_DATAFIELD                                         0x0A,0x69,0x05
+#define HID_USAGE_SENSOR_DATA_ENUMERATOR_TABLE_ROW_INDEX                                0x0A,0x6A,0x05
+#define HID_USAGE_SENSOR_DATA_ENUMERATOR_TABLE_ROW_COUNT                                0x0A,0x6B,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_GUID_OR_PROPERTYKEY_KIND                          0x0A,0x6C,0x05 // NAry
+//begin GorPK kind selectors
+#define HID_USAGE_SENSOR_GORPK_KIND_CATEGORY                                            0x0A,0xD0,0x08 // Sel
+#define HID_USAGE_SENSOR_GORPK_KIND_TYPE                                                0x0A,0xD1,0x08 // Sel
+#define HID_USAGE_SENSOR_GORPK_KIND_EVENT                                               0x0A,0xD2,0x08 // Sel
+#define HID_USAGE_SENSOR_GORPK_KIND_PROPERTY                                            0x0A,0xD3,0x08 // Sel
+#define HID_USAGE_SENSOR_GORPK_KIND_DATAFIELD                                           0x0A,0xD4,0x08 // Sel
+//end GorPK kind selectors
+#define HID_USAGE_SENSOR_DATA_GENERIC_GUID                                              0x0A,0x6D,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_PROPERTYKEY                                       0x0A,0x6E,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_TOP_LEVEL_COLLECTION_ID                           0x0A,0x6F,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_ID                                         0x0A,0x70,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_ITEM_POSITION_INDEX                        0x0A,0x71,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_FIRMWARE_VARTYPE                                  0x0A,0x72,0x05 // NAry
+//begin firmware vartype selectors
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_NULL                                       0x0A,0x00,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_BOOL                                       0x0A,0x01,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI1                                        0x0A,0x02,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I1                                         0x0A,0x03,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI2                                        0x0A,0x04,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I2                                         0x0A,0x05,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI4                                        0x0A,0x06,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I4                                         0x0A,0x07,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_UI8                                        0x0A,0x08,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_I8                                         0x0A,0x09,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_R4                                         0x0A,0x0A,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_R8                                         0x0A,0x0B,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_WSTR                                       0x0A,0x0C,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_STR                                        0x0A,0x0D,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_CLSID                                      0x0A,0x0E,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_VECTOR_VT_UI1                              0x0A,0x0F,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E0                                      0x0A,0x10,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E1                                      0x0A,0x11,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E2                                      0x0A,0x12,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E3                                      0x0A,0x13,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E4                                      0x0A,0x14,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E5                                      0x0A,0x15,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E6                                      0x0A,0x16,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E7                                      0x0A,0x17,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E8                                      0x0A,0x18,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16E9                                      0x0A,0x19,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EA                                      0x0A,0x1A,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EB                                      0x0A,0x1B,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EC                                      0x0A,0x1C,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16ED                                      0x0A,0x1D,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EE                                      0x0A,0x1E,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F16EF                                      0x0A,0x1F,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E0                                      0x0A,0x20,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E1                                      0x0A,0x21,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E2                                      0x0A,0x22,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E3                                      0x0A,0x23,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E4                                      0x0A,0x24,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E5                                      0x0A,0x25,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E6                                      0x0A,0x26,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E7                                      0x0A,0x27,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E8                                      0x0A,0x28,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32E9                                      0x0A,0x29,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EA                                      0x0A,0x2A,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EB                                      0x0A,0x2B,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EC                                      0x0A,0x2C,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32ED                                      0x0A,0x2D,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EE                                      0x0A,0x2E,0x09 // Sel
+#define HID_USAGE_SENSOR_FIRMWARE_VARTYPE_VT_F32EF                                      0x0A,0x2F,0x09 // Sel
+//end firmware vartype selectors
+#define HID_USAGE_SENSOR_DATA_GENERIC_UNIT_OF_MEASURE                                   0x0A,0x73,0x05 // NAry
+//begin unit of measure selectors
+#define HID_USAGE_SENSOR_GENERIC_UNIT_NOT_SPECIFIED                                     0x0A,0x40,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_LUX                                               0x0A,0x41,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_KELVIN                                    0x0A,0x42,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_CELSIUS                                   0x0A,0x43,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_PASCAL                                            0x0A,0x44,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_NEWTON                                            0x0A,0x45,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_METERS_PER_SECOND                                 0x0A,0x46,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_KILOGRAM                                          0x0A,0x47,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_METER                                             0x0A,0x48,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_METERS_PER_SEC_SQRD                               0x0A,0x49,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_FARAD                                             0x0A,0x4A,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_AMPERE                                            0x0A,0x4B,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_WATT                                              0x0A,0x4C,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_HENRY                                             0x0A,0x4D,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_OHM                                               0x0A,0x4E,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_VOLT                                              0x0A,0x4F,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_HERTZ                                             0x0A,0x50,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_BAR                                               0x0A,0x51,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_ANTI_CLOCKWISE                            0x0A,0x52,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_CLOCKWISE                                 0x0A,0x53,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES                                           0x0A,0x54,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_PER_SECOND                                0x0A,0x55,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_DEGREES_PER_SEC_SQRD                              0x0A,0x56,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_KNOT                                              0x0A,0x57,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_PERCENT                                           0x0A,0x58,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_SECOND                                            0x0A,0x59,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_MILLISECOND                                       0x0A,0x5A,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_G                                                 0x0A,0x5B,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_BYTES                                             0x0A,0x5C,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_MILLIGAUSS                                        0x0A,0x5D,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_UNIT_BITS                                              0x0A,0x5E,0x09 // Sel
+//end unit of measure selectors
+#define HID_USAGE_SENSOR_DATA_GENERIC_UNIT_EXPONENT                                     0x0A,0x74,0x05 // NAry
+//begin unit exponent selectors
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_0                                             0x0A,0x70,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_1                                             0x0A,0x71,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_2                                             0x0A,0x72,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_3                                             0x0A,0x73,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_4                                             0x0A,0x74,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_5                                             0x0A,0x75,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_6                                             0x0A,0x76,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_7                                             0x0A,0x77,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_8                                             0x0A,0x78,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_9                                             0x0A,0x79,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_A                                             0x0A,0x7A,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_B                                             0x0A,0x7B,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_C                                             0x0A,0x7C,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_D                                             0x0A,0x7D,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_E                                             0x0A,0x7E,0x09 // Sel
+#define HID_USAGE_SENSOR_GENERIC_EXPONENT_F                                             0x0A,0x7F,0x09 // Sel
+//end unit exponent selectors
+#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_SIZE                                       0x0A,0x75,0x05
+#define HID_USAGE_SENSOR_DATA_GENERIC_REPORT_COUNT                                      0x0A,0x76,0x05
+//property usages (get/set feature report)
+#define HID_USAGE_SENSOR_PROPERTY_GENERIC                                               0x0A,0x80,0x05
+#define HID_USAGE_SENSOR_PROPERTY_ENUMERATOR_TABLE_ROW_INDEX                            0x0A,0x81,0x05
+#define HID_USAGE_SENSOR_PROPERTY_ENUMERATOR_TABLE_ROW_COUNT                            0x0A,0x82,0x05
+
+
+////////////////////////////////////////////////////////////////////////////////////
+//
+// Other HID definitions
+//
+////////////////////////////////////////////////////////////////////////////////////
+
+//NOTE: These definitions are designed to permit compiling the HID report descriptors
+// with somewhat self-explanatory information to help readability and reduce errors
+
+//input,output,feature flags
+#define Data_Arr_Abs                            0x00
+#define Const_Arr_Abs                           0x01
+#define Data_Var_Abs                            0x02
+#define Const_Var_Abs                           0x03
+#define Data_Var_Rel                            0x06
+//collection flags
+#define Physical                                0x00
+#define Application                             0x01
+#define Logical                                 0x02
+#define NamedArray                              0x04
+#define UsageSwitch                             0x05
+//other
+#define Undefined                               0x00
+
+#define HID_USAGE_PAGE(a)                       0x05,a
+#define HID_USAGE(a)                            0x09,a
+#define HID_USAGE16(a,b)                        0x0A,a,b
+#define HID_USAGE_SENSOR_DATA(a,b)              a|b     //This or-s the mod into usage
+#define HID_COLLECTION(a)                       0xA1,a
+#define HID_REPORT_ID(a)                        0x85,a
+#define HID_REPORT_SIZE(a)                      0x75,a
+#define HID_REPORT_COUNT(a)                     0x95,a
+#define HID_USAGE_MIN_8(a)                      0x19,a
+#define HID_USAGE_MIN_16(a,b)                   0x1A,a,b
+#define HID_USAGE_MAX_8(a)                      0x29,a
+#define HID_USAGE_MAX_16(a,b)                   0x2A,a,b
+#define HID_LOGICAL_MIN_8(a)                    0x15,a
+#define HID_LOGICAL_MIN_16(a,b)                 0x16,a,b
+#define HID_LOGICAL_MIN_32(a,b,c,d)             0x17,a,b,c,d
+#define HID_LOGICAL_MAX_8(a)                    0x25,a
+#define HID_LOGICAL_MAX_16(a,b)                 0x26,a,b
+#define HID_LOGICAL_MAX_32(a,b,c,d)             0x27,a,b,c,d
+#define HID_UNIT_EXPONENT(a)                    0x55,a
+#define HID_INPUT(a)                            0x81,a
+#define HID_OUTPUT(a)                           0x91,a
+#define HID_FEATURE(a)                          0xB1,a
+#define HID_END_COLLECTION                      0xC0
+
+#endif // HIDUTIL_TEST_HIDSENSORSPEC_H

modules/sensors/dynamic_sensor/HidUtils/test/TriStateTest.cpp

@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2017 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 "TriState.h"
+#include <gtest/gtest.h>
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <iostream>
+
+using HidUtil::TriState;
+typedef TriState<uint32_t> tri_uint32_t;
+typedef TriState<int32_t> tri_int32_t;
+typedef TriState<int16_t> tri_int16_t;
+
+TEST(TriStateTest, Constructor) {
+    tri_uint32_t a;
+    EXPECT_FALSE(a.isSet());
+
+    a += 1;
+    EXPECT_FALSE(a.isSet());
+
+    a -= 1;
+    EXPECT_FALSE(a.isSet());
+
+    a *= 1;
+    EXPECT_FALSE(a.isSet());
+
+    a /= 1;
+    EXPECT_FALSE(a.isSet());
+
+    tri_uint32_t b;
+    b = a;
+    EXPECT_FALSE(b.isSet());
+
+    a = 1;
+    EXPECT_TRUE(a.isSet());
+
+    b = a;
+    EXPECT_TRUE(b.isSet());
+
+    a.clear();
+    EXPECT_FALSE(a.isSet());
+    EXPECT_TRUE(b.isSet());
+
+    tri_uint32_t c(b);
+    EXPECT_TRUE(c.isSet());
+
+    c.clear();
+    EXPECT_FALSE(c.isSet());
+
+    tri_uint32_t d(a);
+    EXPECT_FALSE(c.isSet());
+}
+
+TEST(TriStateTest, IncAndDecOperation) {
+    tri_int32_t a(1);
+
+    EXPECT_EQ(2, (++a).get(0));
+    EXPECT_EQ(2, (a++).get(0));
+    EXPECT_EQ(3, a.get(0));
+
+    EXPECT_EQ(2, (--a).get(0));
+    EXPECT_EQ(2, (a--).get(0));
+    EXPECT_EQ(1, a.get(0));
+
+    tri_uint32_t b;
+    EXPECT_EQ(static_cast<uint32_t>(100), (++b).get(100));
+    EXPECT_EQ(static_cast<uint32_t>(101), (b++).get(101));
+    EXPECT_EQ(static_cast<uint32_t>(102), b.get(102));
+    EXPECT_FALSE(b.isSet());
+
+    EXPECT_EQ(static_cast<uint32_t>(103), (--b).get(103));
+    EXPECT_EQ(static_cast<uint32_t>(104), (b--).get(104));
+    EXPECT_EQ(static_cast<uint32_t>(105), b.get(105));
+    EXPECT_FALSE(b.isSet());
+}
+
+TEST(TriStateTest, Comparison) {
+    tri_int32_t a(1);
+    tri_int32_t b(1);
+    tri_int32_t c(2);
+    tri_int32_t d;
+
+    EXPECT_EQ(a, b);
+    EXPECT_FALSE((a != b));
+    EXPECT_TRUE(!(a != b));
+    EXPECT_NE(-1, a);
+
+    EXPECT_LT(a, c);
+    EXPECT_LT(a, 3);
+
+    EXPECT_GT(c, b);
+    EXPECT_GT(c, 0);
+
+    EXPECT_LE(a, 1);
+    EXPECT_LE(a, c);
+    EXPECT_LE(a, 3);
+    EXPECT_LE(a, b);
+
+    EXPECT_GE(c, b);
+    EXPECT_GE(b, a);
+    EXPECT_GE(c, 0);
+    EXPECT_GE(c, 2);
+
+    EXPECT_FALSE((a == d).isSet());
+    EXPECT_FALSE((a >= d).isSet());
+    EXPECT_FALSE((a <= d).isSet());
+    EXPECT_FALSE((a != d).isSet());
+    EXPECT_FALSE((a > d).isSet());
+    EXPECT_FALSE((a < d).isSet());
+
+    //EXPECT_EQ(a, d); // will cause runtime failure
+    // due to converting a not-set TriState<bool> to bool
+}
+
+TEST(TriStateTest, CompoundAssign) {
+    tri_uint32_t x;
+
+    x += 10;
+    EXPECT_FALSE(x.isSet());
+    x -= 10;
+    EXPECT_FALSE(x.isSet());
+    x *= 10;
+    EXPECT_FALSE(x.isSet());
+    x /= 10;
+    EXPECT_FALSE(x.isSet());
+    x &= 10;
+    EXPECT_FALSE(x.isSet());
+    x |= 10;
+    EXPECT_FALSE(x.isSet());
+    x %= 10;
+    EXPECT_FALSE(x.isSet());
+    x <<= 10;
+    EXPECT_FALSE(x.isSet());
+    x >>= 10;
+    EXPECT_FALSE(x.isSet());
+
+    tri_int32_t y, z, w;
+#define TEST_COMPOUND_ASSIGN(a, op, op_c, b) \
+    y = z = a; \
+    w = b; \
+    y op_c b; \
+    EXPECT_TRUE(y.isSet()); \
+    EXPECT_EQ(y, (a op b)); \
+    EXPECT_EQ(y, (z op b)); \
+    EXPECT_EQ(y, (a op w));
+
+    TEST_COMPOUND_ASSIGN(123, +, +=, 456);
+    TEST_COMPOUND_ASSIGN(123, -, -=, 456);
+    TEST_COMPOUND_ASSIGN(123, *, *=, 456);
+    TEST_COMPOUND_ASSIGN(123, /, /=, 456);
+    TEST_COMPOUND_ASSIGN(123, |, |=, 456);
+    TEST_COMPOUND_ASSIGN(123, &, &=, 456);
+    TEST_COMPOUND_ASSIGN(123, ^, ^=, 456);
+    TEST_COMPOUND_ASSIGN(123, %, %=, 456);
+#undef TEST_COMPOUND_ASSIGN
+    y = z = 123;
+    w = 10;
+    y <<= 10;
+    EXPECT_TRUE(y.isSet());
+    EXPECT_EQ(123 << 10, y);
+
+    y = z = 12345;
+    w = 10;
+    y >>= 10;
+    EXPECT_TRUE(y.isSet());
+    EXPECT_EQ(12345 >> 10, y);
+}
+
+TEST(TriStateTest, UnaryOperation) {
+    tri_int16_t p;
+    EXPECT_FALSE((!p).isSet());
+    EXPECT_FALSE((-p).isSet());
+    EXPECT_FALSE((~p).isSet());
+
+    tri_int16_t q(1234);
+    EXPECT_TRUE((!q).isSet());
+    EXPECT_EQ(!static_cast<int16_t>(1234), (!q));
+
+    tri_int16_t r(1234);
+    EXPECT_TRUE((-r).isSet());
+    EXPECT_EQ(-1234, (-r));
+
+    tri_int16_t s(1234);
+    EXPECT_TRUE((~s).isSet());
+    EXPECT_EQ(~static_cast<int16_t>(1234), ~s);
+}
+