1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
package org.robolectric.shadows;
import static android.os.Build.VERSION.SDK_INT;
import static android.os.Build.VERSION_CODES.KITKAT;
import static android.os.Build.VERSION_CODES.R;
import static android.os.Build.VERSION_CODES.TIRAMISU;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.robolectric.util.reflector.Reflector.reflector;
import android.hardware.input.InputManager;
import android.util.SparseArray;
import android.view.InputDevice;
import android.view.InputEvent;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.VerifiedKeyEvent;
import android.view.VerifiedMotionEvent;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.annotation.RealObject;
import org.robolectric.annotation.Resetter;
import org.robolectric.util.ReflectionHelpers;
import org.robolectric.util.reflector.Accessor;
import org.robolectric.util.reflector.ForType;
import org.robolectric.versioning.AndroidVersions.U;
/** Shadow for {@link InputManager} */
@Implements(value = InputManager.class, looseSignatures = true)
public class ShadowInputManager {
@RealObject InputManager realInputManager;
@Implementation
protected boolean injectInputEvent(InputEvent event, int mode) {
// ignore
return true;
}
@Implementation(minSdk = KITKAT)
protected boolean[] deviceHasKeys(int id, int[] keyCodes) {
return new boolean[keyCodes.length];
}
/** Used in {@link InputDevice#getDeviceIds()} */
@Implementation
protected int[] getInputDeviceIds() {
return new int[0];
}
@Implementation(maxSdk = TIRAMISU)
protected void populateInputDevicesLocked() throws ClassNotFoundException {
if (ReflectionHelpers.getField(realInputManager, "mInputDevicesChangedListener") == null) {
ReflectionHelpers.setField(
realInputManager,
"mInputDevicesChangedListener",
ReflectionHelpers.callConstructor(
Class.forName("android.hardware.input.InputManager$InputDevicesChangedListener")));
}
if (getInputDevices() == null) {
final int[] ids = realInputManager.getInputDeviceIds();
SparseArray<InputDevice> inputDevices = new SparseArray<>();
for (int i = 0; i < ids.length; i++) {
inputDevices.put(ids[i], null);
}
setInputDevices(inputDevices);
}
}
private SparseArray<InputDevice> getInputDevices() {
return reflector(InputManagerReflector.class, realInputManager).getInputDevices();
}
private void setInputDevices(SparseArray<InputDevice> devices) {
reflector(InputManagerReflector.class, realInputManager).setInputDevices(devices);
}
/**
* Provides a local java implementation, since the real implementation is in system server +
* native code.
*/
@Implementation(minSdk = R)
protected Object verifyInputEvent(Object inputEvent) {
if (inputEvent instanceof MotionEvent) {
MotionEvent motionEvent = (MotionEvent) inputEvent;
return new VerifiedMotionEvent(
motionEvent.getDeviceId(),
MILLISECONDS.toNanos(motionEvent.getEventTime()),
motionEvent.getSource(),
motionEvent.getDisplayId(),
motionEvent.getRawX(),
motionEvent.getRawY(),
motionEvent.getActionMasked(),
MILLISECONDS.toNanos(motionEvent.getDownTime()),
motionEvent.getFlags(),
motionEvent.getMetaState(),
motionEvent.getButtonState());
} else if (inputEvent instanceof KeyEvent) {
KeyEvent keyEvent = (KeyEvent) inputEvent;
return new VerifiedKeyEvent(
keyEvent.getDeviceId(),
MILLISECONDS.toNanos(keyEvent.getEventTime()),
keyEvent.getSource(),
keyEvent.getDisplayId(),
keyEvent.getAction(),
MILLISECONDS.toNanos(keyEvent.getDownTime()),
keyEvent.getFlags(),
keyEvent.getKeyCode(),
keyEvent.getScanCode(),
keyEvent.getMetaState(),
keyEvent.getRepeatCount());
} else {
throw new IllegalArgumentException("unknown input event: " + inputEvent.getClass().getName());
}
}
@Resetter
public static void reset() {
if (SDK_INT < U.SDK_INT) {
ReflectionHelpers.setStaticField(InputManager.class, "sInstance", null);
}
}
@ForType(InputManager.class)
interface InputManagerReflector {
@Accessor("mInputDevices")
SparseArray<InputDevice> getInputDevices();
@Accessor("mInputDevices")
void setInputDevices(SparseArray<InputDevice> devices);
}
}
|
