android.support.v4.view.accessibility.AccessibilityNodeInfoCompat

Here are the examples of the java api class android.support.v4.view.accessibility.AccessibilityNodeInfoCompat taken from open source projects.

1. AccessibilityNodeInfoUtilsTest#searchFromBfsNodeMatchesChild_shouldReturnChild()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void searchFromBfsNodeMatchesChild_shouldReturnChild() {
    AccessibilityNodeInfo parent = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo child = AccessibilityNodeInfo.obtain();
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parent)).addChild(child);
    AccessibilityNodeInfoCompat parentCompat = new AccessibilityNodeInfoCompat(parent);
    AccessibilityNodeInfoCompat childCompat = new AccessibilityNodeInfoCompat(child);
    parent.setFocusable(false);
    child.setFocusable(true);
    AccessibilityNodeInfoCompat returned = AccessibilityNodeInfoUtils.searchFromBfs(parentCompat, focusableFilter);
    assertEquals(childCompat, returned);
    parentCompat.recycle();
    childCompat.recycle();
    returned.recycle();
}

2. CursorGranularityManagerTest#keepGranularityBetweenNodesWithLackOfGranularityTest()

Project: talkback
File: CursorGranularityManagerTest.java
@Test
public void keepGranularityBetweenNodesWithLackOfGranularityTest() {
    AccessibilityNodeInfoCompat node1 = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
    AccessibilityNodeInfoCompat node2 = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE);
    AccessibilityNodeInfoCompat node3 = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
    assertTrue(mGranularityManager.setGranularityAt(node1, CursorGranularity.CHARACTER));
    mGranularityManager.onNodeFocused(node2);
    assertEquals(CursorGranularity.DEFAULT, mGranularityManager.getCurrentGranularity());
    mGranularityManager.onNodeFocused(node3);
    assertEquals(CursorGranularity.CHARACTER, mGranularityManager.getCurrentGranularity());
    node1.recycle();
    node2.recycle();
    node3.recycle();
}

3. AccessibilityNodeInfoUtilsTest#hasAncestorWithSameAncestor_shouldReturnTrue()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void hasAncestorWithSameAncestor_shouldReturnTrue() {
    AccessibilityNodeInfoCompat targetAncestor = AccessibilityNodeInfoCompat.obtain();
    AccessibilityNodeInfoCompat childNode = AccessibilityNodeInfoCompat.obtain();
    ((ShadowAccessibilityNodeInfoCompat) ShadowExtractor.extract(targetAncestor)).addChild(childNode);
    assertTrue(AccessibilityNodeInfoUtils.hasAncestor(childNode, targetAncestor));
    targetAncestor.recycle();
    childNode.recycle();
}

4. AccessibilityNodeInfoUtilsTest#getRootForNonRootNode_shouldReturnRootNode()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void getRootForNonRootNode_shouldReturnRootNode() {
    AccessibilityNodeInfo level1Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level2Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level3Node = AccessibilityNodeInfo.obtain();
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level1Node)).addChild(level2Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level2Node)).addChild(level3Node);
    AccessibilityNodeInfoCompat startNode = new AccessibilityNodeInfoCompat(level3Node);
    AccessibilityNodeInfoCompat targetNode = new AccessibilityNodeInfoCompat(level1Node);
    AccessibilityNodeInfoCompat rootNode = AccessibilityNodeInfoUtils.getRoot(startNode);
    assertEquals(targetNode, rootNode);
    level1Node.recycle();
    level2Node.recycle();
    level3Node.recycle();
    rootNode.recycle();
}

5. CursorGranularityManagerTest#keepGranularityBetweenNodesWithGranularityTest()

Project: talkback
File: CursorGranularityManagerTest.java
@Test
public void keepGranularityBetweenNodesWithGranularityTest() {
    AccessibilityNodeInfoCompat node1 = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
    AccessibilityNodeInfoCompat node2 = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
    assertTrue(mGranularityManager.setGranularityAt(node1, CursorGranularity.CHARACTER));
    mGranularityManager.onNodeFocused(node2);
    assertEquals(CursorGranularity.CHARACTER, mGranularityManager.getCurrentGranularity());
    node1.recycle();
    node2.recycle();
}

6. AccessibilityNodeInfoUtilsTest#testInstrumentation()

Project: brailleback
File: AccessibilityNodeInfoUtilsTest.java
public void testInstrumentation() {
    setContentView(R.layout.non_speaking_container);
    final AccessibilityNodeInfoCompat container = getNodeForId(R.id.container);
    assertNotNull("Obtained container", container);
    final AccessibilityNodeInfoCompat textView = getNodeForId(R.id.textView);
    assertNotNull("Obtained text view", textView);
    final AccessibilityNodeInfoCompat parent = textView.getParent();
    assertNotNull("Text view has a parent node", parent);
    final AccessibilityNodeInfoCompat child = container.getChild(0);
    assertNotNull("Container has a child node", child);
    assertEquals("Container is text view's parent", container, parent);
    assertEquals("Text view is container's child", textView, child);
    AccessibilityNodeInfoUtils.recycleNodes(container, textView, parent, child);
}

7. OptionManagerTest#testScrollWithParent_shouldScrollAndClearFocus()

Project: talkback
File: OptionManagerTest.java
@Test
public void testScrollWithParent_shouldScrollAndClearFocus() {
    AccessibilityNodeInfoCompat parent = AccessibilityNodeInfoCompat.obtain();
    ((ShadowAccessibilityNodeInfoCompat) ShadowExtractor.extract(parent)).addChild(mCompat1);
    ShadowAccessibilityNodeInfo shadowParent = (ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parent.getInfo());
    parent.setScrollable(true);
    mActionNode1.recycle();
    mActionNode1 = new AccessibilityNodeActionNode(mCompat1, new AccessibilityNodeInfoCompat.AccessibilityActionCompat(AccessibilityNodeInfoCompat.ACTION_CLICK, "label1"));
    mSelectionNode = new OptionScanSelectionNode(mActionNode1, mActionNode2);
    mOptionManager.clearFocusIfNewTree(mSelectionNode);
    mOptionManager.selectOption(0);
    mOptionManager.performScrollAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD);
    assertEquals(0, mShadowInfo1.getPerformedActions().size());
    List<Integer> parentActions = shadowParent.getPerformedActions();
    assertEquals(1, parentActions.size());
    assertEquals(new Integer(AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD), parentActions.get(0));
    verify(mOverlayController, times(3)).clearOverlay();
    parent.recycle();
}

8. OrderedTraversalController#getParentsThatAreMovedBeforeOrSameNode()

Project: talkback
File: OrderedTraversalController.java
/**
     * This method is called before moving subtree. It checks if parent of that node was moved
     * on its place because it has before property to that node. In that case parent node should
     * be moved with movingTree node.
     * @return top node that should be moved with movingTree node.
     */
private WorkingTree getParentsThatAreMovedBeforeOrSameNode(WorkingTree movingTree) {
    WorkingTree parent = movingTree.getParent();
    if (parent == null) {
        return movingTree;
    }
    AccessibilityNodeInfoCompat parentNode = parent.getNode();
    AccessibilityNodeInfoCompat parentNodeBefore = getTraversalBefore(parentNode);
    if (parentNodeBefore == null) {
        return movingTree;
    }
    if (parentNodeBefore.equals(movingTree.getNode())) {
        return getParentsThatAreMovedBeforeOrSameNode(parent);
    }
    return movingTree;
}

9. ExploreByTouchHelper#getNodeForRoot()

Project: talkback
File: ExploreByTouchHelper.java
/**
     * Constructs and returns an {@link AccessibilityNodeInfoCompat} for the
     * parent view populated with its virtual descendants.
     *
     * @return An {@link AccessibilityNodeInfoCompat} for the parent view.
     */
private AccessibilityNodeInfoCompat getNodeForRoot() {
    // The root node is identical to the parent node, except that it is a
    // child of the parent view and is populated with virtual descendants.
    final AccessibilityNodeInfoCompat node = AccessibilityNodeInfoCompat.obtain(mHost);
    ViewCompat.onInitializeAccessibilityNodeInfo(mHost, node);
    // Add the virtual descendants.
    final LinkedList<Integer> virtualViewIds = new LinkedList<>();
    getVisibleVirtualViewIds(virtualViewIds);
    for (Integer virtualViewId : virtualViewIds) {
        node.addChild(mHost, virtualViewId);
    }
    // Set up the node as a child of the parent.
    node.setParent(mHost);
    node.setSource(mHost, ROOT_ID);
    return node;
}

10. ExploreByTouchHelper#getNodeForRoot()

Project: brailleback
File: ExploreByTouchHelper.java
/**
     * Constructs and returns an {@link AccessibilityNodeInfoCompat} for the
     * parent view populated with its virtual descendants.
     *
     * @return An {@link AccessibilityNodeInfoCompat} for the parent view.
     */
private AccessibilityNodeInfoCompat getNodeForRoot() {
    // The root node is identical to the parent node, except that it is a
    // child of the parent view and is populated with virtual descendants.
    final AccessibilityNodeInfoCompat node = AccessibilityNodeInfoCompat.obtain(mHost);
    ViewCompat.onInitializeAccessibilityNodeInfo(mHost, node);
    // Add the virtual descendants.
    final LinkedList<Integer> virtualViewIds = new LinkedList<Integer>();
    getVisibleVirtualViewIds(virtualViewIds);
    for (Integer virtualViewId : virtualViewIds) {
        node.addChild(mHost, virtualViewId);
    }
    // Set up the node as a child of the parent.
    node.setParent(mHost);
    node.setSource(mHost, ROOT_ID);
    return node;
}

11. SearchNavigationModeTest#testToggleOff()

Project: brailleback
File: SearchNavigationModeTest.java
public void testToggleOff() throws Exception {
    // Set initial focus.
    AccessibilityNodeInfoCompat initial = getNodeForId(R.id.button1);
    assertTrue(initial.performAction(AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS));
    mSearchNavMode.setInitialNodeToCurrent();
    mSearchNavMode.onActivate();
    AccessibilityNodeInfoCompat root = getNodeForId(R.id.top);
    assertNotNull(root);
    // Search for a node.
    mSearchNavMode.setQueryTextForTest("xy");
    sendInputEvent(BrailleInputEvent.CMD_NAV_ITEM_NEXT);
    assertFocusedNodeText("xyy", root);
    // Test toggling off. Should reset focus back to the initial.
    sendInputEvent(BrailleInputEvent.CMD_TOGGLE_INCREMENTAL_SEARCH);
    assertFalse(mSearchActive);
    AccessibilityNodeInfoCompat focused = getFocusedNode(root);
    assertEquals(initial, focused);
}

12. IMENavigationMode#getFocusedNode()

