← Back to branch summary

~mir-team/mir/in-process-egl+input-conglomeration

« back to all changes in this revision

Viewing changes to 3rd_party/android-input/android_pristine/frameworks/base/services/input/InputListener.h

Merged trunk and fixed issues

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/android-input/android_pristine/frameworks/base/services/input/InputListener.h
1
 
/*
2
 
 * Copyright (C) 2011 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_INPUT_LISTENER_H
18
 
#define _UI_INPUT_LISTENER_H
19
 
 
20
 
#include <androidfw/Input.h>
21
 
#include <utils/RefBase.h>
22
 
#include <utils/Vector.h>
23
 
 
24
 
namespace android {
25
 
 
26
 
class InputListenerInterface;
27
 
 
28
 
 
29
 
/* Superclass of all input event argument objects */
30
 
struct NotifyArgs {
31
 
    virtual ~NotifyArgs() { }
32
 
 
33
 
    virtual void notify(const sp<InputListenerInterface>& listener) const = 0;
34
 
};
35
 
 
36
 
 
37
 
/* Describes a configuration change event. */
38
 
struct NotifyConfigurationChangedArgs : public NotifyArgs {
39
 
    nsecs_t eventTime;
40
 
 
41
 
    inline NotifyConfigurationChangedArgs() { }
42
 
 
43
 
    NotifyConfigurationChangedArgs(nsecs_t eventTime);
44
 
 
45
 
    NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other);
46
 
 
47
 
    virtual ~NotifyConfigurationChangedArgs() { }
48
 
 
49
 
    virtual void notify(const sp<InputListenerInterface>& listener) const;
50
 
};
51
 
 
52
 
 
53
 
/* Describes a key event. */
54
 
struct NotifyKeyArgs : public NotifyArgs {
55
 
    nsecs_t eventTime;
56
 
    int32_t deviceId;
57
 
    uint32_t source;
58
 
    uint32_t policyFlags;
59
 
    int32_t action;
60
 
    int32_t flags;
61
 
    int32_t keyCode;
62
 
    int32_t scanCode;
63
 
    int32_t metaState;
64
 
    nsecs_t downTime;
65
 
 
66
 
    inline NotifyKeyArgs() { }
67
 
 
68
 
    NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
69
 
            int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
70
 
            int32_t metaState, nsecs_t downTime);
71
 
 
72
 
    NotifyKeyArgs(const NotifyKeyArgs& other);
73
 
 
74
 
    virtual ~NotifyKeyArgs() { }
75
 
 
76
 
    virtual void notify(const sp<InputListenerInterface>& listener) const;
77
 
};
78
 
 
79
 
 
80
 
/* Describes a motion event. */
81
 
struct NotifyMotionArgs : public NotifyArgs {
82
 
    nsecs_t eventTime;
83
 
    int32_t deviceId;
84
 
    uint32_t source;
85
 
    uint32_t policyFlags;
86
 
    int32_t action;
87
 
    int32_t flags;
88
 
    int32_t metaState;
89
 
    int32_t buttonState;
90
 
    int32_t edgeFlags;
91
 
    uint32_t pointerCount;
92
 
    PointerProperties pointerProperties[MAX_POINTERS];
93
 
    PointerCoords pointerCoords[MAX_POINTERS];
94
 
    float xPrecision;
95
 
    float yPrecision;
96
 
    nsecs_t downTime;
97
 
 
98
 
    inline NotifyMotionArgs() { }
99
 
 
100
 
    NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
101
 
            int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
102
 
            int32_t edgeFlags, uint32_t pointerCount,
103
 
            const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
104
 
            float xPrecision, float yPrecision, nsecs_t downTime);
105
 
 
106
 
    NotifyMotionArgs(const NotifyMotionArgs& other);
107
 
 
108
 
    virtual ~NotifyMotionArgs() { }
109
 
 
110
 
    virtual void notify(const sp<InputListenerInterface>& listener) const;
111
 
};
112
 
 
113
 
 
114
 
/* Describes a switch event. */
115
 
struct NotifySwitchArgs : public NotifyArgs {
116
 
    nsecs_t eventTime;
117
 
    uint32_t policyFlags;
118
 
    int32_t switchCode;
119
 
    int32_t switchValue;
120
 
 
121
 
    inline NotifySwitchArgs() { }
122
 
 
123
 
    NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,
124
 
            int32_t switchCode, int32_t switchValue);
125
 
 
126
 
    NotifySwitchArgs(const NotifySwitchArgs& other);
127
 
 
128
 
    virtual ~NotifySwitchArgs() { }
129
 
 
130
 
    virtual void notify(const sp<InputListenerInterface>& listener) const;
131
 
};
132
 
 
133
 
 
134
 
/* Describes a device reset event, such as when a device is added,
135
 
 * reconfigured, or removed. */
136
 
struct NotifyDeviceResetArgs : public NotifyArgs {
137
 
    nsecs_t eventTime;
138
 
    int32_t deviceId;
139
 
 
140
 
    inline NotifyDeviceResetArgs() { }
141
 
 
142
 
    NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId);
143
 
 
144
 
    NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other);
145
 
 
146
 
    virtual ~NotifyDeviceResetArgs() { }
147
 
 
148
 
    virtual void notify(const sp<InputListenerInterface>& listener) const;
149
 
};
150
 
 
151
 
 
152
 
/*
153
 
 * The interface used by the InputReader to notify the InputListener about input events.
154
 
 */
155
 
class InputListenerInterface : public virtual RefBase {
156
 
protected:
157
 
    InputListenerInterface() { }
158
 
    virtual ~InputListenerInterface() { }
159
 
 
160
 
public:
161
 
    virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) = 0;
162
 
    virtual void notifyKey(const NotifyKeyArgs* args) = 0;
163
 
    virtual void notifyMotion(const NotifyMotionArgs* args) = 0;
164
 
    virtual void notifySwitch(const NotifySwitchArgs* args) = 0;
165
 
    virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) = 0;
166
 
};
167
 
 
168
 
 
169
 
/*
170
 
 * An implementation of the listener interface that queues up and defers dispatch
171
 
 * of decoded events until flushed.
172
 
 */
173
 
class QueuedInputListener : public InputListenerInterface {
174
 
protected:
175
 
    virtual ~QueuedInputListener();
176
 
 
177
 
public:
178
 
    QueuedInputListener(const sp<InputListenerInterface>& innerListener);
179
 
 
180
 
    virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
181
 
    virtual void notifyKey(const NotifyKeyArgs* args);
182
 
    virtual void notifyMotion(const NotifyMotionArgs* args);
183
 
    virtual void notifySwitch(const NotifySwitchArgs* args);
184
 
    virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
185
 
 
186
 
    void flush();
187
 
 
188
 
private:
189
 
    sp<InputListenerInterface> mInnerListener;
190
 
    Vector<NotifyArgs*> mArgsQueue;
191
 
};
192
 
 
193
 
} // namespace android
194
 
 
195
 
#endif // _UI_INPUT_LISTENER_H