Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2e7f0146 authored by Tim Kilbourn's avatar Tim Kilbourn
Browse files

Refactor InputHost and InputDriver 

The host implementation of the HAL interface is largely done by the
InputDriver, so have it implement the opaque input_host_t type rather
than the InputHost itself. This allows the HAL interface to cast the
input_host_t pointer to an InputDriver pointer in order to implement
the host functionality.

Change-Id: I72de1e90eb6ee5e346c15707b8a6b793005bbccb
parent 4aa427b9

services/inputflinger/host/InputDriver.cpp

+207 −83
Original line number Diff line number Diff line
@@ -35,48 +35,6 @@ 


#define INDENT2 "    "



namespace android {



static input_host_callbacks_t kCallbacks = {

    .create_device_identifier = create_device_identifier,

    .create_device_definition = create_device_definition,

    .create_input_report_definition = create_input_report_definition,

    .create_output_report_definition = create_output_report_definition,

    .free_report_definition = free_report_definition,

    .input_device_definition_add_report = input_device_definition_add_report,

    .input_report_definition_add_collection = input_report_definition_add_collection,

    .input_report_definition_declare_usage_int = input_report_definition_declare_usage_int,

    .input_report_definition_declare_usages_bool = input_report_definition_declare_usages_bool,

    .register_device = register_device,

    .input_allocate_report = input_allocate_report,

    .input_report_set_usage_int = input_report_set_usage_int,

    .input_report_set_usage_bool = input_report_set_usage_bool,

    .report_event = report_event,

    .input_get_device_property_map = input_get_device_property_map,

    .input_get_device_property = input_get_device_property,

    .input_get_property_key = input_get_property_key,

    .input_get_property_value = input_get_property_value,

    .input_free_device_property = input_free_device_property,

    .input_free_device_property_map = input_free_device_property_map,

};



InputDriver::InputDriver(const char* name) : mName(String8(name)) {

    const hw_module_t* module;

    int err = input_open(&module, name);

    LOG_ALWAYS_FATAL_IF(err != 0, "Input module %s not found", name);

    mHal = reinterpret_cast<const input_module_t*>(module);

}



void InputDriver::init(InputHostInterface* host) {

    mHal->init(mHal, static_cast<input_host_t*>(host), kCallbacks);

}



void InputDriver::dump(String8& result) {

    result.appendFormat(INDENT2 "HAL Input Driver (%s)\n", mName.string());

}



} // namespace android



struct input_property_map {

    android::PropertyMap* propertyMap;

};
@@ -127,92 +85,130 @@ struct input_report_definition { 
    std::unordered_map<input_collection_id_t, input_collection, InputCollectionIdHasher> collections;

};



// HAL wrapper functions