Project: brailleback
File: IMENavigationMode.java
/** Returns the node with both accessibility and input focus, if any. */
private AccessibilityNodeInfoCompat getFocusedNode() {
    AccessibilityNodeInfoCompat root = null;
    AccessibilityNodeInfoCompat inputFocused = null;
    AccessibilityNodeInfoCompat accessibilityFocused = null;
    try {
        root = AccessibilityServiceCompatUtils.getRootInActiveWindow(mAccessibilityService);
        if (root == null) {
            return null;
        }
        inputFocused = root.findFocus(AccessibilityNodeInfoCompat.FOCUS_INPUT);
        if (inputFocused == null) {
            return null;
        }
        accessibilityFocused = root.findFocus(AccessibilityNodeInfoCompat.FOCUS_ACCESSIBILITY);
        return inputFocused.equals(accessibilityFocused) ? inputFocused : null;
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(root, accessibilityFocused);
    }
}

13. IMENavigationMode#isSelfBrailledFieldFocused()

Project: brailleback
File: IMENavigationMode.java
/** Returns true if a self-brailled node is focused. */
private boolean isSelfBrailledFieldFocused() {
    AccessibilityNodeInfoCompat root = null;
    AccessibilityNodeInfoCompat inputFocused = null;
    AccessibilityNodeInfoCompat accessibilityFocused = null;
    try {
        root = AccessibilityServiceCompatUtils.getRootInActiveWindow(mAccessibilityService);
        if (root == null) {
            return false;
        }
        inputFocused = root.findFocus(AccessibilityNodeInfoCompat.FOCUS_INPUT);
        if (!mSelfBrailleManager.hasContentForNode(inputFocused)) {
            return false;
        }
        accessibilityFocused = root.findFocus(AccessibilityNodeInfoCompat.FOCUS_ACCESSIBILITY);
        return inputFocused.equals(accessibilityFocused);
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(root, inputFocused, accessibilityFocused);
    }
}

14. AccessibilityNodeInfoUtilsTest#getRootForNodeWithLoop_shouldReturnNull()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void getRootForNodeWithLoop_shouldReturnNull() {
    AccessibilityNodeInfo level1Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level2Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level3Node = AccessibilityNodeInfo.obtain();
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level1Node)).addChild(level2Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level2Node)).addChild(level3Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level3Node)).addChild(level1Node);
    AccessibilityNodeInfoCompat startNode = new AccessibilityNodeInfoCompat(level3Node);
    AccessibilityNodeInfoCompat rootNode = AccessibilityNodeInfoUtils.getRoot(startNode);
    assertNull(rootNode);
    level1Node.recycle();
    level2Node.recycle();
    level3Node.recycle();
}

15. AccessibilityNodeInfoRefTest#parentWithParents_shouldReturnTrueAndSetItselfForParent()

Project: talkback
File: AccessibilityNodeInfoRefTest.java
@Test
public void parentWithParents_shouldReturnTrueAndSetItselfForParent() {
    AccessibilityNodeInfo currentNode = AccessibilityNodeInfo.obtain();
    currentNode.setVisibleToUser(true);
    AccessibilityNodeInfo parentNode = AccessibilityNodeInfo.obtain();
    parentNode.setVisibleToUser(true);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parentNode)).addChild(currentNode);
    AccessibilityNodeInfoCompat currentCompat = new AccessibilityNodeInfoCompat(currentNode);
    AccessibilityNodeInfoCompat parentCompat = new AccessibilityNodeInfoCompat(parentNode);
    AccessibilityNodeInfoRef ref = AccessibilityNodeInfoRef.obtain(currentCompat);
    assertTrue(ref.parent());
    assertEquals(parentCompat, ref.get());
    parentNode.recycle();
    currentNode.recycle();
    ref.recycle();
}

16. CursorGranularityManagerTest#previousGranularityWithLoopingTest()

Project: talkback
File: CursorGranularityManagerTest.java
@Test
public void previousGranularityWithLoopingTest() {
    AccessibilityNodeInfoCompat node = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE);
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_LOWER));
    assertEquals(CursorGranularity.LINE, mGranularityManager.getCurrentGranularity());
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_LOWER));
    assertEquals(CursorGranularity.WORD, mGranularityManager.getCurrentGranularity());
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_LOWER));
    assertEquals(CursorGranularity.CHARACTER, mGranularityManager.getCurrentGranularity());
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_LOWER));
    assertEquals(CursorGranularity.DEFAULT, mGranularityManager.getCurrentGranularity());
    node.recycle();
}

17. CursorGranularityManagerTest#nextGranularityWithLoopingTest()

Project: talkback
File: CursorGranularityManagerTest.java
@Test
public void nextGranularityWithLoopingTest() {
    AccessibilityNodeInfoCompat node = createNodeWithGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE);
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_HIGHER));
    assertEquals(CursorGranularity.CHARACTER, mGranularityManager.getCurrentGranularity());
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_HIGHER));
    assertEquals(CursorGranularity.WORD, mGranularityManager.getCurrentGranularity());
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_HIGHER));
    assertEquals(CursorGranularity.LINE, mGranularityManager.getCurrentGranularity());
    assertTrue(mGranularityManager.adjustGranularityAt(node, CursorGranularityManager.CHANGE_GRANULARITY_HIGHER));
    assertEquals(CursorGranularity.DEFAULT, mGranularityManager.getCurrentGranularity());
    node.recycle();
}

18. AccessibilityNodeInfoUtils#hasMatchingAncestor()

Project: talkback
File: AccessibilityNodeInfoUtils.java
/**
     * Check whether a given node has a scrollable ancestor.
     *
     * @param node The node to examine.
     * @return {@code true} if one of the node's ancestors is scrollable.
     */
public static boolean hasMatchingAncestor(AccessibilityNodeInfoCompat node, NodeFilter filter) {
    if (node == null) {
        return false;
    }
    final AccessibilityNodeInfoCompat result = getMatchingAncestor(node, filter);
    if (result == null) {
        return false;
    }
    result.recycle();
    return true;
}

19. SavedNode#clearCache()

Project: talkback
File: SavedNode.java
private void clearCache() {
    List<AccessibilityNodeInfoCompat> toRemove = new ArrayList<>();
    for (AccessibilityNodeInfoCompat node : mSelectionCache.keySet()) {
        boolean refreshed = refreshNode(node);
        if (!refreshed || !node.isVisibleToUser()) {
            toRemove.add(node);
        }
    }
    for (AccessibilityNodeInfoCompat node : toRemove) {
        mSelectionCache.remove(node);
        node.recycle();
    }
}

20. RuleViewPager#accept()

Project: talkback
File: RuleViewPager.java
@Override
public boolean accept(Context context, AccessibilityNodeInfoCompat node) {
    AccessibilityNodeInfoCompat rootNode = null;
    AccessibilityNodeInfoCompat pagerNode = null;
    try {
        rootNode = AccessibilityNodeInfoUtils.getRoot(node);
        if (rootNode == null) {
            return false;
        }
        pagerNode = AccessibilityNodeInfoUtils.searchFromBfs(rootNode, FILTER_PAGED);
        return pagerNode != null;
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(rootNode, pagerNode);
    }
}

21. TextCursorControllerApp#processTextSelectionChange()

Project: talkback
File: TextCursorControllerApp.java
private void processTextSelectionChange(AccessibilityEvent event) {
    AccessibilityNodeInfo node = event.getSource();
    if (node == null) {
        clear();
        return;
    }
    AccessibilityNodeInfoCompat compat = new AccessibilityNodeInfoCompat(node);
    if (compat.equals(mNode)) {
        mPreviousCursorPosition = mCurrentCursorPosition;
        mCurrentCursorPosition = event.getToIndex();
    } else {
        clear();
        mNode = compat;
        mCurrentCursorPosition = event.getToIndex();
    }
}

22. FullScreenReadControllerApp#moveIntoWebContent()

Project: talkback
File: FullScreenReadControllerApp.java
private void moveIntoWebContent() {
    final AccessibilityNodeInfoCompat webNode = mCursorController.getCursor();
    if (webNode == null) {
        // Reset state.
        interrupt();
        return;
    }
    if (mCurrentState == STATE_READING_FROM_BEGINNING) {
        // Reset ChromeVox's active indicator to the start to the page.
        WebInterfaceUtils.performNavigationAtGranularityAction(webNode, WebInterfaceUtils.DIRECTION_BACKWARD, AccessibilityNodeInfoCompat.MOVEMENT_GRANULARITY_PAGE);
    }
    WebInterfaceUtils.performNavigationAtGranularityAction(webNode, WebInterfaceUtils.DIRECTION_FORWARD, AccessibilityNodeInfoCompat.MOVEMENT_GRANULARITY_PAGE);
    setReadingState(STATE_ENTERING_LEGACY_WEB_CONTENT);
    webNode.recycle();
}

23. CursorControllerApp#getAccessibilityFocusedOrInputFocusedEditableNode()

Project: talkback
File: CursorControllerApp.java
public AccessibilityNodeInfoCompat getAccessibilityFocusedOrInputFocusedEditableNode() {
    final AccessibilityNodeInfoCompat compatRoot = AccessibilityServiceCompatUtils.getRootInAccessibilityFocusedWindow(mService);
    if (compatRoot == null) {
        return null;
    }
    AccessibilityNodeInfoCompat focusedNode = getAccessibilityFocusedNode(compatRoot);
    // focus from new window or try to be smart for things like list views.
    if (focusedNode == null) {
        AccessibilityNodeInfoCompat inputFocusedNode = getInputFocusedNode();
        if (inputFocusedNode != null && inputFocusedNode.isEditable()) {
            focusedNode = inputFocusedNode;
        }
    }
    return focusedNode;
}

24. CursorControllerApp#getAccessibilityFocusedOrRootNode()

Project: talkback
File: CursorControllerApp.java
private AccessibilityNodeInfoCompat getAccessibilityFocusedOrRootNode() {
    final AccessibilityNodeInfoCompat compatRoot = AccessibilityServiceCompatUtils.getRootInAccessibilityFocusedWindow(mService);
    if (compatRoot == null) {
        return null;
    }
    AccessibilityNodeInfoCompat focusedNode = getAccessibilityFocusedNode(compatRoot);
    // focus from new window or try to be smart for things like list views.
    if (focusedNode == null) {
        return compatRoot;
    }
    return focusedNode;
}

25. CursorControllerApp#refocus()

Project: talkback
File: CursorControllerApp.java
@Override
public boolean refocus() {
    final AccessibilityNodeInfoCompat node = getCursor();
    if (node == null) {
        return false;
    }
    clearCursor(node);
    final boolean result = setCursor(node);
    node.recycle();
    return result;
}

26. CompoundButtonsTest#assertDescriptionForIdDoesNotContain()

