Java AccessibilityWindowInfo类代码示例

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * returns true if there is no window with windowType after baseWindow
 */
public boolean isLastWindow(AccessibilityWindowInfo baseWindow, int windowType) {
    int index = getWindowIndex(baseWindow);
    if (index == WRONG_INDEX) {
        return true;
    }

    int count = mWindows.size();
    for (int i = index + 1; i < count; i++) {
        AccessibilityWindowInfo window = mWindows.get(i);
        if (window != null && window.getType() == windowType) {
            return false;
        }
    }

    return true;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * returns true if there is no window with windowType before baseWindow
 */
public boolean isFirstWindow(AccessibilityWindowInfo baseWindow, int windowType) {
    int index = getWindowIndex(baseWindow);
    if (index <= 0) {
        return true;
    }

    for (int i = index - 1; i > 0; i--) {
        AccessibilityWindowInfo window = mWindows.get(i);
        if (window != null && window.getType() == windowType) {
            return false;
        }
    }

    return true;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * @return window that currently accessibilityFocused window.
 * If there is no accessibility focused window it returns first window that has TYPE_APPLICATION
 * or null if there is no window with TYPE_APPLICATION type
 */
public AccessibilityWindowInfo getCurrentWindow(boolean useInputFocus) {
    int currentWindowIndex = getFocusedWindowIndex(mWindows,
            AccessibilityNodeInfo.FOCUS_ACCESSIBILITY);
    if (currentWindowIndex != WRONG_INDEX) {
        return mWindows.get(currentWindowIndex);
    }

    if (!useInputFocus) {
        return null;
    }

    currentWindowIndex = getFocusedWindowIndex(mWindows, AccessibilityNodeInfo.FOCUS_INPUT);
    if (currentWindowIndex != WRONG_INDEX) {
        return mWindows.get(currentWindowIndex);
    }

    return null;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * Gets the window whose anchor equals the given node.
 */
public AccessibilityWindowInfo getAnchoredWindow(
        @Nullable AccessibilityNodeInfoCompat targetAnchor) {
    if (!BuildCompat.isAtLeastN() || targetAnchor == null) {
        return null;
    }

    int windowCount = mWindows.size();
    for (int i = 0; i < windowCount; ++i) {
        AccessibilityWindowInfo window = mWindows.get(i);
        if (window != null) {
            AccessibilityNodeInfo anchor = window.getAnchor();
            if (anchor != null) {
                try {
                    if (anchor.equals(targetAnchor.getInfo())) {
                        return window;
                    }
                } finally {
                    anchor.recycle();
                }
            }
        }
    }

    return null;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
private AccessibilityWindowInfo getWindow(AccessibilityWindowInfo pivotWindow, int direction) {
    if (mWindows == null || pivotWindow == null ||
            (direction != NEXT && direction != PREVIOUS)) {
        return null;
    }

    int currentWindowIndex = getWindowIndex(pivotWindow);
    int resultIndex;
    if (direction == NEXT) {
        resultIndex = getNextWindowIndex(currentWindowIndex);
    } else {
        resultIndex = getPreviousWindowIndex(currentWindowIndex);
    }

    if (resultIndex == WRONG_INDEX) {
        return null;
    }

    return mWindows.get(resultIndex);
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
private static int getFocusedWindowIndex(List<AccessibilityWindowInfo> windows, int focusType) {
    if (windows == null) {
        return WRONG_INDEX;
    }

    for (int i = 0, size = windows.size(); i < size; i++) {
        AccessibilityWindowInfo window = windows.get(i);
        if (window == null) {
            continue;
        }

        if (focusType == AccessibilityNodeInfo.FOCUS_ACCESSIBILITY &&
                window.isAccessibilityFocused()) {
            return i;
        } else if (focusType == AccessibilityNodeInfo.FOCUS_INPUT && window.isFocused()) {
            return i;
        }
    }

    return WRONG_INDEX;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
@Override
public OptionScanNode addWindowListToTree(List<SwitchAccessWindowInfo> windowList,
        OptionScanNode tree) {
    if (windowList != null) {
        List<SwitchAccessWindowInfo> wList = new ArrayList<>(windowList);
        sortWindowListForTraversalOrder(wList);
        removeSystemButtonsWindowFromWindowList(wList);
        if (mOptionScanningEnabled) {
            return mOptionScanTreeBuilder.addWindowListToTree(wList, tree);
        }
        for (SwitchAccessWindowInfo window : wList) {
            SwitchAccessNodeCompat windowRoot = window.getRoot();
            if (windowRoot != null) {
                if (window.getType() == AccessibilityWindowInfo.TYPE_INPUT_METHOD) {
                    tree = mRowColumnTreeBuilder.addViewHierarchyToTree(windowRoot, tree);
                } else {
                    tree = addViewHierarchyToTree(windowRoot, tree);
                }
                windowRoot.recycle();
            }
        }
    }
    return tree;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
private CharSequence getWindowTitle(int windowId) {
    // Try to get window title from the map.
    CharSequence windowTitle = mWindowTitlesMap.get(windowId);
    if (windowTitle != null) {
        return windowTitle;
    }

    if (!BuildCompat.isAtLeastN()) {
        return null;
    }

    // Do not try to get system window title from AccessibilityWindowInfo.getTitle, it can
    // return non-translated value.
    if (isSystemWindow(windowId)) {
        return null;
    }

    // Try to get window title from AccessibilityWindowInfo.
    for (AccessibilityWindowInfo window : mService.getWindows()) {
        if (window.getId() == windowId) {
            return window.getTitle();
        }
    }

    return null;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
private boolean isSystemWindow(int windowId) {
    if (mSystemWindowIdsSet.contains(windowId)) {
        return true;
    }

    if (!mIsSplitScreenModeAvailable) {
        return false;
    }

    for (AccessibilityWindowInfo window : mService.getWindows()) {
        if (window.getId() == windowId &&
                window.getType() == AccessibilityWindowInfo.TYPE_SYSTEM) {
            return true;
        }
    }

    return false;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
@Override
public boolean onMenuItemClick(MenuItem item) {
    if (mAnchor != null) {
        WindowManager windowManager = new WindowManager(mService.isScreenLayoutRTL());
        windowManager.setWindows(mService.getWindows());
        AccessibilityWindowInfo anchoredWindow = windowManager.getAnchoredWindow(mAnchor);
        if (anchoredWindow != null) {
            AccessibilityNodeInfoCompat firstNode = getFirstNode(anchoredWindow);
            if (firstNode != null) {
                CursorController cursorController = mService.getCursorController();
                cursorController.setCursor(firstNode);
                firstNode.recycle();
            }
        }

        mAnchor.recycle();
        mAnchor = null;
    }
    return true;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
private AccessibilityNodeInfoCompat getFirstNode(AccessibilityWindowInfo window) {
    AccessibilityNodeInfo root = window.getRoot();
    if (root != null) {
        AccessibilityNodeInfoCompat compatRoot = new AccessibilityNodeInfoCompat(root);
        TraversalStrategy traversalStrategy = TraversalStrategyUtils.getTraversalStrategy(
                compatRoot, TraversalStrategy.SEARCH_FOCUS_FORWARD);

        AccessibilityNodeInfoCompat firstNode = AccessibilityNodeInfoUtils.searchFocus(
                traversalStrategy,
                compatRoot,
                TraversalStrategy.SEARCH_FOCUS_FORWARD,
                AccessibilityNodeInfoUtils.FILTER_SHOULD_FOCUS);

        compatRoot.recycle(); // This will also recycle the underlying node (root).
        return firstNode;
    }

    return null;
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * @return root node of the window that currently has accessibility focus
 */
public static AccessibilityNodeInfoCompat getRootInAccessibilityFocusedWindow(
        AccessibilityService service) {
    if (service == null) {
        return null;
    }

    AccessibilityNodeInfo focusedRoot = null;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
        List<AccessibilityWindowInfo> windows = service.getWindows();
        // Create window manager with fake value of isInRTL = false. This is okay here since
        // isInRTL will not change the result of getCurrentWindow.
        WindowManager manager = new WindowManager(false /* isInRTL */);
        manager.setWindows(windows);
        AccessibilityWindowInfo accessibilityFocusedWindow =
                manager.getCurrentWindow(false /* useInputFocus */);

        if (accessibilityFocusedWindow != null) {
            focusedRoot = accessibilityFocusedWindow.getRoot();
        }
    }

    if (focusedRoot == null) {
        focusedRoot = service.getRootInActiveWindow();
    }

    if (focusedRoot == null) {
        return null;
    }

    return new AccessibilityNodeInfoCompat(focusedRoot);
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * Returns a fresh copy of node by traversing the given window for a similar node.
 * For example, the node that you want might be in a popup window that has closed and re-opened,
 * causing the accessibility IDs of its views to be different.
 * Note: you must recycle the node that is returned from this method.
 */
public static AccessibilityNodeInfoCompat refreshNodeFuzzy(
        final AccessibilityNodeInfoCompat node,
        AccessibilityWindowInfo window) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
        return null;
    }

    if (window == null || node == null) {
        return null;
    }

    AccessibilityNodeInfo root = window.getRoot();
    if (root == null) {
        return null;
    }

    NodeFilter similarFilter = new NodeFilter() {
        @Override
        public boolean accept(AccessibilityNodeInfoCompat other) {
            return other != null && TextUtils.equals(node.getText(), other.getText());
        }
    };

    AccessibilityNodeInfoCompat rootCompat = new AccessibilityNodeInfoCompat(root);
    try {
        return getMatchingDescendant(rootCompat, similarFilter);
    } finally {
        rootCompat.recycle();
    }
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
/**
 * Returns the node to which the given node's window is anchored, if there is an anchor.
 * Note: you must recycle the node that is returned from this method.
 */
public static AccessibilityNodeInfoCompat getAnchor(
        @Nullable AccessibilityNodeInfoCompat node) {
    if (!BuildCompat.isAtLeastN()) {
        return null;
    }

    if (node == null) {
        return null;
    }

    AccessibilityNodeInfo nativeNode = (AccessibilityNodeInfo) node.getInfo();
    if (nativeNode == null) {
        return null;
    }

    AccessibilityWindowInfo nativeWindow = nativeNode.getWindow();
    if (nativeWindow == null) {
        return null;
    }

    AccessibilityNodeInfo nativeAnchor = nativeWindow.getAnchor();
    if (nativeAnchor == null) {
        return null;
    }

    return new AccessibilityNodeInfoCompat(nativeAnchor);
}
 

import android.view.accessibility.AccessibilityWindowInfo; //导入依赖的package包/类
@Override
public int compare(AccessibilityWindowInfo windowA, AccessibilityWindowInfo windowB) {
    windowA.getBoundsInScreen(mRectA);
    windowB.getBoundsInScreen(mRectB);

    if (mRectA.top != mRectB.top) {
        return mRectA.top - mRectB.top;
    } else {
        return mIsInRTL ? mRectB.right - mRectA.right : mRectA.left - mRectB.left;
    }
}