From 6fa82480aeb702ca60bc20d5c8df3c4a62904e3b Mon Sep 17 00:00:00 2001
From: Tim Kilbourn <tkilbourn@google.com>
Date: Mon, 6 Apr 2015 13:49:40 -0700
Subject: Add input HAL methods for getting device properties.

A property map holds the collection of the properties for a given
device identifier. HAL modules allocate and release these property maps
to control the lifetime of the data. The host will typically open and
read the corresponding idc file on allocation, and release these
resources when it is freed.

Change-Id: Ia13ec7b7abf1a79eeed87dc744c174a37f1fb8a9
---
 modules/input/evdev/InputHost.cpp | 26 +++++++++++++++++
 modules/input/evdev/InputHost.h   | 59 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+)

(limited to 'modules')

diff --git a/modules/input/evdev/InputHost.cpp b/modules/input/evdev/InputHost.cpp
index 0903f47..6a65fcd 100644
--- a/modules/input/evdev/InputHost.cpp
+++ b/modules/input/evdev/InputHost.cpp
@@ -47,6 +47,27 @@ void InputDeviceDefinition::addReport(InputReportDefinition r) {
     mCallbacks.input_device_definition_add_report(mHost, mDeviceDefinition, r);
 }
 
+InputProperty::~InputProperty() {
+    mCallbacks.input_free_device_property(mHost, mProperty);
+}
+
+const char* InputProperty::getKey() {
+    return mCallbacks.input_get_property_key(mHost, mProperty);
+}
+
+const char* InputProperty::getValue() {
+    return mCallbacks.input_get_property_value(mHost, mProperty);
+}
+
+InputPropertyMap::~InputPropertyMap() {
+    mCallbacks.input_free_device_property_map(mHost, mMap);
+}
+
+InputProperty InputPropertyMap::getDeviceProperty(const char* key) {
+    return InputProperty(mHost, mCallbacks,
+            mCallbacks.input_get_device_property(mHost, mMap, key));
+}
+
 InputDeviceIdentifier InputHost::createDeviceIdentifier(const char* name, int32_t productId,
         int32_t vendorId, InputBus bus, const char* uniqueId) {
     return mCallbacks.create_device_identifier(mHost, name, productId, vendorId, bus, uniqueId);
@@ -75,4 +96,9 @@ void InputHost::unregisterDevice(InputDeviceHandle handle) {
     return mCallbacks.unregister_device(mHost, handle);
 }
 
+InputPropertyMap InputHost::getDevicePropertyMap(InputDeviceIdentifier id) {
+    return InputPropertyMap(mHost, mCallbacks,
+            mCallbacks.input_get_device_property_map(mHost, id));
+}
+
 }  // namespace android
diff --git a/modules/input/evdev/InputHost.h b/modules/input/evdev/InputHost.h
index 129443e..98ce26f 100644
--- a/modules/input/evdev/InputHost.h
+++ b/modules/input/evdev/InputHost.h
@@ -17,6 +17,8 @@
 #ifndef ANDROID_INPUT_HOST_H_
 #define ANDROID_INPUT_HOST_H_
 
+#include <memory>
+
 #include <hardware/input.h>
 
 namespace android {
@@ -109,6 +111,61 @@ private:
     input_device_definition_t* mDeviceDefinition;
 };
 
+class InputProperty : private InputHostBase {
+public:
+    virtual ~InputProperty();
+
+    operator input_property_t*() { return mProperty; }
+
+    const char* getKey();
+    const char* getValue();
+
+    // Default move constructor transfers ownership of the input_property_t
+    // pointer.
+    InputProperty(InputProperty&& rhs) = default;
+
+    // Prevent copy/assign because of the ownership of the underlying
+    // input_property_t pointer.
+    InputProperty(const InputProperty& rhs) = delete;
+    InputProperty& operator=(const InputProperty& rhs) = delete;
+
+private:
+    friend class InputPropertyMap;
+
+    InputProperty(
+            input_host_t* host, input_host_callbacks_t cb, input_property_t* p) :
+        InputHostBase(host, cb), mProperty(p) {}
+
+    input_property_t* mProperty;
+};
+
+class InputPropertyMap : private InputHostBase {
+public:
+    virtual ~InputPropertyMap();
+
+    operator input_property_map_t*() { return mMap; }
+
+    InputProperty getDeviceProperty(const char* key);
+
+    // Default move constructor transfers ownership of the input_property_map_t
+    // pointer.
+    InputPropertyMap(InputPropertyMap&& rhs) = default;
+
+    // Prevent copy/assign because of the ownership of the underlying
+    // input_property_map_t pointer.
+    InputPropertyMap(const InputPropertyMap& rhs) = delete;
+    InputPropertyMap& operator=(const InputPropertyMap& rhs) = delete;
+
+private:
+    friend class InputHost;
+
+    InputPropertyMap(
+            input_host_t* host, input_host_callbacks_t cb, input_property_map_t* m) :
+        InputHostBase(host, cb), mMap(m) {}
+
+    input_property_map_t* mMap;
+};
+
 class InputHost : private InputHostBase {
 public:
     InputHost(input_host_t* host, input_host_callbacks_t cb) : InputHostBase(host, cb) {}
@@ -126,6 +183,8 @@ public:
 
     InputDeviceHandle registerDevice(InputDeviceIdentifier id, InputDeviceDefinition d);
     void unregisterDevice(InputDeviceHandle handle);
+
+    InputPropertyMap getDevicePropertyMap(InputDeviceIdentifier id);
 };
 
 }  // namespace android
-- 
cgit v1.1