Project: talkback
File: CompoundButtonsTest.java
private void assertDescriptionForIdDoesNotContain(final int viewId, final CharSequence partialText) throws Throwable {
    final AccessibilityNodeInfoCompat source = getNodeForId(viewId);
    final AccessibilityNodeInfoCompat announcedNode = AccessibilityNodeInfoUtils.findFocusFromHover(source);
    runTestOnUiThread(new Runnable() {

        @Override
        public void run() {
            final CharSequence description = mNodeProcessor.getDescriptionForTree(announcedNode, null, source);
            final CharSequenceFilter filter = new CharSequenceFilter().addContainsIgnoreCase(partialText);
            assertFalse("Description \"" + description + "\" for view with id " + viewId + " should not match filter " + filter, filter.matches(description));
        }
    });
}

27. CompoundButtonsTest#assertDescriptionForIdContains()

Project: talkback
File: CompoundButtonsTest.java
private void assertDescriptionForIdContains(final int viewId, final CharSequence... partialText) throws Throwable {
    final AccessibilityNodeInfoCompat source = getNodeForId(viewId);
    final AccessibilityNodeInfoCompat announcedNode = AccessibilityNodeInfoUtils.findFocusFromHover(source);
    runTestOnUiThread(new Runnable() {

        @Override
        public void run() {
            final CharSequence description = mNodeProcessor.getDescriptionForTree(announcedNode, null, source);
            final CharSequenceFilter filter = new CharSequenceFilter().addContainsIgnoreCase(partialText);
            assertTrue("Description \"" + description + "\" for view with id " + viewId + " matches filter " + filter, filter.matches(description));
        }
    });
}

28. AccessibilityNodeInfoUtilsTest#testRefreshNodeContainerNode()

Project: brailleback
File: AccessibilityNodeInfoUtilsTest.java
public void testRefreshNodeContainerNode() throws Throwable {
    final String description = "Nice view";
    setContentView(R.layout.non_speaking_container);
    final AccessibilityNodeInfoCompat containerNode = getNodeForId(R.id.container);
    final View containerView = getViewForId(R.id.container);
    assertNull("Container should have no content description", containerNode.getContentDescription());
    runTestOnUiThread(new Runnable() {

        @Override
        public void run() {
            containerView.setContentDescription(description);
        }
    });
    waitForAccessibilityIdleSync();
    final AccessibilityNodeInfoCompat refreshedNode = AccessibilityNodeInfoUtils.refreshNode(containerNode);
    assertEquals("Refreshed node should keep its identity", containerNode, refreshedNode);
    assertEquals("Refreshed node should have new content description", description, refreshedNode.getContentDescription());
}

29. AccessibilityNodeInfoUtilsTest#testRefreshNodeLeafNode()

Project: brailleback
File: AccessibilityNodeInfoUtilsTest.java
public void testRefreshNodeLeafNode() throws Throwable {
    final String someOtherText = "someothertext";
    setContentView(R.layout.non_speaking_container);
    final AccessibilityNodeInfoCompat textViewNode = getNodeForId(R.id.textView);
    final TextView textView = (TextView) getViewForId(R.id.textView);
    assertEquals("Text view text doesn't match", getActivity().getString(R.string.dummy_text), textViewNode.getText());
    runTestOnUiThread(new Runnable() {

        @Override
        public void run() {
            textView.setText(someOtherText);
        }
    });
    waitForAccessibilityIdleSync();
    final AccessibilityNodeInfoCompat refreshedNode = AccessibilityNodeInfoUtils.refreshNode(textViewNode);
    assertEquals("Refreshed node should keep its identity", textViewNode, refreshedNode);
    assertEquals("Refreshed node should have new text", someOtherText, refreshedNode.getText());
}

30. AccessibilityNodeInfoUtils#hasMatchingAncestor()

Project: brailleback
File: AccessibilityNodeInfoUtils.java
/**
     * Check whether a given node has a scrollable ancestor.
     *
     * @param node The node to examine.
     * @return {@code true} if one of the node's ancestors is scrollable.
     */
private static boolean hasMatchingAncestor(Context context, AccessibilityNodeInfoCompat node, NodeFilter filter) {
    if (node == null) {
        return false;
    }
    final AccessibilityNodeInfoCompat result = getMatchingAncestor(context, node, filter);
    if (result == null) {
        return false;
    }
    result.recycle();
    return true;
}

31. AccessibilityNodeInfoUtils#getRoot()

Project: brailleback
File: AccessibilityNodeInfoUtils.java
/**
     * Returns the root node of the tree containing {@code node}.
     */
public static AccessibilityNodeInfoCompat getRoot(AccessibilityNodeInfoCompat node) {
    if (node == null) {
        return null;
    }
    AccessibilityNodeInfoCompat current = null;
    AccessibilityNodeInfoCompat parent = AccessibilityNodeInfoCompat.obtain(node);
    do {
        current = parent;
        parent = current.getParent();
    } while (parent != null);
    return current;
}

32. NodeBrailler#addNodeSpanForUncovered()

Project: brailleback
File: NodeBrailler.java
/**
     * Adds {@code node} as a span on {@code content} if not already
     * fully covered by an accessibility node info span.
     */
private void addNodeSpanForUncovered(AccessibilityNodeInfoCompat node, Spannable spannable) {
    AccessibilityNodeInfoCompat[] spans = spannable.getSpans(0, spannable.length(), AccessibilityNodeInfoCompat.class);
    for (AccessibilityNodeInfoCompat span : spans) {
        if (spannable.getSpanStart(span) == 0 && spannable.getSpanEnd(span) == spannable.length()) {
            return;
        }
    }
    DisplaySpans.setAccessibilityNode(spannable, node);
}

33. IMENavigationMode#isModalFieldFocused()

Project: brailleback
File: IMENavigationMode.java
/** Returns true if a field suitable for modal editing is focused. */
private boolean isModalFieldFocused() {
    // Only instances of EditText with both input and accessibility focus
    // should be edited modally.
    AccessibilityNodeInfoCompat root = null;
    AccessibilityNodeInfoCompat accessibilityFocused = null;
    try {
        root = AccessibilityServiceCompatUtils.getRootInActiveWindow(mAccessibilityService);
        if (root == null) {
            return false;
        }
        accessibilityFocused = root.findFocus(AccessibilityNodeInfoCompat.FOCUS_ACCESSIBILITY);
        return (accessibilityFocused != null && accessibilityFocused.isFocused() && AccessibilityNodeInfoUtils.nodeMatchesClassByType(mAccessibilityService, accessibilityFocused, EditText.class));
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(root, accessibilityFocused);
    }
}

34. DisplaySpans#recycleSpans()

Project: brailleback
File: DisplaySpans.java
/**
     * Recycles objects owned by the spannable.  In particular, any
     * accessibility nodes that have been associated with {@code spannable}
     * are recycled and removed.
     */
public static void recycleSpans(CharSequence chars) {
    if (!(chars instanceof Spannable)) {
        return;
    }
    Spannable spannable = (Spannable) chars;
    AccessibilityNodeInfoCompat[] nodes = spannable.getSpans(0, spannable.length(), AccessibilityNodeInfoCompat.class);
    for (AccessibilityNodeInfoCompat node : nodes) {
        node.recycle();
        spannable.removeSpan(node);
    }
}

35. DisplaySpans#logNodes()

Project: brailleback
File: DisplaySpans.java
/**
     * Utility function to log what accessibiility nodes are attached
     * to what parts of the character sequence.
     */
public static void logNodes(CharSequence chars) {
    if (!(chars instanceof Spanned)) {
        LogUtils.log(DisplaySpans.class, Log.VERBOSE, "Not a Spanned");
        return;
    }
    Spanned spanned = (Spanned) chars;
    AccessibilityNodeInfoCompat spans[] = spanned.getSpans(0, spanned.length(), AccessibilityNodeInfoCompat.class);
    for (AccessibilityNodeInfoCompat node : spans) {
        LogUtils.log(DisplaySpans.class, Log.VERBOSE, chars.subSequence(spanned.getSpanStart(node), spanned.getSpanEnd(node)).toString());
        LogUtils.log(DisplaySpans.class, Log.VERBOSE, node.getInfo().toString());
    }
}

36. DisplaySpans#getAccessibilityNodeFromPosition()

Project: brailleback
File: DisplaySpans.java
/**
     * Finds the shortest accessibility node span that overlaps {@code position}
     * in {@code chars}.  If a node is found, it is returned, otherwise
     * {@code null} is returned.  If a node is returned, it is still owned
     * by {@code chars} for the purpose of recycling.
     */
public static AccessibilityNodeInfoCompat getAccessibilityNodeFromPosition(int position, CharSequence chars) {
    if (!(chars instanceof Spanned)) {
        return null;
    }
    Spanned spanned = (Spanned) chars;
    AccessibilityNodeInfoCompat[] spans = spanned.getSpans(position, position, AccessibilityNodeInfoCompat.class);
    if (spans.length == 0) {
        return null;
    }
    AccessibilityNodeInfoCompat found = spans[0];
    int foundLength = spanned.getSpanEnd(found) - spanned.getSpanStart(found);
    for (int i = 1; i < spans.length; ++i) {
        AccessibilityNodeInfoCompat span = spans[i];
        int length = spanned.getSpanEnd(span) - spanned.getSpanStart(span);
        if (length < foundLength) {
            found = span;
            foundLength = length;
        }
    }
    return found;
}

37. DefaultNavigationMode#attemptScrollAction()

Project: brailleback
File: DefaultNavigationMode.java
/**
     * Attempts to scroll using the specified action.
     */
private boolean attemptScrollAction(int action) {
    AccessibilityNodeInfoCompat focusedNode = null;
    AccessibilityNodeInfoCompat scrollableNode = null;
    try {
        focusedNode = getFocusedNode(false);
        if (focusedNode == null) {
            return false;
        }
        scrollableNode = AccessibilityNodeInfoUtils.getSelfOrMatchingAncestor(mAccessibilityService, focusedNode, AccessibilityNodeInfoUtils.FILTER_SCROLLABLE);
        if (scrollableNode == null) {
            return false;
        }
        return scrollableNode.performAction(action);
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(focusedNode, scrollableNode);
    }
}

38. AccessibilityNodeInfoUtils#hasMatchingAncestor()

Project: Accessibility-Test-Framework-for-Android
File: AccessibilityNodeInfoUtils.java
/**
     * Check whether a given node has a scrollable ancestor.
     *
     * @param node The node to examine.
     * @return {@code true} if one of the node's ancestors is scrollable.
     */
private static boolean hasMatchingAncestor(Context context, AccessibilityNodeInfoCompat node, NodeFilter filter) {
    if (node == null) {
        return false;
    }
    final AccessibilityNodeInfoCompat result = getMatchingAncestor(context, node, filter);
    if (result == null) {
        return false;
    }
    result.recycle();
    return true;
}

39. AccessibilityNodeInfoUtils#getRoot()

Project: Accessibility-Test-Framework-for-Android
File: AccessibilityNodeInfoUtils.java
/**
     * Returns the root node of the tree containing {@code node}.
     */
