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

Commit bc16fb98 authored by Michael Wright's avatar Michael Wright Committed by Android Git Automerger
Browse files

am cff01363: Merge commit \'8a196b56\' into merge-fix 

* commit 'cff01363':
  DO NOT MERGE Revert "am f37143d8: Merge "Cancel touches as well as pointer gestures." into mnc-dev"
parents 6263caf7 cff01363

services/inputflinger/InputReader.cpp

+5 −29
Original line number Diff line number Diff line
@@ -3860,7 +3860,6 @@ void TouchInputMapper::reset(nsecs_t when) { 
    mPointerUsage = POINTER_USAGE_NONE;

    mSentHoverEnter = false;

    mHavePointerIds = false;

    mCurrentMotionAborted = false;

    mDownTime = 0;



    mCurrentVirtualKey.down = false;
@@ -4088,7 +4087,6 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { 
                    mCurrentCookedState.cookedPointerData.touchingIdBits);

        }



        if (!mCurrentMotionAborted) {

        dispatchButtonRelease(when, policyFlags);

        dispatchHoverExit(when, policyFlags);

        dispatchTouches(when, policyFlags);
@@ -4096,11 +4094,6 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { 
        dispatchButtonPress(when, policyFlags);

    }



        if (mCurrentCookedState.cookedPointerData.pointerCount == 0) {

            mCurrentMotionAborted = false;

        }

    }



    // Synthesize key up from raw buttons if needed.

    synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,

            policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState);
@@ -4323,22 +4316,6 @@ void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags, 
    getListener()->notifyKey(&args);

}



void TouchInputMapper::abortTouches(nsecs_t when, uint32_t policyFlags) {

    BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;

    if (!currentIdBits.isEmpty()) {

        int32_t metaState = getContext()->getGlobalMetaState();

        int32_t buttonState = mCurrentCookedState.buttonState;

        dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0,

                metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,

                mCurrentCookedState.cookedPointerData.pointerProperties,

                mCurrentCookedState.cookedPointerData.pointerCoords,

                mCurrentCookedState.cookedPointerData.idToIndex,

                currentIdBits, -1,

                mOrientedXPrecision, mOrientedYPrecision, mDownTime);

        mCurrentMotionAborted = true;

    }

}



void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {

    BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;

    BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits;
@@ -6112,7 +6089,6 @@ void TouchInputMapper::fadePointer() { 


void TouchInputMapper::cancelTouch(nsecs_t when) {

    abortPointerUsage(when, 0 /*policyFlags*/);

    abortTouches(when, 0 /* policyFlags*/);

}



bool TouchInputMapper::isPointInsideSurface(int32_t x, int32_t y) {

services/inputflinger/InputReader.h

+0 −4
Original line number Diff line number Diff line
@@ -1469,9 +1469,6 @@ protected: 
    // Have we assigned pointer IDs for this stream

    bool mHavePointerIds;



    // Is the current stream of direct touch events aborted

    bool mCurrentMotionAborted;



    // The time the primary pointer last went down.

    nsecs_t mDownTime;
@@ -1805,7 +1802,6 @@ private: 
    void dispatchButtonPress(nsecs_t when, uint32_t policyFlags);

    const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData);

    void cookPointerData();

    void abortTouches(nsecs_t when, uint32_t policyFlags);



    void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);

    void abortPointerUsage(nsecs_t when, uint32_t policyFlags);

services/inputflinger/host/InputDriver.cpp

+14 −156
Original line number Diff line number Diff line
@@ -14,11 +14,8 @@ 
 * limitations under the License.

 */



#include <functional>

#include <stdint.h>

#include <sys/types.h>

#include <unordered_map>

#include <vector>



#define LOG_TAG "InputDriver"
@@ -28,9 +25,7 @@ 
#include "InputHost.h"



#include <hardware/input.h>

#include <input/InputDevice.h>

#include <utils/Log.h>

#include <utils/PropertyMap.h>

#include <utils/String8.h>



#define INDENT2 "    "
@@ -42,7 +37,6 @@ static input_host_callbacks_t kCallbacks = { 
    .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,
@@ -75,214 +69,78 @@ void InputDriver::dump(String8& result) { 
    result.appendFormat(INDENT2 "HAL Input Driver (%s)\n", mName.string());

}



} // namespace android



struct input_property_map {

    android::PropertyMap* propertyMap;

};



struct input_property {

    android::String8 key;

    android::String8 value;

};



struct input_device_identifier {

    const char* name;

    const char* uniqueId;

    input_bus_t bus;

    int32_t     vendorId;

    int32_t     productId;

    int32_t     version;

};



struct input_device_definition {

    std::vector<input_report_definition*> reportDefs;

};



struct input_device_handle {

    input_device_identifier_t* id;

    input_device_definition_t* def;

};



struct input_int_usage {

    input_usage_t usage;

    int32_t min;

    int32_t max;

    float   resolution;

};



struct input_collection {

    int32_t arity;

    std::vector<input_int_usage> intUsages;

    std::vector<input_usage_t> boolUsages;

};



struct InputCollectionIdHasher {

    std::size_t operator()(const input_collection_id& id) const {

        return std::hash<int>()(static_cast<int>(id));

    }

};



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,

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 identifier = new ::input_device_identifier {

        .name = name,

        .productId = product_id,

        .vendorId = vendor_id,

        //.bus = bus,

        .uniqueId = unique_id,

    };

    // store this identifier somewhere? in the host?

    return identifier;

    return nullptr;

}



