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 #ifndef _UI_INPUTREADER_INPUT_MAPPER_H
18 #define _UI_INPUTREADER_INPUT_MAPPER_H
19 
20 #include "EventHub.h"
21 #include "InputDevice.h"
22 #include "InputListener.h"
23 #include "InputReaderContext.h"
24 #include "StylusState.h"
25 
26 namespace android {
27 
28 /* An input mapper transforms raw input events into cooked event data.
29  * A single input device can have multiple associated input mappers in order to interpret
30  * different classes of events.
31  *
32  * InputMapper lifecycle:
33  * - create
34  * - configure with 0 changes
35  * - reset
36  * - process, process, process (may occasionally reconfigure with non-zero changes or reset)
37  * - reset
38  * - destroy
39  */
40 class InputMapper {
41 public:
42     explicit InputMapper(InputDevice* device);
43     virtual ~InputMapper();
44 
getDevice()45     inline InputDevice* getDevice() { return mDevice; }
getDeviceId()46     inline int32_t getDeviceId() { return mDevice->getId(); }
getDeviceName()47     inline const std::string getDeviceName() { return mDevice->getName(); }
getContext()48     inline InputReaderContext* getContext() { return mContext; }
getPolicy()49     inline InputReaderPolicyInterface* getPolicy() { return mContext->getPolicy(); }
getListener()50     inline InputListenerInterface* getListener() { return mContext->getListener(); }
getEventHub()51     inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
52 
53     virtual uint32_t getSources() = 0;
54     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
55     virtual void dump(std::string& dump);
56     virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
57     virtual void reset(nsecs_t when);
58     virtual void process(const RawEvent* rawEvent) = 0;
59     virtual void timeoutExpired(nsecs_t when);
60 
61     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
62     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
63     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
64     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
65                                        const int32_t* keyCodes, uint8_t* outFlags);
66     virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, int32_t token);
67     virtual void cancelVibrate(int32_t token);
68     virtual void cancelTouch(nsecs_t when);
69 
70     virtual int32_t getMetaState();
71     virtual void updateMetaState(int32_t keyCode);
72 
73     virtual void updateExternalStylusState(const StylusState& state);
74 
75     virtual void fadePointer();
getAssociatedDisplay()76     virtual std::optional<int32_t> getAssociatedDisplay() { return std::nullopt; }
77 
78 protected:
79     InputDevice* mDevice;
80     InputReaderContext* mContext;
81 
82     status_t getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo);
83     void bumpGeneration();
84 
85     static void dumpRawAbsoluteAxisInfo(std::string& dump, const RawAbsoluteAxisInfo& axis,
86                                         const char* name);
87     static void dumpStylusState(std::string& dump, const StylusState& state);
88 };
89 
90 } // namespace android
91 
92 #endif // _UI_INPUTREADER_INPUT_MAPPER_H
93