public static AccessibilityNodeInfoCompat getRoot(AccessibilityNodeInfoCompat node) {
    if (node == null) {
        return null;
    }
    AccessibilityNodeInfoCompat current = null;
    AccessibilityNodeInfoCompat parent = AccessibilityNodeInfoCompat.obtain(node);
    do {
        current = parent;
        parent = current.getParent();
    } while (parent != null);
    return current;
}

40. NodeCachedBoundsCalculatorTest#getBoundsWithLoop_shouldNotHang()

Project: talkback
File: NodeCachedBoundsCalculatorTest.java
@Test(timeout = 1000)
public void getBoundsWithLoop_shouldNotHang() {
    AccessibilityNodeInfo level1Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level2Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level3Node = AccessibilityNodeInfo.obtain();
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level1Node)).addChild(level2Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level2Node)).addChild(level3Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level3Node)).addChild(level1Node);
    AccessibilityNodeInfoCompat startNode = new AccessibilityNodeInfoCompat(level1Node);
    NodeCachedBoundsCalculator calculator = new NodeCachedBoundsCalculator();
    calculator.getBounds(startNode);
    level1Node.recycle();
    level2Node.recycle();
    level3Node.recycle();
}

41. AccessibilityNodeInfoUtilsTest#shouldFocusNodeWithLoop_shouldNotHang()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test(timeout = 100)
public void shouldFocusNodeWithLoop_shouldNotHang() {
    AccessibilityNodeInfo level1Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level2Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level3Node = AccessibilityNodeInfo.obtain();
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level1Node)).addChild(level2Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level2Node)).addChild(level3Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level3Node)).addChild(level1Node);
    AccessibilityNodeInfoCompat startNode = new AccessibilityNodeInfoCompat(level1Node);
    AccessibilityNodeInfoUtils.shouldFocusNode(startNode);
    level1Node.recycle();
    level2Node.recycle();
    level3Node.recycle();
}

42. AccessibilityNodeInfoUtilsTest#isFocusableWithLoop_shouldNotHang()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test(timeout = 100)
public void isFocusableWithLoop_shouldNotHang() {
    AccessibilityNodeInfo level1Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level2Node = AccessibilityNodeInfo.obtain();
    AccessibilityNodeInfo level3Node = AccessibilityNodeInfo.obtain();
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level1Node)).addChild(level2Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level2Node)).addChild(level3Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(level3Node)).addChild(level1Node);
    AccessibilityNodeInfoCompat startNode = new AccessibilityNodeInfoCompat(level1Node);
    AccessibilityNodeInfoUtils.isAccessibilityFocusable(startNode);
    level1Node.recycle();
    level2Node.recycle();
    level3Node.recycle();
}

43. AccessibilityNodeInfoRefTest#parentWithSelfReferencedParent_shouldReturnFalse()

Project: talkback
File: AccessibilityNodeInfoRefTest.java
@Test
public void parentWithSelfReferencedParent_shouldReturnFalse() {
    AccessibilityNodeInfo curNode = AccessibilityNodeInfo.obtain();
    curNode.setVisibleToUser(true);
    AccessibilityNodeInfo parentNode = AccessibilityNodeInfo.obtain();
    parentNode.setVisibleToUser(true);
    curNode.setContentDescription("Current");
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(curNode)).addChild(curNode);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(curNode)).setVisibleToUser(true);
    AccessibilityNodeInfoCompat currentCompat = new AccessibilityNodeInfoCompat(curNode);
    AccessibilityNodeInfoRef ref = AccessibilityNodeInfoRef.obtain(currentCompat);
    assertFalse(ref.parent());
    parentNode.recycle();
    curNode.recycle();
    ref.recycle();
}

44. AccessibilityNodeInfoRefTest#parentWithLoopedParents_shouldReturnFalse()

Project: talkback
File: AccessibilityNodeInfoRefTest.java
@Test
public void parentWithLoopedParents_shouldReturnFalse() {
    AccessibilityNodeInfo curNode = AccessibilityNodeInfo.obtain();
    curNode.setVisibleToUser(true);
    AccessibilityNodeInfo parentNode = AccessibilityNodeInfo.obtain();
    parentNode.setVisibleToUser(true);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parentNode)).addChild(curNode);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(curNode)).addChild(parentNode);
    /* Set nodes to be invisible to force the the code to traverse the loop */
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parentNode)).setVisibleToUser(false);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(curNode)).setVisibleToUser(false);
    AccessibilityNodeInfoCompat currentCompat = new AccessibilityNodeInfoCompat(curNode);
    AccessibilityNodeInfoRef ref = AccessibilityNodeInfoRef.obtain(currentCompat);
    assertFalse(ref.parent());
    parentNode.recycle();
    curNode.recycle();
    ref.recycle();
}

45. AccessibilityNodeInfoRefTest#lastDescentWithLoop_shouldReturnFalse()

Project: talkback
File: AccessibilityNodeInfoRefTest.java
@Test
public void lastDescentWithLoop_shouldReturnFalse() {
    AccessibilityNodeInfo parentNode = AccessibilityNodeInfo.obtain();
    parentNode.setVisibleToUser(true);
    AccessibilityNodeInfo child1Node = AccessibilityNodeInfo.obtain();
    child1Node.setVisibleToUser(true);
    AccessibilityNodeInfo child2Node = AccessibilityNodeInfo.obtain();
    child2Node.setVisibleToUser(true);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parentNode)).addChild(child1Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(parentNode)).addChild(child2Node);
    ((ShadowAccessibilityNodeInfo) ShadowExtractor.extract(child2Node)).addChild(parentNode);
    AccessibilityNodeInfoCompat parentCompat = new AccessibilityNodeInfoCompat(parentNode);
    AccessibilityNodeInfoRef ref = AccessibilityNodeInfoRef.obtain(parentCompat);
    assertFalse(ref.lastDescendant());
    parentNode.recycle();
    child1Node.recycle();
    child2Node.recycle();
    ref.recycle();
}

46. ShadowAccessibilityNodeInfoCompat#equals()

Project: talkback
File: ShadowAccessibilityNodeInfoCompat.java
@Implementation
@Override
public boolean equals(Object object) {
    if (object == null) {
        return false;
    }
    final AccessibilityNodeInfoCompat compat = (AccessibilityNodeInfoCompat) object;
    final AccessibilityNodeInfo thisInfo = ((AccessibilityNodeInfo) mRealObject.getInfo());
    final AccessibilityNodeInfo otherInfo = ((AccessibilityNodeInfo) compat.getInfo());
    return thisInfo.equals(otherInfo);
}

47. ReorderedChildrenIterator#reorder()

Project: talkback
File: ReorderedChildrenIterator.java
private void reorder(List<AccessibilityNodeInfoCompat> nodes) {
    if (nodes == null || nodes.size() == 1) {
        return;
    }
    int size = nodes.size();
    AccessibilityNodeInfoCompat[] nodeArray = new AccessibilityNodeInfoCompat[size];
    nodes.toArray(nodeArray);
    int currentIndex = size - 2;
    while (currentIndex >= 0) {
        AccessibilityNodeInfoCompat currentNode = nodeArray[currentIndex];
        if (mBoundsCalculator.usesChildrenBounds(currentNode)) {
            moveNodeIfNecessary(nodeArray, currentIndex);
        }
        currentIndex--;
    }
    nodes.clear();
    nodes.addAll(Arrays.asList(nodeArray));
}

48. ReorderedChildrenIterator#needReordering()

Project: talkback
File: ReorderedChildrenIterator.java
private boolean needReordering(List<AccessibilityNodeInfoCompat> nodes) {
    if (nodes == null || nodes.size() == 1) {
        return false;
    }
    for (AccessibilityNodeInfoCompat node : nodes) {
        if (mBoundsCalculator.usesChildrenBounds(node)) {
            return true;
        }
    }
    return false;
}

49. NodeSearch#getMatchText()

Project: talkback
File: NodeSearch.java
/**
     * Get the text of the currently matched node.
     *
     * @return The text of the current match. May be empty, for example if no match has been found.
     */
public String getMatchText() {
    final AccessibilityNodeInfoCompat currentMatch = mMatchedNode.get();
    if (currentMatch == null) {
        return "";
    }
    final CharSequence nodeText = AccessibilityNodeInfoUtils.getNodeText(currentMatch, mLabelManager);
    if (nodeText == null) {
        return "";
    }
    return nodeText.toString();
}

50. AutomationUtils#findViewsWithText()

Project: talkback
File: AutomationUtils.java
/**
     * Returns a list of nodes under the {@code root} node that match the
     * class specified by {@code className} and exactly match the text or
     * content description specified by {@code text}.
     */
private static List<AccessibilityNodeInfoCompat> findViewsWithText(AccessibilityNodeInfoCompat root, CharSequence className, String text) {
    final List<AccessibilityNodeInfoCompat> nodes = root.findAccessibilityNodeInfosByText(text);
    final List<AccessibilityNodeInfoCompat> results = new LinkedList<>();
    for (AccessibilityNodeInfoCompat node : nodes) {
        if (nodeMatchesFilter(node, className, text)) {
            results.add(node);
        }
    }
    return Collections.unmodifiableList(results);
}

51. AccessibilityNodeInfoUtils#refreshFromParent()

Project: talkback
File: AccessibilityNodeInfoUtils.java
private static AccessibilityNodeInfoCompat refreshFromParent(AccessibilityNodeInfoCompat node) {
    AccessibilityNodeInfoCompat parent = node.getParent();
    if (parent != null) {
        try {
            int childCount = parent.getChildCount();
            for (int i = 0; i < childCount; ++i) {
                AccessibilityNodeInfoCompat child = parent.getChild(i);
                if (node.equals(child)) {
                    return child;
                }
                recycleNodes(child);
            }
        } finally {
            parent.recycle();
        }
    }
    return null;
}

52. AccessibilityNodeInfoUtils#refreshNode()

Project: talkback
File: AccessibilityNodeInfoUtils.java
/**
     * Returns a fresh copy of {@code node} with properties that are
     * less likely to be stale.  Returns {@code null} if the node can't be
     * found anymore.
     */
public static AccessibilityNodeInfoCompat refreshNode(AccessibilityNodeInfoCompat node) {
    if (node == null) {
        return null;
    }
    AccessibilityNodeInfoCompat result = refreshFromChild(node);
    if (result == null) {
        result = refreshFromParent(node);
    }
    return result;
}

53. AccessibilityNodeInfoUtils#recycleNodes()

Project: talkback
File: AccessibilityNodeInfoUtils.java
/**
     * Recycles the given nodes.
     *
     * @param nodes The nodes to recycle.
     */
public static void recycleNodes(Collection<AccessibilityNodeInfoCompat> nodes) {
    if (nodes == null) {
        return;
    }
    for (AccessibilityNodeInfoCompat node : nodes) {
        if (node != null) {
            node.recycle();
        }
    }
    nodes.clear();
}