input_device_definition_t* create_device_definition(input_host_t* host) {

    return new ::input_device_definition;

    return nullptr;

}



input_report_definition_t* create_input_report_definition(input_host_t* host) {

    return new ::input_report_definition;

    return nullptr;

}



input_report_definition_t* create_output_report_definition(input_host_t* host) {

    return new ::input_report_definition;

}



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

    delete report_def;

    return nullptr;

}



void input_device_definition_add_report(input_host_t* host,

        input_device_definition_t* d, input_report_definition_t* r) {

    d->reportDefs.push_back(r);

}

        input_device_definition_t* d, input_report_definition_t* r) { }



void input_report_definition_add_collection(input_host_t* host,

        input_report_definition_t* report, input_collection_id_t id, int32_t arity) {

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

}

        input_report_definition_t* report, input_collection_id_t id, int32_t 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) {

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

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

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

    }

}

        input_usage_t usage, int32_t min, int32_t max, float 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) {

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

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

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

        }

    }

}

        input_usage_t* usage, size_t usage_count) { }





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());

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

    return nullptr;

}



input_report_t* input_allocate_report(input_host_t* host, 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 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 report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report) {

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

}

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



input_property_map_t* input_get_device_property_map(input_host_t* host,

        input_device_identifier_t* id) {

    InputDeviceIdentifier idi;

    idi.name = id->name;

    idi.uniqueId = id->uniqueId;

    idi.bus = id->bus;

    idi.vendor = id->vendorId;

    idi.product = id->productId;

    idi.version = id->version;



    String8 configFile = getInputDeviceConfigurationFilePathByDeviceIdentifier(

            idi, INPUT_DEVICE_CONFIGURATION_FILE_TYPE_CONFIGURATION);

    if (configFile.isEmpty()) {

        ALOGD("No input device configuration file found for device '%s'.",

                idi.name.string());

    } else {

        auto propMap = new input_property_map_t();

        status_t status = PropertyMap::load(configFile, &propMap->propertyMap);

        if (status) {

            ALOGE("Error loading input device configuration file for device '%s'. "

                    "Using default configuration.",

                    idi.name.string());

            delete propMap;

            return nullptr;

        }

        return propMap;

    }

    return nullptr;

}



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

        const char* key) {

    String8 keyString(key);

    if (map != nullptr) {

        if (map->propertyMap->hasProperty(keyString)) {

            auto prop = new input_property_t();

            if (!map->propertyMap->tryGetProperty(keyString, prop->value)) {

                delete prop;

                return nullptr;

            }

            prop->key = keyString;

            return prop;

        }

    }

    return nullptr;

}



const char* input_get_property_key(input_host_t* host, 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) {

    if (property != nullptr) {

        return property->value.string();

    }

    return nullptr;

}



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

    if (property != nullptr) {

        delete property;

    }

}

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



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

    if (map != nullptr) {

        delete map->propertyMap;

        delete map;

    }

}

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



} // namespace android

services/inputflinger/host/InputDriver.h

+0 −2
Original line number Diff line number Diff line
@@ -68,8 +68,6 @@ input_report_definition_t* create_input_report_definition(input_host_t* host); 


input_report_definition_t* create_output_report_definition(input_host_t* host);



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



void input_device_definition_add_report(input_host_t* host,

        input_device_definition_t* d, input_report_definition_t* r);