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

Commit 8a196b56 authored by Michael Wright's avatar Michael Wright Committed by Android (Google) Code Review
Browse files

Merge "DO NOT MERGE Revert "am f37143d8: Merge "Cancel touches as well as... 

Merge "DO NOT MERGE Revert "am f37143d8: Merge "Cancel touches as well as pointer gestures." into mnc-dev"" into mnc-dr-dev
parents 72ebebed a16b98c6

include/android/keycodes.h

+1 −14
Original line number Diff line number Diff line
@@ -722,20 +722,7 @@ enum { 
    AKEYCODE_NAVIGATE_PREVIOUS = 260,

    AKEYCODE_NAVIGATE_NEXT   = 261,

    AKEYCODE_NAVIGATE_IN     = 262,

    AKEYCODE_NAVIGATE_OUT    = 263,

    /** Primary stem key for Wear

     * Main power/reset button on watch. */

    AKEYCODE_STEM_PRIMARY = 264,

    /** Generic stem key 1 for Wear */

    AKEYCODE_STEM_1 = 265,

    /** Generic stem key 2 for Wear */

    AKEYCODE_STEM_2 = 266,

    /** Generic stem key 3 for Wear */

    AKEYCODE_STEM_3 = 267,

    AKEYCODE_MEDIA_SKIP_FORWARD = 272,

    AKEYCODE_MEDIA_SKIP_BACKWARD = 273,

    AKEYCODE_MEDIA_STEP_FORWARD = 274,

    AKEYCODE_MEDIA_STEP_BACKWARD = 275

    AKEYCODE_NAVIGATE_OUT    = 263



    // NOTE: If you add a new keycode here you must also add it to several other files.

    //       Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.

include/input/InputEventLabels.h

+0 −8
Original line number Diff line number Diff line
@@ -303,14 +303,6 @@ static const InputEventLabel KEYCODES[] = { 
    DEFINE_KEYCODE(NAVIGATE_NEXT),

    DEFINE_KEYCODE(NAVIGATE_IN),

    DEFINE_KEYCODE(NAVIGATE_OUT),

    DEFINE_KEYCODE(STEM_PRIMARY),

    DEFINE_KEYCODE(STEM_1),

    DEFINE_KEYCODE(STEM_2),

    DEFINE_KEYCODE(STEM_3),

    DEFINE_KEYCODE(MEDIA_SKIP_FORWARD),

    DEFINE_KEYCODE(MEDIA_SKIP_BACKWARD),

    DEFINE_KEYCODE(MEDIA_STEP_FORWARD),

    DEFINE_KEYCODE(MEDIA_STEP_BACKWARD),



    { NULL, 0 }

};

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