Example usage for android.view.accessibility AccessibilityEvent TYPE_VIEW_HOVER_ENTER

List of usage examples for android.view.accessibility AccessibilityEvent TYPE_VIEW_HOVER_ENTER

  1. HOME
  2. Java
  3. android
  4. android.view.accessibility.*
  5. AccessibilityEvent
  6. TYPE_VIEW_HOVER_ENTER

Introduction

In this page you can find the example usage for android.view.accessibility AccessibilityEvent TYPE_VIEW_HOVER_ENTER.

Prototype

int TYPE_VIEW_HOVER_ENTER

To view the source code for android.view.accessibility AccessibilityEvent TYPE_VIEW_HOVER_ENTER.

Click Source Link

Document

Represents the event of a hover enter over a android.view.View .

Usage

From source file:com.android.utils.AccessibilityEventUtils.java

public static int[] getAllEventTypes() {
    return new int[] { AccessibilityEvent.TYPE_ANNOUNCEMENT, AccessibilityEvent.TYPE_ASSIST_READING_CONTEXT,
            AccessibilityEvent.TYPE_GESTURE_DETECTION_END, AccessibilityEvent.TYPE_GESTURE_DETECTION_START,
            AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED,
            AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_END,
            AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_START,
            AccessibilityEvent.TYPE_TOUCH_INTERACTION_END, AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
            AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED,
            AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED, AccessibilityEvent.TYPE_VIEW_CLICKED,
            AccessibilityEvent.TYPE_VIEW_CONTEXT_CLICKED, AccessibilityEvent.TYPE_VIEW_FOCUSED,
            AccessibilityEvent.TYPE_VIEW_HOVER_ENTER, AccessibilityEvent.TYPE_VIEW_HOVER_EXIT,
            AccessibilityEvent.TYPE_VIEW_LONG_CLICKED, AccessibilityEvent.TYPE_VIEW_SCROLLED,
            AccessibilityEvent.TYPE_VIEW_SELECTED, AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED,
            AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED,
            AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY,
            AccessibilityEvent.TYPE_WINDOWS_CHANGED, AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED,
            AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED };
}

From source file:com.google.android.marvin.mytalkback.ProcessorLongHover.java

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    final int eventType = event.getEventType();

    if ((eventType == AccessibilityEvent.TYPE_VIEW_HOVER_ENTER)
            || (eventType == AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_START)) {
        mIsTouchExploring = true;/*from  ww w. ja v  a 2 s  .  c  o m*/
    }

    if (eventType == AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_END) {
        mIsTouchExploring = false;
        cacheEnteredNode(null);
        cancelLongHover();
        return;
    }

    if (!mIsTouchExploring
            || ((eventType != TRIGGER_ACTION) && (eventType != AccessibilityEvent.TYPE_VIEW_HOVER_EXIT))) {
        return;
    }

    final AccessibilityRecordCompat record = new AccessibilityRecordCompat(event);
    final AccessibilityNodeInfoCompat source = record.getSource();

    if (source == null) {
        return;
    }

    if (eventType == TRIGGER_ACTION) {
        cacheEnteredNode(source);
        postLongHoverRunnable(event);
    } else if (eventType == AccessibilityEventCompat.TYPE_VIEW_HOVER_EXIT) {
        if (source.equals(mWaitingForExit)) {
            cancelLongHover();
        }
    }

    source.recycle();
}

