private void addKeyState(int deviceId, int source, int keyCode) { android.view.InputEventConsistencyVerifier.KeyState state = android.view.InputEventConsistencyVerifier .KeyState.obtain(deviceId, source, keyCode); state.next = mKeyStateList; mKeyStateList = state; }
private android.view.InputEventConsistencyVerifier.KeyState findKeyState(int deviceId , int source, int keyCode, bool remove) { android.view.InputEventConsistencyVerifier.KeyState last = null; android.view.InputEventConsistencyVerifier.KeyState state = mKeyStateList; while (state != null) { if (state.deviceId == deviceId && state.source == source && state.keyCode == keyCode) { if (remove) { if (last != null) { last.next = state.next; } else { mKeyStateList = state.next; } state.next = null; } return(state); } last = state; state = state.next; } return(null); }
public void recycle() { lock (mRecycledListLock) { next = mRecycledList; mRecycledList = next; } }
/// <summary>Resets the state of the input event consistency verifier.</summary> /// <remarks>Resets the state of the input event consistency verifier.</remarks> public void reset() { mLastEvent = null; mLastNestingLevel = 0; mTrackballDown = false; mTrackballUnhandled = false; mTouchEventStreamPointers = 0; mTouchEventStreamIsTainted = false; mTouchEventStreamUnhandled = false; mHoverEntered = false; while (mKeyStateList != null) { android.view.InputEventConsistencyVerifier.KeyState state = mKeyStateList; mKeyStateList = state.next; state.recycle(); } }
/// <summary> /// Notifies the verifier that a given event was unhandled and the rest of the /// trace for the event should be ignored. /// </summary> /// <remarks> /// Notifies the verifier that a given event was unhandled and the rest of the /// trace for the event should be ignored. /// This method should only be called if the event was previously checked by /// the consistency verifier using /// <see cref="onInputEvent(InputEvent, int)">onInputEvent(InputEvent, int)</see> /// and other methods. /// </remarks> /// <param name="event">The event.</param> /// <param name="nestingLevel"> /// The nesting level: 0 if called from the base class, /// or 1 from a subclass. If the event was already checked by this consistency verifier /// at a higher nesting level, it will not be checked again. Used to handle the situation /// where a subclass dispatching method delegates to its superclass's dispatching method /// and both dispatching methods call into the consistency verifier. /// </param> public void onUnhandledEvent(android.view.InputEvent @event, int nestingLevel) { if (nestingLevel != mLastNestingLevel) { return; } if (mRecentEventsUnhandled != null) { mRecentEventsUnhandled[mMostRecentEventIndex] = true; } if (@event is android.view.KeyEvent) { android.view.KeyEvent keyEvent = (android.view.KeyEvent)@event; int deviceId = keyEvent.getDeviceId(); int source = keyEvent.getSource(); int keyCode = keyEvent.getKeyCode(); android.view.InputEventConsistencyVerifier.KeyState state = findKeyState(deviceId , source, keyCode, false); if (state != null) { state.unhandled = true; } } else { android.view.MotionEvent motionEvent = (android.view.MotionEvent)@event; if (motionEvent.isTouchEvent()) { mTouchEventStreamUnhandled = true; } else { if ((motionEvent.getSource() & android.view.InputDevice.SOURCE_CLASS_TRACKBALL) != 0) { if (mTrackballDown) { mTrackballUnhandled = true; } } } } }
public static android.view.InputEventConsistencyVerifier.KeyState obtain(int deviceId , int source, int keyCode) { android.view.InputEventConsistencyVerifier.KeyState state; lock (mRecycledListLock) { state = mRecycledList; if (state != null) { mRecycledList = state.next; } else { state = new android.view.InputEventConsistencyVerifier.KeyState(); } } state.deviceId = deviceId; state.source = source; state.keyCode = keyCode; state.unhandled = false; return(state); }
public static android.view.InputEventConsistencyVerifier.KeyState obtain(int deviceId , int source, int keyCode) { android.view.InputEventConsistencyVerifier.KeyState state; lock (mRecycledListLock) { state = mRecycledList; if (state != null) { mRecycledList = state.next; } else { state = new android.view.InputEventConsistencyVerifier.KeyState(); } } state.deviceId = deviceId; state.source = source; state.keyCode = keyCode; state.unhandled = false; return state; }
private android.view.InputEventConsistencyVerifier.KeyState findKeyState(int deviceId , int source, int keyCode, bool remove) { android.view.InputEventConsistencyVerifier.KeyState last = null; android.view.InputEventConsistencyVerifier.KeyState state = mKeyStateList; while (state != null) { if (state.deviceId == deviceId && state.source == source && state.keyCode == keyCode) { if (remove) { if (last != null) { last.next = state.next; } else { mKeyStateList = state.next; } state.next = null; } return state; } last = state; state = state.next; } return null; }
/// <summary>Checks a key event.</summary> /// <remarks>Checks a key event.</remarks> /// <param name="event">The event.</param> /// <param name="nestingLevel"> /// The nesting level: 0 if called from the base class, /// or 1 from a subclass. If the event was already checked by this consistency verifier /// at a higher nesting level, it will not be checked again. Used to handle the situation /// where a subclass dispatching method delegates to its superclass's dispatching method /// and both dispatching methods call into the consistency verifier. /// </param> public void onKeyEvent(android.view.KeyEvent @event, int nestingLevel) { if (!startEvent(@event, nestingLevel, EVENT_TYPE_KEY)) { return; } try { ensureMetaStateIsNormalized(@event.getMetaState()); int action = @event.getAction(); int deviceId = @event.getDeviceId(); int source = @event.getSource(); int keyCode = @event.getKeyCode(); switch (action) { case android.view.KeyEvent.ACTION_DOWN: { android.view.InputEventConsistencyVerifier.KeyState state = findKeyState(deviceId , source, keyCode, false); if (state != null) { // If the key is already down, ensure it is a repeat. // We don't perform this check when processing raw device input // because the input dispatcher itself is responsible for setting // the key repeat count before it delivers input events. if (state.unhandled) { state.unhandled = false; } else { if ((mFlags & FLAG_RAW_DEVICE_INPUT) == 0 && @event.getRepeatCount() == 0) { problem("ACTION_DOWN but key is already down and this event " + "is not a key repeat." ); } } } else { addKeyState(deviceId, source, keyCode); } break; } case android.view.KeyEvent.ACTION_UP: { android.view.InputEventConsistencyVerifier.KeyState state = findKeyState(deviceId , source, keyCode, true); if (state == null) { problem("ACTION_UP but key was not down."); } else { state.recycle(); } break; } case android.view.KeyEvent.ACTION_MULTIPLE: { break; } default: { problem("Invalid action " + android.view.KeyEvent.actionToString(action) + " for key event." ); break; } } } finally { finishEvent(); } }