54. AccessibilityNodeInfoUtils#hasAncestor()

Project: talkback
File: AccessibilityNodeInfoUtils.java
public static boolean hasAncestor(AccessibilityNodeInfoCompat node, final AccessibilityNodeInfoCompat targetAncestor) {
    if (node == null || targetAncestor == null) {
        return false;
    }
    NodeFilter filter = new NodeFilter() {

        @Override
        public boolean accept(AccessibilityNodeInfoCompat node) {
            return targetAncestor.equals(node);
        }
    };
    AccessibilityNodeInfoCompat foundAncestor = getMatchingAncestor(node, filter);
    if (foundAncestor != null) {
        foundAncestor.recycle();
        return true;
    }
    return false;
}

55. RuleSeekBar#format()

Project: talkback
File: RuleSeekBar.java
@Override
public boolean format(AccessibilityEvent event, TalkBackService context, Utterance utterance) {
    final AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
    final AccessibilityNodeInfoCompat source = record.getSource();
    if (source == null)
        return false;
    CharSequence text = format(context, source, event);
    if (TextUtils.isEmpty(text))
        return false;
    utterance.addSpoken(text);
    utterance.getMetadata().putInt(Utterance.KEY_UTTERANCE_GROUP, SpeechController.UTTERANCE_GROUP_SEEK_PROGRESS);
    utterance.addSpokenFlag(FeedbackItem.FLAG_CLEAR_QUEUED_UTTERANCES_WITH_SAME_UTTERANCE_GROUP);
    utterance.getMetadata().putInt(Utterance.KEY_METADATA_QUEUING, SpeechController.QUEUE_MODE_UNINTERRUPTIBLE);
    return true;
}

56. ProgressBarFormatter#shouldDropEvent()

Project: talkback
File: ProgressBarFormatter.java
private boolean shouldDropEvent(AccessibilityEvent event) {
    final AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
    final AccessibilityNodeInfoCompat source = record.getSource();
    // missing a node).
    if (source == null) {
        return false;
    }
    // Don't drop if the node is currently focused or accessibility focused.
    if (source.isFocused() || source.isAccessibilityFocused()) {
        return false;
    }
    // Don't drop if the node was recently explored.
    return true;
}

57. LiveViewFormatter#accept()

Project: talkback
File: LiveViewFormatter.java
@Override
public boolean accept(AccessibilityEvent event, TalkBackService context) {
    if (event.getEventType() != AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED)
        return false;
    AccessibilityNodeInfoCompat node = new AccessibilityNodeInfoCompat(event.getSource());
    if (node.getInfo() == null) {
        return false;
    }
    int liveRegion = node.getLiveRegion();
    switch(liveRegion) {
        case View.ACCESSIBILITY_LIVE_REGION_POLITE:
            return true;
        case View.ACCESSIBILITY_LIVE_REGION_ASSERTIVE:
            return true;
        case View.ACCESSIBILITY_LIVE_REGION_NONE:
            return false;
        default:
            return false;
    }
}

58. EventSpeechRule#getNodeDescriptionOrFallback()

Project: talkback
File: EventSpeechRule.java
/**
     * Attempts to obtain a description for an event, using the
     * {@link NodeSpeechRuleProcessor} to obtain a description for the source
     * node if possible or falling back on the event text or content description
     * otherwise.
     *
     * @param event The event to generate a description for.
     * @return A description of the event, or an empty string on failure.
     */
private CharSequence getNodeDescriptionOrFallback(AccessibilityEvent event) {
    AccessibilityNodeInfoCompat source = null;
    try {
        source = AccessibilityEventCompat.asRecord(event).getSource();
        if (source != null) {
            final NodeSpeechRuleProcessor nodeProcessor = NodeSpeechRuleProcessor.getInstance();
            final CharSequence treeDescription = nodeProcessor.getDescriptionForTree(source, event, source);
            if (!TextUtils.isEmpty(treeDescription)) {
                return treeDescription;
            }
        }
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(source);
    }
    final CharSequence eventDescription = AccessibilityEventUtils.getEventTextOrDescription(event);
    if (!TextUtils.isEmpty(eventDescription)) {
        return eventDescription;
    }
    return "";
}

59. ProcessorFocusAndSingleTap#focusNextFocusedNode()