From source file:com.android.screenspeak.eventprocessor.ProcessorAccessibilityHints.java

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    final int eventType = event.getEventType();

    if (eventType == AccessibilityEvent.TYPE_VIEW_HOVER_ENTER
            || eventType == AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_START) {
        mIsTouchExploring = true;// ww w . j  a v  a2  s.c  o m
    }

    if (eventType == AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_END
            || eventType == AccessibilityEvent.TYPE_VIEW_CLICKED) {
        mIsTouchExploring = false;
        cacheEnteredNode(null);
        cancelA11yHint();
        return;
    }

    if (!mIsTouchExploring || ((eventType != AccessibilityEventCompat.TYPE_VIEW_ACCESSIBILITY_FOCUSED)
            && (eventType != AccessibilityEvent.TYPE_VIEW_HOVER_EXIT))) {
        return;
    }

    final AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
    final AccessibilityNodeInfoCompat source = record.getSource();

    if (source == null) {
        return;
    }

    if (eventType == AccessibilityEventCompat.TYPE_VIEW_ACCESSIBILITY_FOCUSED) {
        cacheEnteredNode(source);
        String hint = getHintFromEvent(event);
        if (hint != null) {
            postA11yHintRunnable(hint);
        }
    } else if (eventType == AccessibilityEventCompat.TYPE_VIEW_HOVER_EXIT) {
        if (source.equals(mWaitingForExit)) {
            cancelA11yHint();
        }
    }

    source.recycle();
}

From source file:com.android.talkback.tutorial.TutorialMainFragment.java

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    if (mOffButton == null || mParentLayout == null) {
        return;/*from  w  ww.ja v  a 2 s . c  o  m*/
    }

    // There are three types of areas that we're detecting: the button area, areas of the
    // activity that are a11y-focusable, and areas of the activity that are blank.
    // 1) The HoverTrackingButton keeps track of the button area.
    // 2) The HoverTrackingLinearLayout keeps track of blank activity areas.
    // 3) We use TYPE_VIEW_HOVER_ENTER to track a11y-focusable activity areas.
    // The user must begin and end the touch interaction within the Turn TalkBack Off button
    // without moving their finger into other areas of the activity in order to turn TB off.

    switch (event.getEventType()) {
    case AccessibilityEvent.TYPE_TOUCH_INTERACTION_START:
        mOtherViewHovered = false;
        mOffButton.clearTracking();
        mParentLayout.clearTracking();
        break;
    case AccessibilityEvent.TYPE_TOUCH_INTERACTION_END:
        if (mOffButton.didHoverEnter() && !mParentLayout.didHoverEnter() && !mOtherViewHovered) {
            if (TalkBackService.getInstance() != null) {
                TalkBackService.getInstance().disableTalkBack();
            }
        }
        break;
    case AccessibilityEvent.TYPE_VIEW_HOVER_ENTER:
        CharSequence className = event.getClassName();
        // Hovering over the button gives an event with TUTORIAL_CLASS_NAME class.
        // But empty areas of the activity should be tracked by HoverTrackingLinearLayout.
        if (className == null || !className.equals(TUTORIAL_CLASS_NAME)) {
            mOtherViewHovered = true;
        }
        break;
    }
}

From source file:com.googlecode.eyesfree.brailleback.TreeDebugNavigationMode.java

@Override
public void onObserveAccessibilityEvent(AccessibilityEvent event) {
    AccessibilityNodeInfo source = event.getSource();
    if (source == null) {
        return;//w ww  .j  av a 2s .  co m
    }
    boolean isNewWindow = false;
    if (mCurrentNode == null || mCurrentNode.getWindowId() != source.getWindowId()) {
        isNewWindow = true;
    }
    int t = event.getEventType();
    boolean isInterestingEventType = false;
    if (t == AccessibilityEvent.TYPE_VIEW_SELECTED || t == AccessibilityEvent.TYPE_VIEW_FOCUSED
            || t == AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED
            || t != AccessibilityEvent.TYPE_VIEW_HOVER_ENTER) {
        isInterestingEventType = true;
    }
    if (isNewWindow || isInterestingEventType) {
        setPendingNode(source);
    }
}

