blob: d6573d27215c04b6f3d7ba107c9b66b8c46ce8af [file] [log] [blame]
* Copyright (C) 2015 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#include <memory>
#include <hardware/input.h>
namespace android {
* Classes in this file wrap the corresponding interfaces in the Input HAL. They
* are intended to be lightweight, as they primarily wrap pointers to callbacks.
* It is still important not to use an object after a HAL-specific method has
* freed the underlying representation.
* See hardware/input.h for details about each of these methods.
using InputBus = input_bus_t;
using InputCollectionId = input_collection_id_t;
using InputDeviceHandle = input_device_handle_t;
using InputDeviceIdentifier = input_device_identifier_t;
using InputUsage = input_usage_t;
class InputHostBase {
InputHostBase(input_host_t* host, input_host_callbacks_t cb) : mHost(host), mCallbacks(cb) {}
virtual ~InputHostBase() = default;
InputHostBase(const InputHostBase& rhs) = delete;
InputHostBase(InputHostBase&& rhs) = delete;
input_host_t* mHost;
input_host_callbacks_t mCallbacks;
class InputReport : private InputHostBase {
InputReport(input_host_t* host, input_host_callbacks_t cb, input_report_t* r) :
InputHostBase(host, cb), mReport(r) {}
virtual ~InputReport() = default;
virtual void setIntUsage(InputCollectionId id, InputUsage usage, int32_t value,
int32_t arityIndex);
virtual void setBoolUsage(InputCollectionId id, InputUsage usage, bool value,
int32_t arityIndex);
virtual void reportEvent(InputDeviceHandle* d);
operator input_report_t*() const { return mReport; }
InputReport(const InputReport& rhs) = delete;
InputReport& operator=(const InputReport& rhs) = delete;
input_report_t* mReport;
class InputReportDefinition : private InputHostBase {
InputReportDefinition(input_host_t* host, input_host_callbacks_t cb,
input_report_definition_t* r) : InputHostBase(host, cb), mReportDefinition(r) {}
virtual ~InputReportDefinition() = default;
virtual void addCollection(InputCollectionId id, int32_t arity);
virtual void declareUsage(InputCollectionId id, InputUsage usage, int32_t min, int32_t max,
float resolution);
virtual void declareUsages(InputCollectionId id, InputUsage* usage, size_t usageCount);
virtual InputReport* allocateReport();
operator input_report_definition_t*() { return mReportDefinition; }
InputReportDefinition(const InputReportDefinition& rhs) = delete;
InputReportDefinition& operator=(const InputReportDefinition& rhs) = delete;
input_report_definition_t* mReportDefinition;
class InputDeviceDefinition : private InputHostBase {
InputDeviceDefinition(input_host_t* host, input_host_callbacks_t cb,
input_device_definition_t* d) :
InputHostBase(host, cb), mDeviceDefinition(d) {}
virtual ~InputDeviceDefinition() = default;
virtual void addReport(InputReportDefinition* r);
operator input_device_definition_t*() { return mDeviceDefinition; }
InputDeviceDefinition(const InputDeviceDefinition& rhs) = delete;
InputDeviceDefinition& operator=(const InputDeviceDefinition& rhs) = delete;
input_device_definition_t* mDeviceDefinition;
class InputProperty : private InputHostBase {
virtual ~InputProperty() = default;
InputProperty(input_host_t* host, input_host_callbacks_t cb, input_property_t* p) :
InputHostBase(host, cb), mProperty(p) {}
virtual const char* getKey() const;
virtual const char* getValue() const;
operator input_property_t*() { return mProperty; }
InputProperty(const InputProperty& rhs) = delete;
InputProperty& operator=(const InputProperty& rhs) = delete;
input_property_t* mProperty;
class InputPropertyMap : private InputHostBase {
virtual ~InputPropertyMap() = default;
InputPropertyMap(input_host_t* host, input_host_callbacks_t cb, input_property_map_t* m) :
InputHostBase(host, cb), mMap(m) {}
virtual InputProperty* getDeviceProperty(const char* key) const;
virtual void freeDeviceProperty(InputProperty* property) const;
operator input_property_map_t*() { return mMap; }
InputPropertyMap(const InputPropertyMap& rhs) = delete;
InputPropertyMap& operator=(const InputPropertyMap& rhs) = delete;
input_property_map_t* mMap;
class InputHostInterface {
virtual ~InputHostInterface() = default;
virtual InputDeviceIdentifier* createDeviceIdentifier(const char* name, int32_t productId,
int32_t vendorId, InputBus bus, const char* uniqueId) = 0;
virtual InputDeviceDefinition* createDeviceDefinition() = 0;
virtual InputReportDefinition* createInputReportDefinition() = 0;
virtual InputReportDefinition* createOutputReportDefinition() = 0;
virtual void freeReportDefinition(InputReportDefinition* reportDef) = 0;
virtual InputDeviceHandle* registerDevice(InputDeviceIdentifier* id,
InputDeviceDefinition* d) = 0;
virtual void unregisterDevice(InputDeviceHandle* handle) = 0;
virtual InputPropertyMap* getDevicePropertyMap(InputDeviceIdentifier* id) = 0;
virtual void freeDevicePropertyMap(InputPropertyMap* propertyMap) = 0;
class InputHost : public InputHostInterface, private InputHostBase {
InputHost(input_host_t* host, input_host_callbacks_t cb) : InputHostBase(host, cb) {}
virtual ~InputHost() = default;
InputDeviceIdentifier* createDeviceIdentifier(const char* name, int32_t productId,
int32_t vendorId, InputBus bus, const char* uniqueId) override;
InputDeviceDefinition* createDeviceDefinition() override;
InputReportDefinition* createInputReportDefinition() override;
InputReportDefinition* createOutputReportDefinition() override;
virtual void freeReportDefinition(InputReportDefinition* reportDef) override;
InputDeviceHandle* registerDevice(InputDeviceIdentifier* id, InputDeviceDefinition* d) override;
void unregisterDevice(InputDeviceHandle* handle) override;
InputPropertyMap* getDevicePropertyMap(InputDeviceIdentifier* id) override;
void freeDevicePropertyMap(InputPropertyMap* propertyMap) override;
InputHost(const InputHost& rhs) = delete;
InputHost& operator=(const InputHost& rhs) = delete;
} // namespace android