Project: talkback
File: ProcessorFocusAndSingleTap.java
private boolean focusNextFocusedNode(TraversalStrategy traversal, AccessibilityNodeInfoCompat node, int direction) {
    if (node == null) {
        return false;
    }
    NodeFilter filter = new NodeFilter() {

        @Override
        public boolean accept(AccessibilityNodeInfoCompat node) {
            return node != null && AccessibilityNodeInfoUtils.shouldFocusNode(node) && PerformActionUtils.performAction(node, AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
        }
    };
    AccessibilityNodeInfoCompat candidateFocus = AccessibilityNodeInfoUtils.searchFocus(traversal, node, direction, filter);
    return candidateFocus != null;
}

60. ProcessorFocusAndSingleTap#handleWindowStateChange()

Project: talkback
File: ProcessorFocusAndSingleTap.java
private void handleWindowStateChange(AccessibilityEvent event) {
    if (mLastFocusedItem != null) {
        mLastFocusedItem.recycle();
        mLastFocusedItem = null;
    }
    clearScrollAction();
    mLastScrollFromIndex = -1;
    mLastScrollToIndex = -1;
    // Since we may get WINDOW_STATE_CHANGE events from the keyboard even
    // though the active window is still another app, only clear focus if
    // the event's window ID matches the cursor's window ID.
    final AccessibilityNodeInfoCompat cursor = mCursorController.getCursor();
    if ((cursor != null) && (cursor.getWindowId() == event.getWindowId())) {
        ensureFocusConsistency();
    }
    if (cursor != null) {
        cursor.recycle();
    }
    tryFocusCachedRecord();
}

61. CursorControllerApp#performAction()

Project: talkback
File: CursorControllerApp.java
/**
     * Performs the specified action on the current cursor.
     *
     * @param action The action to perform on the current cursor.
     * @return {@code true} if successful.
     */
private boolean performAction(int action) {
    AccessibilityNodeInfoCompat current = null;
    try {
        current = getCursor();
        return current != null && PerformActionUtils.performAction(current, action);
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(current);
    }
}

62. CursorControllerApp#getCurrentCursor()

Project: talkback
File: CursorControllerApp.java
private AccessibilityNodeInfoCompat getCurrentCursor(boolean useInputFocusAsPivotIfEmpty) {
    AccessibilityNodeInfoCompat cursor = null;
    if (useInputFocusAsPivotIfEmpty) {
        cursor = getAccessibilityFocusedOrInputFocusedEditableNode();
    }
    if (cursor == null) {
        cursor = getAccessibilityFocusedOrRootNode();
    }
    return cursor;
}

63. CursorControllerApp#adjustGranularity()

Project: talkback
File: CursorControllerApp.java
/**
     * Attempts to adjust granularity in the direction indicated.
     *
     * @param direction The direction to adjust granularity. One of
     *            {@link CursorGranularityManager#CHANGE_GRANULARITY_HIGHER} or
     *            {@link CursorGranularityManager#CHANGE_GRANULARITY_LOWER}
     * @return true on success, false if no nodes in the current hierarchy
     *         support a granularity other than the default.
     */
private boolean adjustGranularity(int direction) {
    AccessibilityNodeInfoCompat currentNode = null;
    try {
        currentNode = getCursor();
        if (currentNode == null) {
            return false;
        }
        final boolean wasAdjusted = mGranularityManager.adjustGranularityAt(currentNode, direction);
        if (wasAdjusted) {
            granularityUpdated(mGranularityManager.getCurrentGranularity(), true);
        }
        return wasAdjusted;
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(currentNode);
    }
}

64. CursorControllerApp#getBestScrollableNode()

Project: talkback
File: CursorControllerApp.java
private AccessibilityNodeInfoCompat getBestScrollableNode(AccessibilityNodeInfoCompat cursor, final int action) {
    final AccessibilityNodeInfoCompat predecessor = AccessibilityNodeInfoUtils.getSelfOrMatchingAncestor(cursor, AccessibilityNodeInfoUtils.FILTER_SCROLLABLE.and(new NodeFilter() {

        @Override
        public boolean accept(AccessibilityNodeInfoCompat node) {
            return node != null && AccessibilityNodeInfoUtils.supportsAnyAction(node, action);
        }
    }));
    if (predecessor != null && isLogicalScrollableWidget(predecessor)) {
        return predecessor;
    }
    return null;
}

65. CursorControllerApp#getInputFocusedNode()

Project: talkback
File: CursorControllerApp.java
private AccessibilityNodeInfoCompat getInputFocusedNode() {
    AccessibilityNodeInfoCompat activeRoot = AccessibilityServiceCompatUtils.getRootInActiveWindow(mService);
    if (activeRoot != null) {
        try {
            return activeRoot.findFocus(AccessibilityNodeInfoCompat.FOCUS_INPUT);
        } finally {
            activeRoot.recycle();
        }
    }
    return null;
}

66. CursorControllerApp#getAccessibilityFocusedNode()

Project: talkback
File: CursorControllerApp.java
public AccessibilityNodeInfoCompat getAccessibilityFocusedNode(AccessibilityNodeInfoCompat compatRoot) {
    if (compatRoot == null) {
        return null;
    }
    AccessibilityNodeInfoCompat focusedNode = compatRoot.findFocus(AccessibilityNodeInfoCompat.FOCUS_ACCESSIBILITY);
    if (focusedNode == null) {
        return null;
    }
    if (!AccessibilityNodeInfoUtils.isVisible(focusedNode)) {
        focusedNode.recycle();
        return null;
    }
    return focusedNode;
}

67. TreeBuilderUtils#getNodesInTalkBackOrder()

Project: talkback
File: TreeBuilderUtils.java
/**
     * Obtain a list of nodes in the order TalkBack would traverse them
     *
     * @param root The root of the tree to traverse
     * @return The nodes in {@code root}'s subtree (including root) in the order TalkBack would
     * traverse them.
     */
public static LinkedList<SwitchAccessNodeCompat> getNodesInTalkBackOrder(SwitchAccessNodeCompat root) {
    LinkedList<SwitchAccessNodeCompat> outList = new LinkedList<>();
    OrderedTraversalController traversalController = new OrderedTraversalController();
    traversalController.initOrder(root);
    AccessibilityNodeInfoCompat node = traversalController.findFirst();
    while (node != null) {
        outList.add(new SwitchAccessNodeCompat(node.getInfo(), root.getWindowsAbove()));
        node = traversalController.findNext(node);
    }
    traversalController.recycle();
    return outList;
}

68. BaseAccessibilityInstrumentationTestCase#getNodeForView()

Project: talkback
File: BaseAccessibilityInstrumentationTestCase.java
/**
     * Returns the {@link android.support.v4.view.accessibility.AccessibilityNodeInfoCompat} for a specific view, or
     * {@code null} if the view is invalid or an error occurred while obtaining
     * the info.
     *
     * @param view The view whose node to obtain.
     * @return The view's node info, or {@code null}.
     */
protected AccessibilityNodeInfoCompat getNodeForView(View view) {
    if (view == null) {
        return null;
    }
    final int realViewId = view.getId();
    view.setId(FAKE_VIEW_ID);
    final AccessibilityNodeInfoCompat node = getNodeForId(FAKE_VIEW_ID);
    view.setId(realViewId);
    return node;
}

69. TouchExplorationHelper#getNodeForParent()

Project: HoloEverywhere
File: TouchExplorationHelper.java
private AccessibilityNodeInfoCompat getNodeForParent() {
    final AccessibilityNodeInfoCompat info = AccessibilityNodeInfoCompat.obtain(mParentView);
    ViewCompat.onInitializeAccessibilityNodeInfo(mParentView, info);
    final LinkedList<T> items = new LinkedList<T>();
    getVisibleItems(items);
    for (T item : items) {
        final int virtualDescendantId = getIdForItem(item);
        info.addChild(mParentView, virtualDescendantId);
    }
    return info;
}

70. TouchExplorationHelper#createAccessibilityNodeInfo()

Project: HoloEverywhere
File: TouchExplorationHelper.java
@Override
public AccessibilityNodeInfoCompat createAccessibilityNodeInfo(int virtualViewId) {
    if (virtualViewId == View.NO_ID) {
        return getNodeForParent();
    }
    final T item = getItemForId(virtualViewId);
    if (item == null) {
        return null;
    }
    final AccessibilityNodeInfoCompat node = AccessibilityNodeInfoCompat.obtain();
    populateNodeForItemInternal(item, node);
    return node;
}

71. AutomationUtils#findViewsWithText()

Project: brailleback
File: AutomationUtils.java
/**
     * Returns a list of nodes under the {@code root} node that match the
     * class specified by {@code className} and exactly match the text or
     * content description specified by {@code text}.
     */
private static List<AccessibilityNodeInfoCompat> findViewsWithText(Context context, AccessibilityNodeInfoCompat root, CharSequence className, String text) {
    final List<AccessibilityNodeInfoCompat> nodes = root.findAccessibilityNodeInfosByText(text);
    final List<AccessibilityNodeInfoCompat> results = new LinkedList<AccessibilityNodeInfoCompat>();
    for (AccessibilityNodeInfoCompat node : nodes) {
        if (nodeMatchesFilter(context, node, className, text)) {
            results.add(node);
        }
    }
    return Collections.unmodifiableList(results);
}

72. AccessibilityNodeInfoUtils#refreshFromParent()

Project: brailleback
File: AccessibilityNodeInfoUtils.java
private static AccessibilityNodeInfoCompat refreshFromParent(AccessibilityNodeInfoCompat node) {
    AccessibilityNodeInfoCompat parent = node.getParent();
    if (parent != null) {
        try {
            int childCount = parent.getChildCount();
            for (int i = 0; i < childCount; ++i) {
                AccessibilityNodeInfoCompat child = parent.getChild(i);
                if (node.equals(child)) {
                    return child;
                }
                recycleNodes(child);
            }
        } finally {
            parent.recycle();
        }
    }
    return null;
}

73. AccessibilityNodeInfoUtils#searchFromInOrderTraversal()

Project: brailleback
File: AccessibilityNodeInfoUtils.java
/**
     * Performs in-order traversal from a given node in a particular direction
     * until a node matching the specified filter is reached.
     *
     * @param context The parent context.
     * @param root The root node to traverse from.
     * @param filter The filter to satisfy.
     * @return The first node reached via in-order traversal that satisfies the
     *         filter.
     */
public static AccessibilityNodeInfoCompat searchFromInOrderTraversal(Context context, AccessibilityNodeInfoCompat root, NodeFilter filter, int direction) {
    AccessibilityNodeInfoCompat currentNode = NodeFocusFinder.focusSearch(root, direction);
    final HashSet<AccessibilityNodeInfoCompat> seenNodes = new HashSet<AccessibilityNodeInfoCompat>();
    while ((currentNode != null) && !seenNodes.contains(currentNode) && !filter.accept(context, currentNode)) {
        seenNodes.add(currentNode);
        currentNode = NodeFocusFinder.focusSearch(currentNode, direction);
    }
    // Recycle all the seen nodes.
    AccessibilityNodeInfoUtils.recycleNodes(seenNodes);
    return currentNode;
}

74. AccessibilityNodeInfoUtils#recycleNodes()

Project: brailleback
File: AccessibilityNodeInfoUtils.java
/**
     * Recycles the given nodes.
     *
     * @param nodes The nodes to recycle.
     */
public static void recycleNodes(Collection<AccessibilityNodeInfoCompat> nodes) {
    if (nodes == null) {
        return;
    }
    for (AccessibilityNodeInfoCompat node : nodes) {
        if (node != null) {
            node.recycle();
        }
    }
    nodes.clear();
}

75. AccessibilityNodeInfoRef#parent()

Project: brailleback
File: AccessibilityNodeInfoRef.java
/**
     * Traverses to the parent of this node, returning {@code true} on
     * success. On failure, returns {@code false} and does not move.
     */
public boolean parent() {
    if (mNode == null) {
        return false;
    }
    AccessibilityNodeInfoCompat parentNode = mNode.getParent();
    while (parentNode != null) {
        if (AccessibilityNodeInfoUtils.isVisibleOrLegacy(parentNode)) {
            reset(parentNode);
            return true;
        }
        AccessibilityNodeInfoCompat tmp = parentNode.getParent();
        parentNode.recycle();
        parentNode = tmp;
    }
    return false;
}

76. SearchNavigationModeTest#getFocusedNode()

Project: brailleback
File: SearchNavigationModeTest.java
/**
     * Returns the focused node or the specified root if none found.
     */
private AccessibilityNodeInfoCompat getFocusedNode(AccessibilityNodeInfoCompat root) {
    AccessibilityNodeInfoCompat focused = null;
    if (root != null) {
        focused = root.findFocus(AccessibilityNodeInfoCompat.FOCUS_ACCESSIBILITY);
        if (focused != null && focused.isVisibleToUser()) {
            return focused;
        }
        return root;
    }
    return null;
}

77. SearchNavigationModeTest#testClearQuery()

Project: brailleback
File: SearchNavigationModeTest.java
public void testClearQuery() throws Exception {
    mSearchNavMode.onActivate();
    AccessibilityNodeInfoCompat root = getNodeForId(R.id.top);
    assertNotNull(root);
    mSearchNavMode.setQueryTextForTest("xy");
    // Deactivate and reactivate and make sure query text has cleared.
    mSearchNavMode.onDeactivate();
    mSearchNavMode.onActivate();
    assertEquals("", mSearchNavMode.getQueryTextForTest());
}

78. SearchNavigationMode#formatEventToBraille()

Project: brailleback
File: SearchNavigationMode.java
/**
     * Formats some braille content from an {@link AccessibilityEvent}.
     */
private DisplayManager.Content formatEventToBraille(AccessibilityEvent event) {
    AccessibilityNodeInfoCompat eventNode = getNodeFromEvent(event);
    if (eventNode != null) {
        DisplayManager.Content content = formatNodeToBraille(eventNode);
        if (content != null) {
            return content.setPanStrategy(DisplayManager.Content.PAN_CURSOR);
        }
    }
    // This should never happen, print out an error if it does.
    LogUtils.log(this, Log.WARN, "No node on event!");
    return null;
}

79. IMENavigationMode#navigateAtMovementGranularity()

Project: brailleback
File: IMENavigationMode.java
/** Asks the focused node to navigate at the requested granularity. */
private boolean navigateAtMovementGranularity(int action, int granularity) {
    Bundle arguments = new Bundle();
    arguments.putInt(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT, granularity);
    AccessibilityNodeInfoCompat node = getFocusedNode();
    if (node == null) {
        return false;
    }
    try {
        return node.performAction(action, arguments);
    } finally {
        node.recycle();
    }
}

80. DefaultNavigationMode#brailleFocusedNode()

Project: brailleback
File: DefaultNavigationMode.java
private boolean brailleFocusedNode() {
    AccessibilityNodeInfoCompat focused = getFocusedNode(false);
    if (focused != null) {
        DisplayManager.Content content = mNodeBrailler.brailleNode(focused);
        if (focused.equals(mLastFocusedNode.get()) && (content.getPanStrategy() == DisplayManager.Content.PAN_RESET)) {
            content.setPanStrategy(DisplayManager.Content.PAN_KEEP);
        }
        mDisplayManager.setContent(content);
        mLastFocusedNode.reset(focused);
        return true;
    }
    return false;
}

81. DefaultNavigationMode#formatEventToBraille()

Project: brailleback
File: DefaultNavigationMode.java
/**
     * Formats some braille content from an {@link AccessibilityEvent}.
     *
     * @param event The event from which to format an utterance.
     * @return The formatted utterance.
     */
private DisplayManager.Content formatEventToBraille(AccessibilityEvent event) {
    AccessibilityNodeInfoCompat eventNode = getNodeFromEvent(event);
    if (eventNode != null) {
        DisplayManager.Content ret = mNodeBrailler.brailleNode(eventNode);
        ret.setPanStrategy(DisplayManager.Content.PAN_CURSOR);
        mLastFocusedNode.reset(eventNode);
        return ret;
    }
    // Fall back on putting the event text on the display.
    // TODO: This can interfere with what's on the display and should be
    // done in a more disciplined manner.
    LogUtils.log(this, Log.VERBOSE, "No node on event, falling back on event text");
    mLastFocusedNode.clear();
    return new DisplayManager.Content(AccessibilityEventUtils.getEventText(event));
}

82. DefaultNavigationMode#moveFocus()

Project: brailleback
File: DefaultNavigationMode.java
private boolean moveFocus(AccessibilityNodeInfoCompat from, int direction) {
    int searchDirection = (direction == DIRECTION_BACKWARD) ? FocusFinder.SEARCH_BACKWARD : FocusFinder.SEARCH_FORWARD;
    AccessibilityNodeInfoCompat next = null;
    next = mFocusFinder.linear(from, searchDirection);
    try {
        if (next != null) {
            return next.performAction(AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS);
        }
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(next);
    }
    return false;
}

83. DefaultNavigationMode#handleIncrementalSearchAction()

Project: brailleback
File: DefaultNavigationMode.java
private boolean handleIncrementalSearchAction() {
    AccessibilityNodeInfoCompat currentNode = getFocusedNode(true);
    try {
        if (currentNode != null && WebInterfaceUtils.hasLegacyWebContent(currentNode) && mFeedbackManager.emitOnFailure(WebInterfaceUtils.performSpecialAction(currentNode, ACTION_TOGGLE_INCREMENTAL_SEARCH), FeedbackManager.TYPE_COMMAND_FAILED)) {
            return true;
        }
        return false;
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(currentNode);
    }
}

84. DefaultNavigationMode#navigateHTMLElementAction()

Project: brailleback
File: DefaultNavigationMode.java
private boolean navigateHTMLElementAction(int direction, String element) {
    AccessibilityNodeInfoCompat currentNode = getFocusedNode(true);
    try {
        if (currentNode != null && WebInterfaceUtils.supportsWebActions(currentNode) && WebInterfaceUtils.performNavigationToHtmlElementAction(currentNode, direction, element)) {
            return true;
        }
        return false;
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(currentNode);
    }
}

85. DefaultNavigationMode#navigateItem()

Project: brailleback
File: DefaultNavigationMode.java
private boolean navigateItem(int direction) {
    AccessibilityNodeInfoCompat currentNode = getFocusedNode(true);
    try {
        if (currentNode != null && WebInterfaceUtils.hasLegacyWebContent(currentNode) && WebInterfaceUtils.performNavigationByDOMObject(currentNode, direction)) {
            return true;
        }
        // Check if we need to scroll.
        int scrollDirection = (direction == DIRECTION_FORWARD) ? AccessibilityNodeInfo.ACTION_SCROLL_FORWARD : AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD;
        if (autoScrollItem(currentNode, scrollDirection)) {
            return true;
        }
        return moveFocus(currentNode, direction);
    } finally {
        AccessibilityNodeInfoUtils.recycleNodes(currentNode);
    }
}

86. BrailleMenuNavigationMode#onActivate()

Project: brailleback
File: BrailleMenuNavigationMode.java
@Override
public void onActivate() {
    // No point in activating if labeling isn't supported on the OS.
    if (Build.VERSION.SDK_INT < CustomLabelManager.MIN_API_LEVEL) {
        closeMenu();
        return;
    }
    mActive = true;
    // If the currently focused node doesn't warrant a menu, deactivate.
    AccessibilityNodeInfoCompat focused = FocusFinder.getFocusedNode(mAccessibilityService, false);
    if (!showMenuForNode(focused)) {
        mFeedbackManager.emitFeedback(FeedbackManager.TYPE_COMMAND_FAILED);
        closeMenu();
        return;
    }
    // Save the node.
    mInitialNode.reset(focused);
    brailleDisplayWithCurrentItem();
}

87. AccessibilityNodeInfoUtils#refreshFromParent()

Project: Accessibility-Test-Framework-for-Android
File: AccessibilityNodeInfoUtils.java
private static AccessibilityNodeInfoCompat refreshFromParent(AccessibilityNodeInfoCompat node) {
    AccessibilityNodeInfoCompat parent = node.getParent();
    if (parent != null) {
        try {
            int childCount = parent.getChildCount();
            for (int i = 0; i < childCount; ++i) {
                AccessibilityNodeInfoCompat child = parent.getChild(i);
                if (node.equals(child)) {
                    return child;
                }
                recycleNodes(child);
            }
        } finally {
            parent.recycle();
        }
    }
    return null;
}

88. AccessibilityNodeInfoUtils#searchFromInOrderTraversal()

Project: Accessibility-Test-Framework-for-Android
File: AccessibilityNodeInfoUtils.java
/**
     * Performs in-order traversal from a given node in a particular direction
     * until a node matching the specified filter is reached.
     *
     * @param context The parent context.
     * @param root The root node to traverse from.
     * @param filter The filter to satisfy.
     * @return The first node reached via in-order traversal that satisfies the
     *         filter.
     */
public static AccessibilityNodeInfoCompat searchFromInOrderTraversal(Context context, AccessibilityNodeInfoCompat root, NodeFilter filter, int direction) {
    AccessibilityNodeInfoCompat currentNode = NodeFocusFinder.focusSearch(root, direction);
    final HashSet<AccessibilityNodeInfoCompat> seenNodes = new HashSet<AccessibilityNodeInfoCompat>();
    while ((currentNode != null) && !seenNodes.contains(currentNode) && !filter.accept(context, currentNode)) {
        seenNodes.add(currentNode);
        currentNode = NodeFocusFinder.focusSearch(currentNode, direction);
    }
    // Recycle all the seen nodes.
    AccessibilityNodeInfoUtils.recycleNodes(seenNodes);
    return currentNode;
}

89. AccessibilityNodeInfoUtils#recycleNodes()

Project: Accessibility-Test-Framework-for-Android
File: AccessibilityNodeInfoUtils.java
/**
     * Recycles the given nodes.
     *
     * @param nodes The nodes to recycle.
     */
public static void recycleNodes(Collection<AccessibilityNodeInfoCompat> nodes) {
    if (nodes == null) {
        return;
    }
    for (AccessibilityNodeInfoCompat node : nodes) {
        if (node != null) {
            node.recycle();
        }
    }
    nodes.clear();
}

90. AccessibilityNodeInfoRef#parent()

Project: Accessibility-Test-Framework-for-Android
File: AccessibilityNodeInfoRef.java
/**
     * Traverses to the parent of this node, returning {@code true} on
     * success. On failure, returns {@code false} and does not move.
     */
public boolean parent() {
    if (mNode == null) {
        return false;
    }
    AccessibilityNodeInfoCompat parentNode = mNode.getParent();
    while (parentNode != null) {
        if (AccessibilityNodeInfoUtils.isVisibleOrLegacy(parentNode)) {
            reset(parentNode);
            return true;
        }
        AccessibilityNodeInfoCompat tmp = parentNode.getParent();
        parentNode.recycle();
        parentNode = tmp;
    }
    return false;
}

91. ExploreByTouchHelper#getNodeForHost()

Project: brailleback
File: ExploreByTouchHelper.java
/**
     * Constructs and returns an {@link AccessibilityNodeInfoCompat} for the
     * parent view populated with its virtual descendants.
     *
     * @return An {@link AccessibilityNodeInfoCompat} for the parent view.
     */
private AccessibilityNodeInfoCompat getNodeForHost() {
    // Since we don't want the parent to be focusable, but we can't remove
    // actions from a node, copy over the necessary fields.
    final AccessibilityNodeInfoCompat result = AccessibilityNodeInfoCompat.obtain(mHost);
    final AccessibilityNodeInfoCompat source = AccessibilityNodeInfoCompat.obtain(mHost);
    ViewCompat.onInitializeAccessibilityNodeInfo(mHost, source);
    // Copy over parent and screen bounds.
    source.getBoundsInParent(mTempParentRect);
    source.getBoundsInScreen(mTempScreenRect);
    result.setBoundsInParent(mTempParentRect);
    result.setBoundsInScreen(mTempScreenRect);
    // Set up the parent view, if applicable.
    final ViewParent parent = ViewCompat.getParentForAccessibility(mHost);
    if (parent instanceof View) {
        result.setParent((View) parent);
    }
    // Populate the minimum required fields.
    result.setVisibleToUser(source.isVisibleToUser());
    result.setPackageName(source.getPackageName());
    result.setClassName(source.getClassName());
    // Add the fake root node.
    result.addChild(mHost, ROOT_ID);
    return result;
}

92. ExploreByTouchHelper#getNodeForHost()

Project: talkback
File: ExploreByTouchHelper.java
/**
     * Constructs and returns an {@link AccessibilityNodeInfoCompat} for the
     * parent view populated with its virtual descendants.
     *
     * @return An {@link AccessibilityNodeInfoCompat} for the parent view.
     */
private AccessibilityNodeInfoCompat getNodeForHost() {
    // Since we don't want the parent to be focusable, but we can't remove
    // actions from a node, copy over the necessary fields.
    final AccessibilityNodeInfoCompat result = AccessibilityNodeInfoCompat.obtain(mHost);
    final AccessibilityNodeInfoCompat source = AccessibilityNodeInfoCompat.obtain(mHost);
    ViewCompat.onInitializeAccessibilityNodeInfo(mHost, source);
    // Copy over parent and screen bounds.
    source.getBoundsInParent(mTempParentRect);
    source.getBoundsInScreen(mTempScreenRect);
    result.setBoundsInParent(mTempParentRect);
    result.setBoundsInScreen(mTempScreenRect);
    // Set up the parent view, if applicable.
    final ViewParent parent = ViewCompat.getParentForAccessibility(mHost);
    if (parent instanceof View) {
        result.setParent((View) parent);
    }
    // Populate the minimum required fields.
    result.setVisibleToUser(source.isVisibleToUser());
    result.setPackageName(source.getPackageName());
    result.setClassName(source.getClassName());
    // Add the fake root node.
    result.addChild(mHost, ROOT_ID);
    return result;
}

93. ExploreByTouchHelper#getNodeForVirtualViewId()

Project: talkback
File: ExploreByTouchHelper.java
/**
     * Constructs and returns an {@link AccessibilityNodeInfoCompat} for the
     * specified item. Automatically manages accessibility focus actions.
     * <p>
     * Allows the implementing class to specify most node properties, but
     * overrides the following:
     * <ul>
     * <li>{@link AccessibilityNodeInfoCompat#setPackageName}
     * <li>{@link AccessibilityNodeInfoCompat#setClassName}
     * <li>{@link AccessibilityNodeInfoCompat#setParent(View)}
     * <li>{@link AccessibilityNodeInfoCompat#setSource(View, int)}
     * <li>{@link AccessibilityNodeInfoCompat#setVisibleToUser}
     * <li>{@link AccessibilityNodeInfoCompat#setBoundsInScreen(Rect)}
     * </ul>
     * <p>
     * Uses the bounds of the parent view and the parent-relative bounding
     * rectangle specified by
     * {@link AccessibilityNodeInfoCompat#getBoundsInParent} to automatically
     * update the following properties:
     * <ul>
     * <li>{@link AccessibilityNodeInfoCompat#setVisibleToUser}
     * <li>{@link AccessibilityNodeInfoCompat#setBoundsInParent(Rect)}
     * </ul>
     *
     * @param virtualViewId The virtual view id for item for which to construct
     *            a node.
     * @return An {@link AccessibilityNodeInfoCompat} for the specified item.
     */
private AccessibilityNodeInfoCompat getNodeForVirtualViewId(int virtualViewId) {
    final AccessibilityNodeInfoCompat node = AccessibilityNodeInfoCompat.obtain();
    // Ensure the client has good defaults.
    node.setEnabled(true);
    node.setClassName(mHost.getClass().getName() + DEFAULT_CLASS_NAME);
    // Allow the client to populate the node.
    populateNodeForVirtualViewId(virtualViewId, node);
    if (TextUtils.isEmpty(node.getText()) && TextUtils.isEmpty(node.getContentDescription())) {
        throw new RuntimeException("You must add text or a content description in populateNodeForVirtualViewId()");
    }
    // Don't allow the client to override these properties.
    node.setPackageName(mHost.getContext().getPackageName());
    node.setParent(mHost, ROOT_ID);
    node.setSource(mHost, virtualViewId);
    // Manage internal accessibility focus state.
    if (mFocusedVirtualViewId == virtualViewId) {
        node.setAccessibilityFocused(true);
        node.addAction(AccessibilityNodeInfoCompat.ACTION_CLEAR_ACCESSIBILITY_FOCUS);
    } else {
        node.setAccessibilityFocused(false);
        node.addAction(AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
    }
    node.getBoundsInParent(mTempParentRect);
    if (mTempParentRect.isEmpty()) {
        throw new RuntimeException("You must set parent bounds in populateNodeForVirtualViewId()");
    }
    // Set the visibility based on the parent bound.
    if (intersectVisibleToUser(mTempParentRect)) {
        node.setVisibleToUser(true);
        node.setBoundsInParent(mTempParentRect);
    }
    // Calculate screen-relative bound.
    mHost.getLocationOnScreen(mTempGlobalRect);
    final int offsetX = mTempGlobalRect[0];
    final int offsetY = mTempGlobalRect[1];
    mTempScreenRect.set(mTempParentRect);
    mTempScreenRect.offset(offsetX, offsetY);
    node.setBoundsInScreen(mTempScreenRect);
    return node;
}

94. ExploreByTouchHelper#getNodeForVirtualViewId()

Project: brailleback
File: ExploreByTouchHelper.java
/**
     * Constructs and returns an {@link AccessibilityNodeInfoCompat} for the
     * specified item. Automatically manages accessibility focus actions.
     * <p>
     * Allows the implementing class to specify most node properties, but
     * overrides the following:
     * <ul>
     * <li>{@link AccessibilityNodeInfoCompat#setPackageName}
     * <li>{@link AccessibilityNodeInfoCompat#setClassName}
     * <li>{@link AccessibilityNodeInfoCompat#setParent(View)}
     * <li>{@link AccessibilityNodeInfoCompat#setSource(View, int)}
     * <li>{@link AccessibilityNodeInfoCompat#setVisibleToUser}
     * <li>{@link AccessibilityNodeInfoCompat#setBoundsInScreen(Rect)}
     * </ul>
     * <p>
     * Uses the bounds of the parent view and the parent-relative bounding
     * rectangle specified by
     * {@link AccessibilityNodeInfoCompat#getBoundsInParent} to automatically
     * update the following properties:
     * <ul>
     * <li>{@link AccessibilityNodeInfoCompat#setVisibleToUser}
     * <li>{@link AccessibilityNodeInfoCompat#setBoundsInParent(Rect)}
     * </ul>
     *
     * @param virtualViewId The virtual view id for item for which to construct
     *            a node.
     * @return An {@link AccessibilityNodeInfoCompat} for the specified item.
     */
private AccessibilityNodeInfoCompat getNodeForVirtualViewId(int virtualViewId) {
    final AccessibilityNodeInfoCompat node = AccessibilityNodeInfoCompat.obtain();
    // Ensure the client has good defaults.
    node.setEnabled(true);
    node.setClassName(mHost.getClass().getName() + DEFAULT_CLASS_NAME);
    // Allow the client to populate the node.
    populateNodeForVirtualViewId(virtualViewId, node);
    if (TextUtils.isEmpty(node.getText()) && TextUtils.isEmpty(node.getContentDescription())) {
        throw new RuntimeException("You must add text or a content description in populateNodeForVirtualViewId()");
    }
    // Don't allow the client to override these properties.
    node.setPackageName(mHost.getContext().getPackageName());
    node.setParent(mHost, ROOT_ID);
    node.setSource(mHost, virtualViewId);
    // Manage internal accessibility focus state.
    if (mFocusedVirtualViewId == virtualViewId) {
        node.setAccessibilityFocused(true);
        node.addAction(AccessibilityNodeInfoCompat.ACTION_CLEAR_ACCESSIBILITY_FOCUS);
    } else {
        node.setAccessibilityFocused(false);
        node.addAction(AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
    }
    node.getBoundsInParent(mTempParentRect);
    if (mTempParentRect.isEmpty()) {
        throw new RuntimeException("You must set parent bounds in populateNodeForVirtualViewId()");
    }
    // Set the visibility based on the parent bound.
    if (intersectVisibleToUser(mTempParentRect)) {
        node.setVisibleToUser(true);
        node.setBoundsInParent(mTempParentRect);
    }
    // Calculate screen-relative bound.
    mHost.getLocationOnScreen(mTempGlobalRect);
    final int offsetX = mTempGlobalRect[0];
    final int offsetY = mTempGlobalRect[1];
    mTempScreenRect.set(mTempParentRect);
    mTempScreenRect.offset(offsetX, offsetY);
    node.setBoundsInScreen(mTempScreenRect);
    return node;
}

95. AccessibilityNodeInfoUtilsTest#searchFromBfsNodeMatchesSelf_shouldReturnSelf()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void searchFromBfsNodeMatchesSelf_shouldReturnSelf() {
    AccessibilityNodeInfoCompat compat = new AccessibilityNodeInfoCompat(AccessibilityNodeInfo.obtain());
    compat.setFocusable(true);
    AccessibilityNodeInfoCompat returned = AccessibilityNodeInfoUtils.searchFromBfs(compat, focusableFilter);
    assertEquals(compat, returned);
    compat.recycle();
    returned.recycle();
}

96. SearchNavigationModeTest#testDeleteKey()

Project: brailleback
File: SearchNavigationModeTest.java
public void testDeleteKey() throws Exception {
    // Set initial focus.
    AccessibilityNodeInfoCompat initial = getNodeForId(R.id.button1);
    initial.performAction(AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
    mSearchNavMode.setInitialNodeToCurrent();
    mSearchNavMode.onActivate();
    AccessibilityNodeInfoCompat root = getNodeForId(R.id.top);
    assertNotNull(root);
    // Search and focus a result.
    mSearchNavMode.setQueryTextForTest("xy");
    sendInputEvent(BrailleInputEvent.CMD_NAV_ITEM_NEXT);
    assertFocusedNodeText("xyy", root);
    // Test delete.
    sendInputEvent(BrailleInputEvent.CMD_KEY_DEL);
    assertEquals("x", mSearchNavMode.getQueryTextForTest());
    assertFocusedNodeText("xyy", root);
    // Test a second delete.
    sendInputEvent(BrailleInputEvent.CMD_KEY_DEL);
    assertEquals("", mSearchNavMode.getQueryTextForTest());
    assertFocusedNodeText("xyy", root);
    // Test a third delete. Since the query is empty now, this should escape
    // and bring focus back to the initial node.
    sendInputEvent(BrailleInputEvent.CMD_KEY_DEL);
    assertFalse(mSearchActive);
    AccessibilityNodeInfoCompat focused = getFocusedNode(root);
    assertEquals(initial, focused);
}

97. AccessibilityNodeInfoUtilsTest#hasAncestorWithoutSameAncestor_shouldReturnFalse()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void hasAncestorWithoutSameAncestor_shouldReturnFalse() {
    AccessibilityNodeInfoCompat targetAncestor = AccessibilityNodeInfoCompat.obtain();
    AccessibilityNodeInfoCompat childNode = AccessibilityNodeInfoCompat.obtain();
    assertFalse(AccessibilityNodeInfoUtils.hasAncestor(childNode, targetAncestor));
    targetAncestor.recycle();
    childNode.recycle();
}

98. AccessibilityNodeInfoUtilsTest#getRootForRootNode_shouldReturnSelf()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void getRootForRootNode_shouldReturnSelf() {
    AccessibilityNodeInfoCompat compat = new AccessibilityNodeInfoCompat(AccessibilityNodeInfo.obtain());
    AccessibilityNodeInfoCompat root = AccessibilityNodeInfoUtils.getRoot(compat);
    assertEquals(root, compat);
    compat.recycle();
    root.recycle();
}

99. AccessibilityNodeInfoUtilsTest#searchFromBfsNodeMatchesNothing_shouldReturnNull()

Project: talkback
File: AccessibilityNodeInfoUtilsTest.java
@Test
public void searchFromBfsNodeMatchesNothing_shouldReturnNull() {
    AccessibilityNodeInfoCompat compat = new AccessibilityNodeInfoCompat(AccessibilityNodeInfo.obtain());
    compat.setFocusable(false);
    assertNull(AccessibilityNodeInfoUtils.searchFromBfs(compat, focusableFilter));
    compat.recycle();
}

100. AccessibilityNodeInfoUtils#isMatchingEdgeListItem()

Project: talkback
File: AccessibilityNodeInfoUtils.java
/**
     * Utility method for determining if a searching past a particular node will
     * fall off the edge of a scrollable container.
     *
     * @param cursor Node to check.
     * @param direction The direction in which to move from the cursor.
     * @param filter Filter used to validate list-type ancestors.
     * @param traversalStrategy - traversal strategy that is used to define order of node
     * @return {@code true} if focusing search in the specified direction will
     *         fall off the edge of the container.
     */
private static boolean isMatchingEdgeListItem(AccessibilityNodeInfoCompat cursor, int direction, NodeFilter filter, TraversalStrategy traversalStrategy) {
    AccessibilityNodeInfoCompat ancestor = null;
    AccessibilityNodeInfoCompat nextFocusNode = null;
    AccessibilityNodeInfoCompat searchedAncestor = null;
    try {
        ancestor = getMatchingAncestor(cursor, filter);
        if (ancestor == null) {
            // Not contained in a scrollable list.
            return false;
        }
        nextFocusNode = searchFocus(traversalStrategy, cursor, direction, FILTER_SHOULD_FOCUS);
        if ((nextFocusNode == null) || nextFocusNode.equals(ancestor)) {
            // Can't move from this position.
            return true;
        }
        // with nextFocusNode inside it to the screen bounds.
        if (!nextFocusNode.isVisibleToUser() && WebInterfaceUtils.hasNativeWebContent(nextFocusNode)) {
            AccessibilityNodeInfoCompat webViewNode = getMatchingAncestor(nextFocusNode, new NodeFilter() {

                @Override
                public boolean accept(AccessibilityNodeInfoCompat node) {
                    return nodeMatchesClassByType(node, WebView.class);
                }
            });
            if (webViewNode != null && (!webViewNode.isVisibleToUser() || isNodeInBoundsOfOther(webViewNode, nextFocusNode))) {
                return true;
            }
        }
        searchedAncestor = getMatchingAncestor(nextFocusNode, filter);
        while (searchedAncestor != null) {
            if (ancestor.equals(searchedAncestor)) {
                return false;
            }
            AccessibilityNodeInfoCompat temp = searchedAncestor;
            searchedAncestor = getMatchingAncestor(searchedAncestor, filter);
            temp.recycle();
        }
        // Moves outside of the scrollable container.
        return true;
    } finally {
        recycleNodes(ancestor, nextFocusNode, searchedAncestor);
    }
}