From source file:com.google.android.marvin.mytalkback.ProcessorFocusAndSingleTap.java

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    if (!mAccessibilityManager.isTouchExplorationEnabled()) {
        // Don't manage focus when touch exploration is disabled.
        return;/*from ww  w .j  a v  a  2  s  . c  o  m*/
    }

    final AccessibilityRecordCompat record = new AccessibilityRecordCompat(event);

    switch (event.getEventType()) {
    case AccessibilityEvent.TYPE_VIEW_CLICKED:
        // Prevent conflicts between lift-to-type and single tap. This
        // is only necessary when a CLICKED event occurs during a touch
        // interaction sequence (e.g. before an INTERACTION_END event),
        // but it isn't harmful to call more often.
        cancelSingleTap();
        break;
    case AccessibilityEvent.TYPE_VIEW_FOCUSED:
        setFocusFromViewFocused(event, record);
        break;
    case AccessibilityEvent.TYPE_VIEW_SELECTED:
        setFocusFromViewSelected(event, record);
        break;
    case AccessibilityEvent.TYPE_VIEW_HOVER_ENTER:
        setFocusFromViewHoverEnter(record);
        break;
    case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
        handleWindowStateChange(event);
        break;
    case AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED:
        handleWindowContentChanged(record);
        break;
    case AccessibilityEvent.TYPE_VIEW_SCROLLED:
        handleViewScrolled(event, record);
        break;
    case AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_START:
        // This event type only exists on API 17+ (JB MR1).
        handleTouchInteractionStart(event);
        break;
    case AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_END:
        // This event type only exists on API 17+ (JB MR1).
        handleTouchInteractionEnd(event);
        break;
    }
}

From source file:com.google.android.marvin.talkback.ProcessorFocusAndSingleTap.java

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    if (!mAccessibilityManager.isTouchExplorationEnabled()) {
        // Don't manage focus when touch exploration is disabled.
        return;/* ww w  . j  a  v  a  2 s .  co m*/
    }

    final AccessibilityRecordCompat record = new AccessibilityRecordCompat(event);

    switch (event.getEventType()) {
    case AccessibilityEvent.TYPE_VIEW_CLICKED:
        // Prevent conflicts between lift-to-type and single tap. This
        // is only necessary when a CLICKED event occurs during a touch
        // interaction sequence (e.g. before an INTERACTION_END event),
        // but it isn't harmful to call more often.
        cancelSingleTap();
        break;
    case AccessibilityEvent.TYPE_VIEW_FOCUSED:
        setFocusFromViewFocused(event, record);
        break;
    case AccessibilityEvent.TYPE_VIEW_SELECTED:
        setFocusFromViewSelected(event, record);
        break;
    case AccessibilityEvent.TYPE_VIEW_HOVER_ENTER:
        final AccessibilityNodeInfoCompat touchedNode = record.getSource();
        try {
            if ((touchedNode != null) && !setFocusFromViewHoverEnter(touchedNode) && FEATURE_FLAG_EMPTY_SPACE) {
                mHandler.sendEmptyTouchAreaFeedbackDelayed(touchedNode);
            }
        } finally {
            AccessibilityNodeInfoUtils.recycleNodes(touchedNode);
        }

        break;
    case AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED:
        mHandler.cancelEmptyTouchAreaFeedback();
        break;
    case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
        handleWindowStateChange(event);
        break;
    case AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED:
        handleWindowContentChanged(record);
        break;
    case AccessibilityEvent.TYPE_VIEW_SCROLLED:
        handleViewScrolled(event, record);
        break;
    case AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_START:
        // This event type only exists on API 17+ (JB MR1).
        handleTouchInteractionStart(event);
        break;
    case AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_END:
        // This event type only exists on API 17+ (JB MR1).
        handleTouchInteractionEnd(event);
        break;
    }
}

From source file:com.android.yijiang.kzx.widget.betterpickers.TouchExplorationHelper.java

private void setCurrentItem(T item) {
    if (mCurrentItem == item) {
        return;//from  w w w.  j  a  v  a 2s .  com
    }

    if (mCurrentItem != null) {
        sendEventForItem(mCurrentItem, AccessibilityEvent.TYPE_VIEW_HOVER_EXIT);
    }

    mCurrentItem = item;

    if (mCurrentItem != null) {
        sendEventForItem(mCurrentItem, AccessibilityEvent.TYPE_VIEW_HOVER_ENTER);
    }
}

From source file:com.android.utils.ExploreByTouchHelper.java

/**
 * Sets the currently hovered item, sending hover accessibility events as
 * necessary to maintain the correct state.
 *
 * @param virtualViewId The virtual view id for the item currently being
 *            hovered, or {@code #INVALID_ID} if no item is hovered within
 *            the parent view./*from   www .j  av  a2s.co m*/
 */
