1 /*
2  * Copyright (C) 2019 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include "CancelationOptions.h"
20 #include "Entry.h"
21 
22 #include <utils/Timers.h>
23 #include <bitset>
24 
25 namespace android {
26 namespace inputdispatcher {
27 
28 static constexpr int32_t INVALID_POINTER_INDEX = -1;
29 
30 /* Tracks dispatched key and motion event state so that cancellation events can be
31  * synthesized when events are dropped. */
32 class InputState {
33 public:
34     explicit InputState(const IdGenerator& idGenerator);
35     ~InputState();
36 
37     // Returns true if the specified source is known to have received a hover enter
38     // motion event.
39     bool isHovering(DeviceId deviceId, uint32_t source, ui::LogicalDisplayId displayId) const;
40 
41     // Records tracking information for a key event that has just been published.
42     // Returns true if the event should be delivered, false if it is inconsistent
43     // and should be skipped.
44     bool trackKey(const KeyEntry& entry, int32_t flags);
45 
46     // Records tracking information for a motion event that has just been published.
47     // Returns true if the event should be delivered, false if it is inconsistent
48     // and should be skipped.
49     bool trackMotion(const MotionEntry& entry, int32_t flags);
50 
51     /**
52      * Return the PointerProperties and the PointerCoords for the last event, if found. Return
53      * std::nullopt if not found. We should not return std::vector<PointerCoords> in isolation,
54      * because the pointers can technically be stored in the vector in any order, so the
55      * PointerProperties are needed to specify the order in which the pointer coords are stored.
56      */
57     std::optional<std::pair<std::vector<PointerProperties>, std::vector<PointerCoords>>>
58     getPointersOfLastEvent(const MotionEntry& entry, bool hovering) const;
59 
60     // Create cancel events for the previous stream if the current motionEntry requires it.
61     std::unique_ptr<EventEntry> cancelConflictingInputStream(const MotionEntry& motionEntry);
62 
63     // Synthesizes cancelation events for the current state and resets the tracked state.
64     std::vector<std::unique_ptr<EventEntry>> synthesizeCancelationEvents(
65             nsecs_t currentTime, const CancelationOptions& options);
66 
67     // Synthesizes down events for the current state.
68     std::vector<std::unique_ptr<EventEntry>> synthesizePointerDownEvents(nsecs_t currentTime);
69 
70     // Clears the current state.
71     void clear();
72 
73     // Merges pointer-related parts of the input state into another instance.
74     void mergePointerStateTo(InputState& other);
75 
76     // Gets the fallback key associated with a keycode.
77     // Returns std::nullopt if none.
78     // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy.
79     std::optional<int32_t> getFallbackKey(int32_t originalKeyCode);
80 
81     // Sets the fallback key for a particular keycode.
82     void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode);
83 
84     // Removes the fallback key for a particular keycode.
85     void removeFallbackKey(int32_t originalKeyCode);
86 
getFallbackKeys()87     inline const std::map<int32_t, int32_t>& getFallbackKeys() const { return mFallbackKeys; }
88 
89 private:
90     struct KeyMemento {
91         DeviceId deviceId;
92         uint32_t source;
93         ui::LogicalDisplayId displayId{ui::LogicalDisplayId::INVALID};
94         int32_t keyCode;
95         int32_t scanCode;
96         int32_t metaState;
97         int32_t flags;
98         nsecs_t downTime;
99         uint32_t policyFlags;
100     };
101 
102     struct MotionMemento {
103         DeviceId deviceId;
104         uint32_t source;
105         ui::LogicalDisplayId displayId{ui::LogicalDisplayId::INVALID};
106         int32_t flags;
107         float xPrecision;
108         float yPrecision;
109         float xCursorPosition;
110         float yCursorPosition;
111         nsecs_t downTime;
112         std::vector<PointerProperties> pointerProperties;
113         std::vector<PointerCoords> pointerCoords;
114         // Track for which pointers the target doesn't know about.
115         int32_t firstNewPointerIdx = INVALID_POINTER_INDEX;
116         bool hovering;
117         uint32_t policyFlags;
118 
119         void setPointers(const MotionEntry& entry);
120         void mergePointerStateTo(MotionMemento& other) const;
121         size_t getPointerCount() const;
122     };
123 
124     const IdGenerator& mIdGenerator; // InputDispatcher owns it so we won't have dangling reference.
125 
126     std::vector<KeyMemento> mKeyMementos;
127     std::vector<MotionMemento> mMotionMementos;
128     std::map</*originalKeyCode*/int32_t, /*fallbackKeyCode*/int32_t> mFallbackKeys;
129 
130     ssize_t findKeyMemento(const KeyEntry& entry) const;
131     ssize_t findMotionMemento(const MotionEntry& entry, bool hovering) const;
132 
133     void addKeyMemento(const KeyEntry& entry, int32_t flags);
134     void addMotionMemento(const MotionEntry& entry, int32_t flags, bool hovering);
135 
136     static bool shouldCancelKey(const KeyMemento& memento, const CancelationOptions& options);
137     static bool shouldCancelMotion(const MotionMemento& memento, const CancelationOptions& options);
138     bool shouldCancelPreviousStream(const MotionEntry& motionEntry) const;
139     std::unique_ptr<MotionEntry> createCancelEntryForMemento(const MotionMemento& memento,
140                                                              nsecs_t eventTime) const;
141 
142     // Synthesizes pointer cancel events for a particular set of pointers.
143     std::vector<std::unique_ptr<MotionEntry>> synthesizeCancelationEventsForPointers(
144             const MotionMemento& memento, std::bitset<MAX_POINTER_ID + 1> pointerIds,
145             nsecs_t currentTime);
146     friend std::ostream& operator<<(std::ostream& out, const InputState& state);
147 };
148 
149 std::ostream& operator<<(std::ostream& out, const InputState& state);
150 
151 } // namespace inputdispatcher
152 } // namespace android
153