namespace android {



::input_device_identifier_t* create_device_identifier(input_host_t* host,

        const char* name, int32_t product_id, int32_t vendor_id,

        input_bus_t bus, const char* unique_id) {

static input_host_callbacks_t kCallbacks = {

    .create_device_identifier = create_device_identifier,

    .create_device_definition = create_device_definition,

    .create_input_report_definition = create_input_report_definition,

    .create_output_report_definition = create_output_report_definition,

    .free_report_definition = free_report_definition,

    .input_device_definition_add_report = input_device_definition_add_report,

    .input_report_definition_add_collection = input_report_definition_add_collection,

    .input_report_definition_declare_usage_int = input_report_definition_declare_usage_int,

    .input_report_definition_declare_usages_bool = input_report_definition_declare_usages_bool,

    .register_device = register_device,

    .input_allocate_report = input_allocate_report,

    .input_report_set_usage_int = input_report_set_usage_int,

    .input_report_set_usage_bool = input_report_set_usage_bool,

    .report_event = report_event,

    .input_get_device_property_map = input_get_device_property_map,

    .input_get_device_property = input_get_device_property,

    .input_get_property_key = input_get_property_key,

    .input_get_property_value = input_get_property_value,

    .input_free_device_property = input_free_device_property,

    .input_free_device_property_map = input_free_device_property_map,

};



InputDriver::InputDriver(const char* name) : mName(String8(name)) {

    const hw_module_t* module;

    int err = input_open(&module, name);

    LOG_ALWAYS_FATAL_IF(err != 0, "Input module %s not found", name);

    mHal = reinterpret_cast<const input_module_t*>(module);

}



void InputDriver::init() {

    mHal->init(mHal, static_cast<input_host_t*>(this), kCallbacks);

}



input_device_identifier_t* InputDriver::createDeviceIdentifier(

            const char* name, int32_t productId, int32_t vendorId,

            input_bus_t bus, const char* uniqueId) {

    auto identifier = new ::input_device_identifier {

        .name = name,

        .productId = product_id,

        .vendorId = vendor_id,

        //.bus = bus,

        .uniqueId = unique_id,

        .productId = productId,

        .vendorId = vendorId,

        .bus = bus,

        .uniqueId = uniqueId,

    };

    // store this identifier somewhere? in the host?

    // TODO: store this identifier somewhere

    return identifier;

}



input_device_definition_t* create_device_definition(input_host_t* host) {

input_device_definition_t* InputDriver::createDeviceDefinition() {

    return new ::input_device_definition;

}



input_report_definition_t* create_input_report_definition(input_host_t* host) {

input_report_definition_t* InputDriver::createInputReportDefinition() {

    return new ::input_report_definition;

}



input_report_definition_t* create_output_report_definition(input_host_t* host) {

input_report_definition_t* InputDriver::createOutputReportDefinition() {

    return new ::input_report_definition;

}



void free_report_definition(input_host_t* host, input_report_definition_t* report_def) {

    delete report_def;

void InputDriver::freeReportDefinition(input_report_definition_t* reportDef) {

    delete reportDef;

}



void input_device_definition_add_report(input_host_t* host,

        input_device_definition_t* d, input_report_definition_t* r) {

void InputDriver::inputDeviceDefinitionAddReport(input_device_definition_t* d,

        input_report_definition_t* r) {

    d->reportDefs.push_back(r);

}



void input_report_definition_add_collection(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id, int32_t arity) {

void InputDriver::inputReportDefinitionAddCollection(input_report_definition_t* report,

        input_collection_id_t id, int32_t arity) {

    report->collections[id] = {.arity = arity};

}



void input_report_definition_declare_usage_int(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id,

        input_usage_t usage, int32_t min, int32_t max, float resolution) {

void InputDriver::inputReportDefinitionDeclareUsageInt(input_report_definition_t* report,

        input_collection_id_t id, input_usage_t usage, int32_t min, int32_t max,

        float resolution) {

    if (report->collections.find(id) != report->collections.end()) {

        report->collections[id].intUsages.push_back({

                .usage = usage, .min = min, .max = max, .resolution = resolution});

    }

}



void input_report_definition_declare_usages_bool(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id,

        input_usage_t* usage, size_t usage_count) {

void InputDriver::inputReportDefinitionDeclareUsagesBool(input_report_definition_t* report,

        input_collection_id_t id, input_usage_t* usage, size_t usageCount) {

    if (report->collections.find(id) != report->collections.end()) {

        for (size_t i = 0; i < usage_count; ++i) {

        for (size_t i = 0; i < usageCount; ++i) {

            report->collections[id].boolUsages.push_back(usage[i]);

        }

    }

}



input_device_handle_t* register_device(input_host_t* host,

        input_device_identifier_t* id, input_device_definition_t* d) {

    ALOGD("Registering device %s with %d input reports", id->name, d->reportDefs.size());

input_device_handle_t* InputDriver::registerDevice(input_device_identifier_t* id,

        input_device_definition_t* d) {

    ALOGD("Registering device %s with %zu input reports", id->name, d->reportDefs.size());

    // TODO: save this device handle

    return new input_device_handle{ .id = id, .def = d };

}



input_report_t* input_allocate_report(input_host_t* host, input_report_definition_t* r) {

void InputDriver::unregisterDevice(input_device_handle_t* handle) {

    delete handle;

}



input_report_t* InputDriver::inputAllocateReport(input_report_definition_t* r) {

    ALOGD("Allocating input report for definition %p", r);

    return nullptr;

}



void input_report_set_usage_int(input_host_t* host, input_report_t* r,

        input_collection_id_t id, input_usage_t usage, int32_t value, int32_t arity_index) { }

void InputDriver::inputReportSetUsageInt(input_report_t* r, input_collection_id_t id,

        input_usage_t usage, int32_t value, int32_t arity_index) {

}



void input_report_set_usage_bool(input_host_t* host, input_report_t* r,

        input_collection_id_t id, input_usage_t usage, bool value, int32_t arity_index) { }

void InputDriver::inputReportSetUsageBool(input_report_t* r, input_collection_id_t id,

        input_usage_t usage, bool value, int32_t arity_index) {

}



void report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report) {

void InputDriver::reportEvent(input_device_handle_t* d, input_report_t* report) {

    ALOGD("report_event %p for handle %p", report, d);

}



input_property_map_t* input_get_device_property_map(input_host_t* host,

        input_device_identifier_t* id) {

input_property_map_t* InputDriver::inputGetDevicePropertyMap(input_device_identifier_t* id) {

    InputDeviceIdentifier idi;

    idi.name = id->name;

    idi.uniqueId = id->uniqueId;
@@ -241,7 +237,7 @@ input_property_map_t* input_get_device_property_map(input_host_t* host, 
    return nullptr;

}



input_property_t* input_get_device_property(input_host_t* host, input_property_map_t* map,

input_property_t* InputDriver::inputGetDeviceProperty(input_property_map_t* map,

        const char* key) {

    String8 keyString(key);

    if (map != nullptr) {
@@ -258,31 +254,159 @@ input_property_t* input_get_device_property(input_host_t* host, input_property_m 
    return nullptr;

}



const char* input_get_property_key(input_host_t* host, input_property_t* property) {

const char* InputDriver::inputGetPropertyKey(input_property_t* property) {

    if (property != nullptr) {

        return property->key.string();

    }

    return nullptr;

}



const char* input_get_property_value(input_host_t* host, input_property_t* property) {

const char* InputDriver::inputGetPropertyValue(input_property_t* property) {

    if (property != nullptr) {

        return property->value.string();

    }

    return nullptr;

}



void input_free_device_property(input_host_t* host, input_property_t* property) {

void InputDriver::inputFreeDeviceProperty(input_property_t* property) {

    if (property != nullptr) {

        delete property;

    }

}



void input_free_device_property_map(input_host_t* host, input_property_map_t* map) {

void InputDriver::inputFreeDevicePropertyMap(input_property_map_t* map) {

    if (map != nullptr) {

        delete map->propertyMap;

        delete map;

    }

}



void InputDriver::dump(String8& result) {

    result.appendFormat(INDENT2 "HAL Input Driver (%s)\n", mName.string());

}



} // namespace android



// HAL wrapper functions



namespace android {



::input_device_identifier_t* create_device_identifier(input_host_t* host,

        const char* name, int32_t product_id, int32_t vendor_id,

        input_bus_t bus, const char* unique_id) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->createDeviceIdentifier(name, product_id, vendor_id, bus, unique_id);

}



input_device_definition_t* create_device_definition(input_host_t* host) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->createDeviceDefinition();

}



input_report_definition_t* create_input_report_definition(input_host_t* host) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->createInputReportDefinition();

}



input_report_definition_t* create_output_report_definition(input_host_t* host) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->createOutputReportDefinition();

}



void free_report_definition(input_host_t* host, input_report_definition_t* report_def) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->freeReportDefinition(report_def);

}



void input_device_definition_add_report(input_host_t* host,

        input_device_definition_t* d, input_report_definition_t* r) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputDeviceDefinitionAddReport(d, r);

}



void input_report_definition_add_collection(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id, int32_t arity) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputReportDefinitionAddCollection(report, id, arity);

}



void input_report_definition_declare_usage_int(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id,

        input_usage_t usage, int32_t min, int32_t max, float resolution) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputReportDefinitionDeclareUsageInt(report, id, usage, min, max, resolution);

}



void input_report_definition_declare_usages_bool(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id,

        input_usage_t* usage, size_t usage_count) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputReportDefinitionDeclareUsagesBool(report, id, usage, usage_count);

}



input_device_handle_t* register_device(input_host_t* host,

        input_device_identifier_t* id, input_device_definition_t* d) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->registerDevice(id, d);

}



void unregister_device(input_host_t* host, input_device_handle_t* handle) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->unregisterDevice(handle);

}



input_report_t* input_allocate_report(input_host_t* host, input_report_definition_t* r) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->inputAllocateReport(r);

}



void input_report_set_usage_int(input_host_t* host, input_report_t* r,

        input_collection_id_t id, input_usage_t usage, int32_t value, int32_t arity_index) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputReportSetUsageInt(r, id, usage, value, arity_index);

}



void input_report_set_usage_bool(input_host_t* host, input_report_t* r,

        input_collection_id_t id, input_usage_t usage, bool value, int32_t arity_index) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputReportSetUsageBool(r, id, usage, value, arity_index);

}



void report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->reportEvent(d, report);

}



input_property_map_t* input_get_device_property_map(input_host_t* host,

        input_device_identifier_t* id) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->inputGetDevicePropertyMap(id);

}



input_property_t* input_get_device_property(input_host_t* host, input_property_map_t* map,

        const char* key) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->inputGetDeviceProperty(map, key);

}



const char* input_get_property_key(input_host_t* host, input_property_t* property) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->inputGetPropertyKey(property);

}



const char* input_get_property_value(input_host_t* host, input_property_t* property) {

    auto driver = static_cast<InputDriverInterface*>(host);

    return driver->inputGetPropertyValue(property);

}



void input_free_device_property(input_host_t* host, input_property_t* property) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputFreeDeviceProperty(property);

}



void input_free_device_property_map(input_host_t* host, input_property_map_t* map) {

    auto driver = static_cast<InputDriverInterface*>(host);

    driver->inputFreeDevicePropertyMap(map);

}



} // namespace android

services/inputflinger/host/InputDriver.h

+81 −5
Original line number Diff line number Diff line
@@ -26,17 +26,56 @@ 
#include <utils/RefBase.h>

#include <utils/String8.h>



namespace android {

// Declare a concrete type for the HAL

struct input_host {

};



class InputHostInterface;

namespace android {



class InputDriverInterface : public virtual RefBase {

class InputDriverInterface : public input_host_t, public virtual RefBase {

protected:

    InputDriverInterface() = default;

    virtual ~InputDriverInterface() = default;



public:

    virtual void init(InputHostInterface* host) = 0;

    virtual void init() = 0;



    virtual input_device_identifier_t* createDeviceIdentifier(

            const char* name, int32_t productId, int32_t vendorId,

            input_bus_t bus, const char* uniqueId) = 0;

    virtual input_device_definition_t* createDeviceDefinition() = 0;

    virtual input_report_definition_t* createInputReportDefinition() = 0;

    virtual input_report_definition_t* createOutputReportDefinition() = 0;

    virtual void freeReportDefinition(input_report_definition_t* reportDef) = 0;



    virtual void inputDeviceDefinitionAddReport(input_device_definition_t* d,

            input_report_definition_t* r) = 0;

    virtual void inputReportDefinitionAddCollection(input_report_definition_t* report,

            input_collection_id_t id, int32_t arity) = 0;

    virtual void inputReportDefinitionDeclareUsageInt(input_report_definition_t* report,

            input_collection_id_t id, input_usage_t usage, int32_t min, int32_t max,

            float resolution) = 0;

    virtual void inputReportDefinitionDeclareUsagesBool(input_report_definition_t* report,

            input_collection_id_t id, input_usage_t* usage, size_t usageCount) = 0;



    virtual input_device_handle_t* registerDevice(input_device_identifier_t* id,

            input_device_definition_t* d) = 0;

    virtual void unregisterDevice(input_device_handle_t* handle) = 0;



    virtual input_report_t* inputAllocateReport(input_report_definition_t* r) = 0;

    virtual void inputReportSetUsageInt(input_report_t* r, input_collection_id_t id,

            input_usage_t usage, int32_t value, int32_t arity_index) = 0;

    virtual void inputReportSetUsageBool(input_report_t* r, input_collection_id_t id,

            input_usage_t usage, bool value, int32_t arity_index) = 0;

    virtual void reportEvent(input_device_handle_t* d, input_report_t* report) = 0;



    virtual input_property_map_t* inputGetDevicePropertyMap(input_device_identifier_t* id) = 0;

    virtual input_property_t* inputGetDeviceProperty(input_property_map_t* map,

            const char* key) = 0;

    virtual const char* inputGetPropertyKey(input_property_t* property) = 0;

    virtual const char* inputGetPropertyValue(input_property_t* property) = 0;

    virtual void inputFreeDeviceProperty(input_property_t* property) = 0;

    virtual void inputFreeDevicePropertyMap(input_property_map_t* map) = 0;



    virtual void dump(String8& result) = 0;

};
@@ -46,7 +85,44 @@ public: 
    InputDriver(const char* name);

    virtual ~InputDriver() = default;



    virtual void init(InputHostInterface* host) override;

    virtual void init() override;



    virtual input_device_identifier_t* createDeviceIdentifier(

            const char* name, int32_t productId, int32_t vendorId,

            input_bus_t bus, const char* uniqueId) override;

    virtual input_device_definition_t* createDeviceDefinition() override;

    virtual input_report_definition_t* createInputReportDefinition() override;

    virtual input_report_definition_t* createOutputReportDefinition() override;

    virtual void freeReportDefinition(input_report_definition_t* reportDef) override;



    virtual void inputDeviceDefinitionAddReport(input_device_definition_t* d,

            input_report_definition_t* r) override;

    virtual void inputReportDefinitionAddCollection(input_report_definition_t* report,

            input_collection_id_t id, int32_t arity) override;

    virtual void inputReportDefinitionDeclareUsageInt(input_report_definition_t* report,

            input_collection_id_t id, input_usage_t usage, int32_t min, int32_t max,

            float resolution) override;

    virtual void inputReportDefinitionDeclareUsagesBool(input_report_definition_t* report,

            input_collection_id_t id, input_usage_t* usage, size_t usageCount) override;



    virtual input_device_handle_t* registerDevice(input_device_identifier_t* id,

            input_device_definition_t* d) override;

    virtual void unregisterDevice(input_device_handle_t* handle) override;



    virtual input_report_t* inputAllocateReport(input_report_definition_t* r) override;

    virtual void inputReportSetUsageInt(input_report_t* r, input_collection_id_t id,

            input_usage_t usage, int32_t value, int32_t arity_index) override;

    virtual void inputReportSetUsageBool(input_report_t* r, input_collection_id_t id,

            input_usage_t usage, bool value, int32_t arity_index) override;

    virtual void reportEvent(input_device_handle_t* d, input_report_t* report) override;



    virtual input_property_map_t* inputGetDevicePropertyMap(input_device_identifier_t* id) override;

    virtual input_property_t* inputGetDeviceProperty(input_property_map_t* map,

            const char* key) override;

    virtual const char* inputGetPropertyKey(input_property_t* property) override;

    virtual const char* inputGetPropertyValue(input_property_t* property) override;

    virtual void inputFreeDeviceProperty(input_property_t* property) override;

    virtual void inputFreeDevicePropertyMap(input_property_map_t* map) override;



    virtual void dump(String8& result) override;

services/inputflinger/host/InputHost.cpp

+1 −1
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ namespace android { 


void InputHost::registerInputDriver(InputDriverInterface* driver) {

    LOG_ALWAYS_FATAL_IF(driver == nullptr, "Cannot register a nullptr as an InputDriver!");

    driver->init(this);

    driver->init();

    mDrivers.push_back(driver);

}

services/inputflinger/host/InputHost.h

+1 −5
Original line number Diff line number Diff line
@@ -26,15 +26,11 @@ 


#include "InputDriver.h"



// Declare a concrete type for the HAL

struct input_host {

};



namespace android {



class InputDriverInterface;



class InputHostInterface : public input_host_t, public virtual RefBase {

class InputHostInterface : public virtual RefBase {

protected:

    InputHostInterface() = default;

    virtual ~InputHostInterface() = default;