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

Commit 0265c5b9 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 10486787 from 5443413a to udc-qpr1-release 

Change-Id: Ie61c81ac2c0781d076ea15dad6ebf82374aec56b
parents 4afdc279 5443413a

include/input/InputEventBuilders.h

0 → 100644
+163 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2023 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

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <android/input.h>

#include <attestation/HmacKeyManager.h>

#include <gui/constants.h>

#include <input/Input.h>

#include <utils/Timers.h> // for nsecs_t, systemTime



#include <vector>



namespace android {



// An arbitrary device id.

static constexpr uint32_t DEFAULT_DEVICE_ID = 1;



// The default policy flags to use for event injection by tests.

static constexpr uint32_t DEFAULT_POLICY_FLAGS = POLICY_FLAG_FILTERED | POLICY_FLAG_PASS_TO_USER;



class PointerBuilder {

public:

    PointerBuilder(int32_t id, ToolType toolType) {

        mProperties.clear();

        mProperties.id = id;

        mProperties.toolType = toolType;

        mCoords.clear();

    }



    PointerBuilder& x(float x) { return axis(AMOTION_EVENT_AXIS_X, x); }



    PointerBuilder& y(float y) { return axis(AMOTION_EVENT_AXIS_Y, y); }



    PointerBuilder& axis(int32_t axis, float value) {

        mCoords.setAxisValue(axis, value);

        return *this;

    }



    PointerProperties buildProperties() const { return mProperties; }



    PointerCoords buildCoords() const { return mCoords; }



private:

    PointerProperties mProperties;

    PointerCoords mCoords;

};



class MotionEventBuilder {

public:

    MotionEventBuilder(int32_t action, int32_t source) {

        mAction = action;

        mSource = source;

        mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);

        mDownTime = mEventTime;

    }



    MotionEventBuilder& deviceId(int32_t deviceId) {

        mDeviceId = deviceId;

        return *this;

    }



    MotionEventBuilder& downTime(nsecs_t downTime) {

        mDownTime = downTime;

        return *this;

    }



    MotionEventBuilder& eventTime(nsecs_t eventTime) {

        mEventTime = eventTime;

        return *this;

    }



    MotionEventBuilder& displayId(int32_t displayId) {

        mDisplayId = displayId;

        return *this;

    }



    MotionEventBuilder& actionButton(int32_t actionButton) {

        mActionButton = actionButton;

        return *this;

    }



    MotionEventBuilder& buttonState(int32_t buttonState) {

        mButtonState = buttonState;

        return *this;

    }



    MotionEventBuilder& rawXCursorPosition(float rawXCursorPosition) {

        mRawXCursorPosition = rawXCursorPosition;

        return *this;

    }



    MotionEventBuilder& rawYCursorPosition(float rawYCursorPosition) {

        mRawYCursorPosition = rawYCursorPosition;

        return *this;

    }



    MotionEventBuilder& pointer(PointerBuilder pointer) {

        mPointers.push_back(pointer);

        return *this;

    }



    MotionEventBuilder& addFlag(uint32_t flags) {

        mFlags |= flags;

        return *this;

    }



    MotionEvent build() {

        std::vector<PointerProperties> pointerProperties;

        std::vector<PointerCoords> pointerCoords;

        for (const PointerBuilder& pointer : mPointers) {

            pointerProperties.push_back(pointer.buildProperties());

            pointerCoords.push_back(pointer.buildCoords());

        }



        // Set mouse cursor position for the most common cases to avoid boilerplate.

        if (mSource == AINPUT_SOURCE_MOUSE &&

            !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

            mRawXCursorPosition = pointerCoords[0].getX();

            mRawYCursorPosition = pointerCoords[0].getY();

        }



        MotionEvent event;

        static const ui::Transform kIdentityTransform;

        event.initialize(InputEvent::nextId(), mDeviceId, mSource, mDisplayId, INVALID_HMAC,

                         mAction, mActionButton, mFlags, /*edgeFlags=*/0, AMETA_NONE, mButtonState,

                         MotionClassification::NONE, kIdentityTransform,

                         /*xPrecision=*/0, /*yPrecision=*/0, mRawXCursorPosition,

                         mRawYCursorPosition, kIdentityTransform, mDownTime, mEventTime,

                         mPointers.size(), pointerProperties.data(), pointerCoords.data());

        return event;

    }



private:

