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

Commit ec05cd4a authored by Jeff Brown's avatar Jeff Brown Committed by Android Git Automerger
Browse files

am 3b724c83: am 00e5c613: Merge "Improve thread safety of input mappers." into gingerbread 

Merge commit '3b724c836b13b320b2b2c492c28660617e0d503e'

* commit '3b724c836b13b320b2b2c492c28660617e0d503e':
  Improve thread safety of input mappers.
parents e1707a96 333e73fc

include/ui/InputReader.h

+83 −67
Original line number Diff line number Diff line
@@ -210,7 +210,7 @@ public: 
 * IMPORTANT INVARIANT:

 *     Because the policy and dispatcher can potentially block or cause re-entrance into

 *     the input reader, the input reader never calls into other components while holding

 *     an exclusive internal lock.

 *     an exclusive internal lock whenever re-entrance can happen.

 */

class InputReader : public InputReaderInterface, private InputReaderContext {

public:
@@ -414,6 +414,8 @@ public: 
    virtual int32_t getMetaState();



private:

    Mutex mLock;



    struct KeyDown {

        int32_t keyCode;

        int32_t scanCode;
@@ -423,17 +425,22 @@ private: 
    uint32_t mSources;

    int32_t mKeyboardType;



    Vector<KeyDown> mKeyDowns; // keys that are down

    int32_t mMetaState;

    nsecs_t mDownTime; // time of most recent key down

    struct LockedState {

        Vector<KeyDown> keyDowns; // keys that are down

        int32_t metaState;

        nsecs_t downTime; // time of most recent key down

    } mLocked;



    void initialize();

    void initializeLocked();



    bool isKeyboardOrGamepadKey(int32_t scanCode);



    void processKey(nsecs_t when, bool down, int32_t keyCode, int32_t scanCode,

            uint32_t policyFlags);

    void applyPolicyAndDispatch(nsecs_t when, uint32_t policyFlags,

            bool down, int32_t keyCode, int32_t scanCode, int32_t metaState, nsecs_t downTime);



    ssize_t findKeyDown(int32_t scanCode);

    ssize_t findKeyDownLocked(int32_t scanCode);

};
@@ -451,6 +458,8 @@ private: 
    // Amount that trackball needs to move in order to generate a key event.

    static const int32_t TRACKBALL_MOVEMENT_THRESHOLD = 6;



    Mutex mLock;



    int32_t mAssociatedDisplayId;



    struct Accumulator {
@@ -475,17 +484,21 @@ private: 
        }

    } mAccumulator;



    bool mDown;

    nsecs_t mDownTime;



    float mXScale;

    float mYScale;

    float mXPrecision;

    float mYPrecision;



    void initialize();

    struct LockedState {

        bool down;

        nsecs_t downTime;

    } mLocked;



    void initializeLocked();



    void sync(nsecs_t when);

    void applyPolicyAndDispatch(nsecs_t when, int32_t motionEventAction,

            PointerCoords* pointerCoords, nsecs_t downTime);

};
@@ -509,6 +522,8 @@ protected: 
     * (This is limited by our use of BitSet32 to track pointer assignments.) */

    static const uint32_t MAX_POINTER_ID = 31;



    Mutex mLock;



    struct VirtualKey {

        int32_t keyCode;

        int32_t scanCode;
@@ -561,7 +576,6 @@ protected: 
    };



    int32_t mAssociatedDisplayId;

    Vector<VirtualKey> mVirtualKeys;



    // Immutable configuration parameters.

    struct Parameters {
@@ -583,26 +597,36 @@ protected: 
        RawAbsoluteAxisInfo orientation;

    } mAxes;



    // The surface orientation and width and height set by configureSurface().

    int32_t mSurfaceOrientation;

    int32_t mSurfaceWidth, mSurfaceHeight;

    // Current and previous touch sample data.

    TouchData mCurrentTouch;

    TouchData mLastTouch;



    // The time the primary pointer last went down.

    nsecs_t mDownTime;



    struct LockedState {

        Vector<VirtualKey> virtualKeys;



        // The surface orientation and width and height set by configureSurfaceLocked().

        int32_t surfaceOrientation;

        int32_t surfaceWidth, surfaceHeight;



        // Translation and scaling factors, orientation-independent.

    int32_t mXOrigin;

    float mXScale;

    float mXPrecision;

        int32_t xOrigin;

        float xScale;

        float xPrecision;



    int32_t mYOrigin;

    float mYScale;

    float mYPrecision;

        int32_t yOrigin;

        float yScale;

        float yPrecision;



    int32_t mPressureOrigin;

    float mPressureScale;

        int32_t pressureOrigin;

        float pressureScale;



    int32_t mSizeOrigin;

    float mSizeScale;

        int32_t sizeOrigin;

        float sizeScale;



    float mOrientationScale;

        float orientationScale;



        // Oriented motion ranges for input device info.

        struct OrientedRanges {
@@ -615,35 +639,23 @@ protected: 
            InputDeviceInfo::MotionRange toolMajor;

            InputDeviceInfo::MotionRange toolMinor;

            InputDeviceInfo::MotionRange orientation;

    } mOrientedRanges;

        } orientedRanges;



        // Oriented dimensions and precision.

    float mOrientedSurfaceWidth, mOrientedSurfaceHeight;

    float mOrientedXPrecision, mOrientedYPrecision;



    // The touch data of the current sample being processed.

    TouchData mCurrentTouch;



    // The touch data of the previous sample that was processed.  This is updated

    // incrementally while the current sample is being processed.

    TouchData mLastTouch;



    // The time the primary pointer last went down.

    nsecs_t mDownTime;

        float orientedSurfaceWidth, orientedSurfaceHeight;

        float orientedXPrecision, orientedYPrecision;



        struct CurrentVirtualKeyState {

            bool down;

            nsecs_t downTime;

            int32_t keyCode;

            int32_t scanCode;

    } mCurrentVirtualKey;



    // Lock for virtual key state.

    Mutex mVirtualKeyLock; // methods use "Lvk" suffix

        } currentVirtualKey;

    } mLocked;



    virtual void configureAxes();

    virtual bool configureSurface();

    virtual void configureVirtualKeys();

    virtual bool configureSurfaceLocked();

    virtual void configureVirtualKeysLocked();



    enum TouchResult {

        // Dispatch the touch normally.
@@ -696,15 +708,19 @@ private: 
        uint64_t distance : 48; // squared distance

    };



    void initialize();

    void initializeLocked();



    TouchResult consumeOffScreenTouches(nsecs_t when, uint32_t policyFlags);

    void dispatchTouches(nsecs_t when, uint32_t policyFlags);

    void dispatchTouch(nsecs_t when, uint32_t policyFlags, TouchData* touch,

            BitSet32 idBits, uint32_t changedId, int32_t motionEventAction);



    bool isPointInsideSurface(int32_t x, int32_t y);

    const VirtualKey* findVirtualKeyHitLvk(int32_t x, int32_t y);

    void applyPolicyAndDispatchVirtualKey(nsecs_t when, uint32_t policyFlags,

            int32_t keyEventAction, int32_t keyEventFlags,

            int32_t keyCode, int32_t scanCode, nsecs_t downTime);



    bool isPointInsideSurfaceLocked(int32_t x, int32_t y);

    const VirtualKey* findVirtualKeyHitLocked(int32_t x, int32_t y);



    bool applyBadTouchFilter();

    bool applyJumpyTouchFilter();