private void setHoveredVirtualViewId(int virtualViewId) {
    if (mHoveredVirtualViewId == virtualViewId) {
        return;
    }

    final int previousVirtualViewId = mHoveredVirtualViewId;
    mHoveredVirtualViewId = virtualViewId;

    // Stay consistent with framework behavior by sending ENTER/EXIT pairs
    // in reverse order. This is accurate as of API 18.
    sendEventForVirtualViewId(virtualViewId, AccessibilityEvent.TYPE_VIEW_HOVER_ENTER);
    sendEventForVirtualViewId(previousVirtualViewId, AccessibilityEvent.TYPE_VIEW_HOVER_EXIT);
}

From source file:com.android.screenspeak.eventprocessor.ProcessorFocusAndSingleTap.java

@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
    if (!mAccessibilityManager.isTouchExplorationEnabled()) {
        // Don't manage focus when touch exploration is disabled.
        return;/*w  w w  .  j av a 2 s . c o m*/
    }

    final AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);

    switch (event.getEventType()) {
    case AccessibilityEvent.TYPE_VIEW_CLICKED:
        // Prevent conflicts between lift-to-type and single tap. This
        // is only necessary when a CLICKED event occurs during a touch
        // interaction sequence (e.g. before an INTERACTION_END event),
        // but it isn't harmful to call more often.
        cancelSingleTap();
        break;
    case AccessibilityEvent.TYPE_VIEW_FOCUSED:
    case AccessibilityEvent.TYPE_VIEW_SELECTED:
        if (!mFirstWindowFocusManager.shouldProcessFocusEvent(event)) {
            return;
        }
        boolean isViewFocusedEvent = (AccessibilityEvent.TYPE_VIEW_FOCUSED == event.getEventType());
        if (!setFocusOnView(record, isViewFocusedEvent)) {
            // It is possible that the only speakable child of source node is invisible
            // at the moment, but could be made visible when view scrolls, or window state
            // changes. Cache it now. And try to focus on the cached record on:
            // VIEW_SCROLLED, WINDOW_CONTENT_CHANGED, WINDOW_STATE_CHANGED.
            // The above 3 are the events that could affect view visibility.
            if (mCachedPotentiallyFocusableRecordQueue.size() == MAX_CACHED_FOCUSED_RECORD_QUEUE) {
                mCachedPotentiallyFocusableRecordQueue.remove().first.recycle();
            }

            mCachedPotentiallyFocusableRecordQueue
                    .add(new Pair<>(AccessibilityRecordCompat.obtain(record), event.getEventType()));
        } else {
            emptyCachedPotentialFocusQueue();
        }
        break;
    case AccessibilityEvent.TYPE_VIEW_HOVER_ENTER:
        final AccessibilityNodeInfoCompat touchedNode = record.getSource();
        try {
            if ((touchedNode != null) && !setFocusFromViewHoverEnter(touchedNode)) {
                mHandler.sendEmptyTouchAreaFeedbackDelayed(touchedNode);
            }
        } finally {
            AccessibilityNodeInfoUtils.recycleNodes(touchedNode);
        }

        break;
    case AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED:
        mHandler.cancelEmptyTouchAreaFeedback();
        AccessibilityNodeInfo source = event.getSource();
        if (source != null) {
            AccessibilityNodeInfoCompat compatSource = new AccessibilityNodeInfoCompat(source);
            mLastFocusedItem = AccessibilityNodeInfoCompat.obtain(compatSource);
        }
        break;
    case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
        mFirstWindowFocusManager.registerWindowChange(event);
        handleWindowStateChange(event);
        break;
    case AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED:
        handleWindowContentChanged();
        break;
    case AccessibilityEvent.TYPE_VIEW_SCROLLED:
        handleViewScrolled(event, record);
        break;
    case AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_START:
        // This event type only exists on API 17+ (JB MR1).
        handleTouchInteractionStart();
        break;
    case AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_END:
        // This event type only exists on API 17+ (JB MR1).
        handleTouchInteractionEnd();
        break;
    }
}