    int32_t mAction;

    int32_t mDeviceId{DEFAULT_DEVICE_ID};

    int32_t mSource;

    nsecs_t mDownTime;

    nsecs_t mEventTime;

    int32_t mDisplayId{ADISPLAY_ID_DEFAULT};

    int32_t mActionButton{0};

    int32_t mButtonState{0};

    int32_t mFlags{0};

    float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};

    float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};



    std::vector<PointerBuilder> mPointers;

};



} // namespace android

libs/graphicsenv/GraphicsEnv.cpp

+3 −16
Original line number Diff line number Diff line
@@ -512,11 +512,7 @@ bool GraphicsEnv::shouldUseAngle() { 
    return mShouldUseAngle;

}



// Set ANGLE information.

// If path is "system", it means system ANGLE must be used for the process.

// If shouldUseNativeDriver is true, it means native GLES drivers must be used for the process.

// If path is set to nonempty and shouldUseNativeDriver is true, ANGLE will be used regardless.

void GraphicsEnv::setAngleInfo(const std::string& path, const bool shouldUseNativeDriver,

void GraphicsEnv::setAngleInfo(const std::string& path, const bool shouldUseSystemAngle,

                               const std::string& packageName,

                               const std::vector<std::string> eglFeatures) {

    if (mShouldUseAngle) {
@@ -533,13 +529,8 @@ void GraphicsEnv::setAngleInfo(const std::string& path, const bool shouldUseNati 
    mAnglePath = std::move(path);

    ALOGV("setting app package name to '%s'", packageName.c_str());

    mPackageName = std::move(packageName);

    if (mAnglePath == "system") {

        mShouldUseSystemAngle = true;

    }

    if (!mAnglePath.empty()) {

    mShouldUseAngle = true;

    }

    mShouldUseNativeDriver = shouldUseNativeDriver;

    mShouldUseSystemAngle = shouldUseSystemAngle;

}



std::string& GraphicsEnv::getPackageName() {
@@ -616,10 +607,6 @@ bool GraphicsEnv::shouldUseSystemAngle() { 
    return mShouldUseSystemAngle;

}



bool GraphicsEnv::shouldUseNativeDriver() {

    return mShouldUseNativeDriver;

}



/**

 * APIs for debuggable layers

 */

libs/graphicsenv/include/graphicsenv/GraphicsEnv.h

+1 −7
Original line number Diff line number Diff line
@@ -108,10 +108,7 @@ public: 
    // (libraries must be stored uncompressed and page aligned); such elements

    // in the search path must have a '!' after the zip filename, e.g.

    //     /system/app/ANGLEPrebuilt/ANGLEPrebuilt.apk!/lib/arm64-v8a

    // If the search patch is "system", then it means the system ANGLE should be used.

    // If shouldUseNativeDriver is true, it means native GLES drivers must be used for the process.

    // If path is set to nonempty and shouldUseNativeDriver is true, ANGLE will be used regardless.

    void setAngleInfo(const std::string& path, const bool shouldUseNativeDriver,

    void setAngleInfo(const std::string& path, const bool useSystemAngle,

                      const std::string& packageName, const std::vector<std::string> eglFeatures);

    // Get the ANGLE driver namespace.

    android_namespace_t* getAngleNamespace();
@@ -121,7 +118,6 @@ public: 
    // Set the persist.graphics.egl system property value.

    void nativeToggleAngleAsSystemDriver(bool enabled);

    bool shouldUseSystemAngle();

    bool shouldUseNativeDriver();



    /*

     * Apis for debug layer
@@ -179,8 +175,6 @@ private: 
    bool mShouldUseAngle = false;

    // Whether loader should load system ANGLE.

    bool mShouldUseSystemAngle = false;

    // Whether loader should load native GLES driver.

    bool mShouldUseNativeDriver = false;

    // ANGLE namespace.

    android_namespace_t* mAngleNamespace = nullptr;

opengl/libs/EGL/Loader.cpp

+6 −23
Original line number Diff line number Diff line
@@ -169,11 +169,6 @@ static bool should_unload_system_driver(egl_connection_t* cnx) { 
        }

    }



    // Return true if native GLES drivers should be used and ANGLE is already loaded.

    if (android::GraphicsEnv::getInstance().shouldUseNativeDriver() && cnx->angleLoaded) {

        return true;

    }



    // Return true if updated driver namespace is set.

    ns = android::GraphicsEnv::getInstance().getDriverNamespace();

    if (ns) {
@@ -245,28 +240,16 @@ void* Loader::open(egl_connection_t* cnx) { 
    if (!hnd) {

        // Secondly, try to load from driver apk.

        hnd = attempt_to_load_updated_driver(cnx);



        // If updated driver apk is set but fail to load, abort here.

        LOG_ALWAYS_FATAL_IF(android::GraphicsEnv::getInstance().getDriverNamespace(),

                            "couldn't find an OpenGL ES implementation from %s",

                            android::GraphicsEnv::getInstance().getDriverPath().c_str());

    }



    // Attempt to load native GLES drivers specified by ro.hardware.egl if native is selected.

    // If native is selected but fail to load, abort.

    if (!hnd && android::GraphicsEnv::getInstance().shouldUseNativeDriver()) {

        auto driverSuffix = base::GetProperty(RO_DRIVER_SUFFIX_PROPERTY, "");

        LOG_ALWAYS_FATAL_IF(driverSuffix.empty(),

                            "Native GLES driver is selected but not specified in %s",

                            RO_DRIVER_SUFFIX_PROPERTY);

        hnd = attempt_to_load_system_driver(cnx, driverSuffix.c_str(), true);

        LOG_ALWAYS_FATAL_IF(!hnd, "Native GLES driver is selected but failed to load. %s=%s",

                            RO_DRIVER_SUFFIX_PROPERTY, driverSuffix.c_str());

    }



    // Finally, try to load default driver.

    bool failToLoadFromDriverSuffixProperty = false;

    if (!hnd) {

        // If updated driver apk is set but fail to load, abort here.

        if (android::GraphicsEnv::getInstance().getDriverNamespace()) {

            LOG_ALWAYS_FATAL("couldn't find an OpenGL ES implementation from %s",

                             android::GraphicsEnv::getInstance().getDriverPath().c_str());

        }

        // Finally, try to load system driver.

        // Start by searching for the library name appended by the system

        // properties of the GLES userspace driver in both locations.

        // i.e.:

include/input/EventBuilders.h→services/inputflinger/include/NotifyArgsBuilders.h

+4 −134
Original line number Diff line number Diff line
@@ -19,145 +19,15 @@ 
#include <NotifyArgs.h>

#include <android/input.h>

#include <attestation/HmacKeyManager.h>

#include <gui/constants.h>

#include <input/Input.h>

#include <input/InputEventBuilders.h>

#include <utils/Timers.h> // for nsecs_t, systemTime



#include <vector>



namespace android {



// An arbitrary device id.

static constexpr uint32_t DEFAULT_DEVICE_ID = 1;



// The default policy flags to use for event injection by tests.

static constexpr uint32_t DEFAULT_POLICY_FLAGS = POLICY_FLAG_FILTERED | POLICY_FLAG_PASS_TO_USER;



class PointerBuilder {

public:

    PointerBuilder(int32_t id, ToolType toolType) {

        mProperties.clear();

        mProperties.id = id;

        mProperties.toolType = toolType;

        mCoords.clear();

    }



    PointerBuilder& x(float x) { return axis(AMOTION_EVENT_AXIS_X, x); }



    PointerBuilder& y(float y) { return axis(AMOTION_EVENT_AXIS_Y, y); }



    PointerBuilder& axis(int32_t axis, float value) {

        mCoords.setAxisValue(axis, value);

        return *this;

    }



    PointerProperties buildProperties() const { return mProperties; }



    PointerCoords buildCoords() const { return mCoords; }



private:

    PointerProperties mProperties;

    PointerCoords mCoords;

};



class MotionEventBuilder {

public:

    MotionEventBuilder(int32_t action, int32_t source) {

        mAction = action;

        mSource = source;

        mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);

        mDownTime = mEventTime;

    }



    MotionEventBuilder& deviceId(int32_t deviceId) {

        mDeviceId = deviceId;

        return *this;

    }



    MotionEventBuilder& downTime(nsecs_t downTime) {

        mDownTime = downTime;

        return *this;

    }



    MotionEventBuilder& eventTime(nsecs_t eventTime) {

        mEventTime = eventTime;

        return *this;

    }



    MotionEventBuilder& displayId(int32_t displayId) {

        mDisplayId = displayId;

        return *this;

    }



    MotionEventBuilder& actionButton(int32_t actionButton) {

        mActionButton = actionButton;

        return *this;

    }



    MotionEventBuilder& buttonState(int32_t buttonState) {

        mButtonState = buttonState;

        return *this;

    }



    MotionEventBuilder& rawXCursorPosition(float rawXCursorPosition) {

        mRawXCursorPosition = rawXCursorPosition;

        return *this;

    }



    MotionEventBuilder& rawYCursorPosition(float rawYCursorPosition) {

        mRawYCursorPosition = rawYCursorPosition;

        return *this;

    }



    MotionEventBuilder& pointer(PointerBuilder pointer) {

        mPointers.push_back(pointer);

        return *this;

    }



    MotionEventBuilder& addFlag(uint32_t flags) {

        mFlags |= flags;

        return *this;

    }



    MotionEvent build() {

        std::vector<PointerProperties> pointerProperties;

        std::vector<PointerCoords> pointerCoords;

        for (const PointerBuilder& pointer : mPointers) {

            pointerProperties.push_back(pointer.buildProperties());

            pointerCoords.push_back(pointer.buildCoords());

        }



        // Set mouse cursor position for the most common cases to avoid boilerplate.

        if (mSource == AINPUT_SOURCE_MOUSE &&

            !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

            mRawXCursorPosition = pointerCoords[0].getX();

            mRawYCursorPosition = pointerCoords[0].getY();

        }



        MotionEvent event;

        static const ui::Transform kIdentityTransform;

        event.initialize(InputEvent::nextId(), mDeviceId, mSource, mDisplayId, INVALID_HMAC,

                         mAction, mActionButton, mFlags, /*edgeFlags=*/0, AMETA_NONE, mButtonState,

                         MotionClassification::NONE, kIdentityTransform,

                         /*xPrecision=*/0, /*yPrecision=*/0, mRawXCursorPosition,

                         mRawYCursorPosition, kIdentityTransform, mDownTime, mEventTime,

                         mPointers.size(), pointerProperties.data(), pointerCoords.data());

        return event;

    }



private:

    int32_t mAction;

    int32_t mDeviceId{DEFAULT_DEVICE_ID};

    int32_t mSource;

    nsecs_t mDownTime;

    nsecs_t mEventTime;

    int32_t mDisplayId{ADISPLAY_ID_DEFAULT};

    int32_t mActionButton{0};

    int32_t mButtonState{0};

    int32_t mFlags{0};

    float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};

    float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};



    std::vector<PointerBuilder> mPointers;

};



class MotionArgsBuilder {

public:

    MotionArgsBuilder(int32_t action, int32_t source) {