Lines Matching refs:event
47 * transforms the motion event stream by modifying, adding, replacing,
132 // Command for delayed sending of a hover enter event.
135 // Command for delayed sending of a hover exit event.
181 // The X of the previous event.
184 // The Y of the previous event.
253 // If we have not received an event then we are in initial
255 MotionEvent event = mReceivedPointerTracker.getLastReceivedEvent();
256 if (event != null) {
265 private void clear(MotionEvent event, int policyFlags) {
274 sendUpForInjectedDownPointers(event, policyFlags);
278 sendUpForInjectedDownPointers(event, policyFlags);
316 public void onMotionEvent(MotionEvent event, MotionEvent rawEvent, int policyFlags) {
318 Slog.d(LOG_TAG, "Received event: " + event + ", policyFlags=0x"
327 handleMotionEventStateTouchExploring(event, rawEvent, policyFlags);
330 handleMotionEventStateDragging(event, policyFlags);
333 handleMotionEventStateDelegating(event, policyFlags);
343 public void onAccessibilityEvent(AccessibilityEvent event) {
344 final int eventType = event.getEventType();
346 // The event for gesture end should be strictly after the
347 // last hover exit event.
354 // The event for touch interaction end should be strictly after the
375 mLastTouchedWindowId = event.getWindowId();
379 mNext.onAccessibilityEvent(event);
384 * Handles a motion event in touch exploring state.
386 * @param event The event to be handled.
387 * @param rawEvent The raw (unmodified) motion event.
388 * @param policyFlags The policy flags associated with the event.
390 private void handleMotionEventStateTouchExploring(MotionEvent event, MotionEvent rawEvent,
397 mDoubleTapDetector.onMotionEvent(event, policyFlags);
399 switch (event.getActionMasked()) {
433 // down we have already send the interaction start event.
434 if (event.getPointerCount() == 1) {
449 mPerformLongPressDelayed.post(event, policyFlags);
457 mSendHoverEnterDelayed.post(event, true, pointerIdBits, policyFlags);
467 final int pointerIndex = event.findPointerIndex(pointerId);
471 /* do nothing - no active pointers so we swallow the event */
507 // Send accessibility event to announce the start
517 sendMotionEvent(event, MotionEvent.ACTION_HOVER_MOVE,
544 sendMotionEvent(event, MotionEvent.ACTION_HOVER_MOVE, pointerIdBits,
582 if (isDraggingGesture(event)) {
587 event.setEdgeFlags(receivedTracker.getLastReceivedDownEdgeFlags());
588 sendMotionEvent(event, MotionEvent.ACTION_DOWN, pointerIdBits,
593 sendDownForAllActiveNotInjectedPointers(event, policyFlags);
615 sendDownForAllActiveNotInjectedPointers(event, policyFlags);
640 mSendHoverExitDelayed.post(event, false, pointerIdBits, policyFlags);
654 clear(event, policyFlags);
660 * Handles a motion event in dragging state.
662 * @param event The event to be handled.
663 * @param policyFlags The policy flags associated with the event.
665 private void handleMotionEventStateDragging(MotionEvent event, int policyFlags) {
667 switch (event.getActionMasked()) {
677 sendMotionEvent(event, MotionEvent.ACTION_UP, pointerIdBits, policyFlags);
679 sendDownForAllActiveNotInjectedPointers(event, policyFlags);
688 if (isDraggingGesture(event)) {
695 final int firstPtrIndex = event.findPointerIndex(pointerIds[0]);
696 final int secondPtrIndex = event.findPointerIndex(pointerIds[1]);
698 final float firstPtrX = event.getX(firstPtrIndex);
699 final float firstPtrY = event.getY(firstPtrIndex);
700 final float secondPtrX = event.getX(secondPtrIndex);
701 final float secondPtrY = event.getY(secondPtrIndex);
708 event.setLocation(deltaX / 2, deltaY / 2);
711 // If still dragging send a drag event.
712 sendMotionEvent(event, MotionEvent.ACTION_MOVE, pointerIdBits,
718 // Send an event to the end of the drag gesture.
719 sendMotionEvent(event, MotionEvent.ACTION_UP, pointerIdBits,
722 sendDownForAllActiveNotInjectedPointers(event, policyFlags);
727 // Send an event to the end of the drag gesture.
728 sendMotionEvent(event, MotionEvent.ACTION_UP, pointerIdBits,
731 sendDownForAllActiveNotInjectedPointers(event, policyFlags);
736 final int pointerId = event.getPointerId(event.getActionIndex());
739 // Send an event to the end of the drag gesture.
740 sendMotionEvent(event, MotionEvent.ACTION_UP, pointerIdBits, policyFlags);
748 final int pointerId = event.getPointerId(event.getActionIndex());
751 // Send an event to the end of the drag gesture.
752 sendMotionEvent(event, MotionEvent.ACTION_UP, pointerIdBits, policyFlags);
757 clear(event, policyFlags);
763 * Handles a motion event in delegating state.
765 * @param event The event to be handled.
766 * @param policyFlags The policy flags associated with the event.
768 private void handleMotionEventStateDelegating(MotionEvent event, int policyFlags) {
769 switch (event.getActionMasked()) {
780 MotionEvent prototype = MotionEvent.obtain(event);
800 clear(event, policyFlags);
803 // Deliver the event striping out inactive pointers.
804 sendMotionEventStripInactivePointers(event, policyFlags);
807 private void handleMotionEventGestureDetecting(MotionEvent event, int policyFlags) {
808 switch (event.getActionMasked()) {
810 final float x = event.getX();
811 final float y = event.getY();
814 mStrokeBuffer.add(new GesturePoint(x, y, event.getEventTime()));
817 final float x = event.getX();
818 final float y = event.getY();
824 mStrokeBuffer.add(new GesturePoint(x, y, event.getEventTime()));
836 float x = event.getX();
837 float y = event.getY();
838 mStrokeBuffer.add(new GesturePoint(x, y, event.getEventTime()));
865 clear(event, policyFlags);
871 * Sends an accessibility event of the given type.
873 * @param type The event type.
878 AccessibilityEvent event = AccessibilityEvent.obtain(type);
879 accessibilityManager.sendAccessibilityEvent(event);
896 * @param policyFlags The policy flags associated with the event.
919 // Do not send event for already delivered pointers.
933 * @param policyFlags The policy flags associated with the event.
936 MotionEvent event = mInjectedPointerTracker.getLastInjectedHoverEvent();
937 if (event != null && event.getActionMasked() != MotionEvent.ACTION_HOVER_EXIT) {
938 final int pointerIdBits = event.getPointerIdBits();
942 sendMotionEvent(event, MotionEvent.ACTION_HOVER_EXIT, pointerIdBits, policyFlags);
950 * @param policyFlags The policy flags associated with the event.
953 MotionEvent event = mInjectedPointerTracker.getLastInjectedHoverEvent();
954 if (event != null && event.getActionMasked() == MotionEvent.ACTION_HOVER_EXIT) {
955 final int pointerIdBits = event.getPointerIdBits();
957 sendMotionEvent(event, MotionEvent.ACTION_HOVER_ENTER, pointerIdBits, policyFlags);
966 * @param policyFlags The policy flags associated with the event.
985 * Sends a motion event by first stripping the inactive pointers.
987 * @param prototype The prototype from which to create the injected event.
988 * @param policyFlags The policy flags associated with the event.
993 // All pointers active therefore we just inject the event as is.
1017 // was active we keep the pointer data in the event.
1033 * @param policyFlags The policy flags associated with the event.
1044 * Sends an event.
1047 * @param action The action of the event.
1049 * @param policyFlags The policy flags associated with the event.
1055 MotionEvent event = null;
1057 event = prototype;
1059 event = prototype.split(pointerIdBits);
1062 event.setDownTime(event.getEventTime());
1064 event.setDownTime(mInjectedPointerTracker.getLastInjectedDownEventTime());
1074 final int remappedIndex = event.findPointerIndex(mLongPressingPointerId);
1075 final int pointerCount = event.getPointerCount();
1079 event.getPointerProperties(i, props[i]);
1080 event.getPointerCoords(i, coords[i]);
1086 MotionEvent remapped = MotionEvent.obtain(event.getDownTime(),
1087 event.getEventTime(), event.getAction(), event.getPointerCount(),
1088 props, coords, event.getMetaState(), event.getButtonState(),
1089 1.0f, 1.0f, event.getDeviceId(), event.getEdgeFlags(),
1090 event.getSource(), event.getFlags());
1091 if (event != prototype) {
1092 event.recycle();
1094 event = remapped;
1098 Slog.d(LOG_TAG, "Injecting event: " + event + ", policyFlags=0x"
1102 // Make sure that the user will see the event.
1105 // TODO: For now pass null for the raw event since the touch
1106 // explorer is the last event transformation and it does
1107 // not care about the raw event.
1108 mNext.onMotionEvent(event, null, policyFlags);
1111 mInjectedPointerTracker.onMotionEvent(event);
1113 if (event != prototype) {
1114 event.recycle();
1119 * Computes the action for an injected event based on a masked action
1158 public void onMotionEvent(MotionEvent event, int policyFlags) {
1159 final int actionIndex = event.getActionIndex();
1160 final int action = event.getActionMasked();
1165 && !GestureUtils.isSamePointerContext(mFirstTapEvent, event)) {
1168 mDownEvent = MotionEvent.obtain(event);
1175 if (!GestureUtils.isSamePointerContext(mDownEvent, event)) {
1179 if (GestureUtils.isTap(mDownEvent, event, mTapTimeout, mTouchSlop,
1182 event, mDoubleTapTimeout)) {
1183 mFirstTapEvent = MotionEvent.obtain(event);
1188 if (GestureUtils.isMultiTap(mFirstTapEvent, event, mDoubleTapTimeout,
1190 onDoubleTap(event, policyFlags);
1217 // Remove pending event deliveries.
1238 // No last touch explored event but there is accessibility focus in
1277 MotionEvent event = MotionEvent.obtain(secondTapUp.getDownTime(),
1281 sendActionDownAndUp(event, policyFlags);
1282 event.recycle();
1305 * @param event The event with the pointer data.
1308 private boolean isDraggingGesture(MotionEvent event) {
1313 final int firstPtrIndex = event.findPointerIndex(pointerIds[0]);
1314 final int secondPtrIndex = event.findPointerIndex(pointerIds[1]);
1316 final float firstPtrX = event.getX(firstPtrIndex);
1317 final float firstPtrY = event.getY(firstPtrIndex);
1318 final float secondPtrX = event.getX(secondPtrIndex);
1319 final float secondPtrY = event.getY(secondPtrIndex);
1426 // No last touch explored event but there is accessibility focus in
1547 Slog.d(LOG_TAG_SEND_HOVER_DELAYED, "Injecting motion event: "
1616 // The last injected hover event.
1619 // The last injected hover event used for performing clicks.
1623 * Processes an injected {@link MotionEvent} event.
1625 * @param event The event to process.
1627 public void onMotionEvent(MotionEvent event) {
1628 final int action = event.getActionMasked();
1632 final int pointerId = event.getPointerId(event.getActionIndex());
1635 mLastInjectedDownEventTime = event.getDownTime();
1639 final int pointerId = event.getPointerId(event.getActionIndex());
1652 mLastInjectedHoverEvent = MotionEvent.obtain(event);
1656 mLastInjectedHoverEventForClick = MotionEvent.obtain(event);
1672 * @return The time of the last injected down event.
1704 * @return The the last injected hover event.
1711 * @return The the last injected hover event.
1756 // The edge flags of the last received down event.
1807 * Processes a received {@link MotionEvent} event.
1809 * @param event The event to process.
1811 public void onMotionEvent(MotionEvent event) {
1815 mLastReceivedEvent = MotionEvent.obtain(event);
1817 final int action = event.getActionMasked();
1820 handleReceivedPointerDown(event.getActionIndex(), event);
1823 handleReceivedPointerDown(event.getActionIndex(), event);
1826 handleReceivedPointerMove(event);
1829 handleReceivedPointerUp(event.getActionIndex(), event);
1832 handleReceivedPointerUp(event.getActionIndex(), event);
1841 * @return The last received event.
1954 * @return The edge flags of the last received down event.
1994 * Handles a received pointer down event.
1997 * @param event The event to be handled.
1999 private void handleReceivedPointerDown(int pointerIndex, MotionEvent event) {
2000 final int pointerId = event.getPointerId(pointerIndex);
2009 mLastReceivedDownEdgeFlags = event.getEdgeFlags();
2012 mReceivedPointerDownX[pointerId] = event.getX(pointerIndex);
2013 mReceivedPointerDownY[pointerId] = event.getY(pointerIndex);
2014 mReceivedPointerDownTime[pointerId] = event.getEventTime();
2029 * Handles a received pointer move event.
2031 * @param event The event to be handled.
2033 private void handleReceivedPointerMove(MotionEvent event) {
2034 detectActivePointers(event);
2038 * Handles a received pointer up event.
2041 * @param event The event to be handled.
2043 private void handleReceivedPointerUp(int pointerIndex, MotionEvent event) {
2044 final int pointerId = event.getPointerId(pointerIndex);
2068 * Detects the active pointers in an event.
2070 * @param event The event to examine.
2072 private void detectActivePointers(MotionEvent event) {
2073 for (int i = 0, count = event.getPointerCount(); i < count; i++) {
2074 final int pointerId = event.getPointerId(i);
2082 final float pointerDeltaMove = computePointerDeltaMove(i, event);
2115 * @param event The event to examine.
2118 private float computePointerDeltaMove(int pointerIndex, MotionEvent event) {
2119 final int pointerId = event.getPointerId(pointerIndex);
2120 final float deltaX = event.getX(pointerIndex) - mReceivedPointerDownX[pointerId];
2121 final float deltaY = event.getY(pointerIndex) - mReceivedPointerDownY[pointerId];