| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.view; |
| |
| import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD; |
| import static android.view.accessibility.AccessibilityNodeInfo.ACTION_ARGUMENT_ACCESSIBLE_CLICKABLE_SPAN; |
| import static android.view.accessibility.AccessibilityNodeInfo.EXTRA_DATA_REQUESTED_KEY; |
| import static android.view.accessibility.AccessibilityNodeInfo.EXTRA_DATA_TEXT_CHARACTER_LOCATION_KEY; |
| |
| import android.graphics.Point; |
| import android.graphics.Rect; |
| import android.graphics.RectF; |
| import android.graphics.Region; |
| import android.os.Binder; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.Parcelable; |
| import android.os.Process; |
| import android.os.RemoteException; |
| import android.os.SystemClock; |
| import android.text.style.AccessibilityClickableSpan; |
| import android.text.style.ClickableSpan; |
| import android.util.LongSparseArray; |
| import android.util.Slog; |
| import android.view.View.AttachInfo; |
| import android.view.accessibility.AccessibilityInteractionClient; |
| import android.view.accessibility.AccessibilityManager; |
| import android.view.accessibility.AccessibilityNodeIdManager; |
| import android.view.accessibility.AccessibilityNodeInfo; |
| import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction; |
| import android.view.accessibility.AccessibilityNodeProvider; |
| import android.view.accessibility.AccessibilityRequestPreparer; |
| import android.view.accessibility.IAccessibilityInteractionConnectionCallback; |
| |
| import com.android.internal.R; |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.os.SomeArgs; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Queue; |
| import java.util.function.Predicate; |
| |
| /** |
| * Class for managing accessibility interactions initiated from the system |
| * and targeting the view hierarchy. A *ClientThread method is to be |
| * called from the interaction connection ViewAncestor gives the system to |
| * talk to it and a corresponding *UiThread method that is executed on the |
| * UI thread. |
| * |
| * @hide |
| */ |
| @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE) |
| public final class AccessibilityInteractionController { |
| |
| private static final String LOG_TAG = "AccessibilityInteractionController"; |
| |
| // Debugging flag |
| private static final boolean ENFORCE_NODE_TREE_CONSISTENT = false; |
| |
| // Constants for readability |
| private static final boolean IGNORE_REQUEST_PREPARERS = true; |
| private static final boolean CONSIDER_REQUEST_PREPARERS = false; |
| |
| // If an app holds off accessibility for longer than this, the hold-off is canceled to prevent |
| // accessibility from hanging |
| private static final long REQUEST_PREPARER_TIMEOUT_MS = 500; |
| |
| private final ArrayList<AccessibilityNodeInfo> mTempAccessibilityNodeInfoList = |
| new ArrayList<AccessibilityNodeInfo>(); |
| |
| private final Object mLock = new Object(); |
| |
| private final PrivateHandler mHandler; |
| |
| private final ViewRootImpl mViewRootImpl; |
| |
| private final AccessibilityNodePrefetcher mPrefetcher; |
| |
| private final long mMyLooperThreadId; |
| |
| private final int mMyProcessId; |
| |
| private final AccessibilityManager mA11yManager; |
| |
| private final ArrayList<View> mTempArrayList = new ArrayList<View>(); |
| |
| private final Point mTempPoint = new Point(); |
| private final Rect mTempRect = new Rect(); |
| private final Rect mTempRect1 = new Rect(); |
| private final Rect mTempRect2 = new Rect(); |
| |
| private AddNodeInfosForViewId mAddNodeInfosForViewId; |
| |
| @GuardedBy("mLock") |
| private int mNumActiveRequestPreparers; |
| @GuardedBy("mLock") |
| private List<MessageHolder> mMessagesWaitingForRequestPreparer; |
| @GuardedBy("mLock") |
| private int mActiveRequestPreparerId; |
| |
| public AccessibilityInteractionController(ViewRootImpl viewRootImpl) { |
| Looper looper = viewRootImpl.mHandler.getLooper(); |
| mMyLooperThreadId = looper.getThread().getId(); |
| mMyProcessId = Process.myPid(); |
| mHandler = new PrivateHandler(looper); |
| mViewRootImpl = viewRootImpl; |
| mPrefetcher = new AccessibilityNodePrefetcher(); |
| mA11yManager = mViewRootImpl.mContext.getSystemService(AccessibilityManager.class); |
| } |
| |
| private void scheduleMessage(Message message, int interrogatingPid, long interrogatingTid, |
| boolean ignoreRequestPreparers) { |
| if (ignoreRequestPreparers |
| || !holdOffMessageIfNeeded(message, interrogatingPid, interrogatingTid)) { |
| // If the interrogation is performed by the same thread as the main UI |
| // thread in this process, set the message as a static reference so |
| // after this call completes the same thread but in the interrogating |
| // client can handle the message to generate the result. |
| if (interrogatingPid == mMyProcessId && interrogatingTid == mMyLooperThreadId |
| && mHandler.hasAccessibilityCallback(message)) { |
| AccessibilityInteractionClient.getInstanceForThread( |
| interrogatingTid).setSameThreadMessage(message); |
| } else { |
| // For messages without callback of interrogating client, just handle the |
| // message immediately if this is UI thread. |
| if (!mHandler.hasAccessibilityCallback(message) |
| && Thread.currentThread().getId() == mMyLooperThreadId) { |
| mHandler.handleMessage(message); |
| } else { |
| mHandler.sendMessage(message); |
| } |
| } |
| } |
| } |
| |
| private boolean isShown(View view) { |
| return (view != null) && (view.getWindowVisibility() == View.VISIBLE && view.isShown()); |
| } |
| |
| public void findAccessibilityNodeInfoByAccessibilityIdClientThread( |
| long accessibilityNodeId, Region interactiveRegion, int interactionId, |
| IAccessibilityInteractionConnectionCallback callback, int flags, int interrogatingPid, |
| long interrogatingTid, MagnificationSpec spec, Bundle arguments) { |
| final Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID; |
| message.arg1 = flags; |
| |
| final SomeArgs args = SomeArgs.obtain(); |
| args.argi1 = AccessibilityNodeInfo.getAccessibilityViewId(accessibilityNodeId); |
| args.argi2 = AccessibilityNodeInfo.getVirtualDescendantId(accessibilityNodeId); |
| args.argi3 = interactionId; |
| args.arg1 = callback; |
| args.arg2 = spec; |
| args.arg3 = interactiveRegion; |
| args.arg4 = arguments; |
| message.obj = args; |
| |
| scheduleMessage(message, interrogatingPid, interrogatingTid, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| /** |
| * Check if this message needs to be held off while the app prepares to meet either this |
| * request, or a request ahead of it. |
| * |
| * @param originalMessage The message to be processed |
| * @param callingPid The calling process id |
| * @param callingTid The calling thread id |
| * |
| * @return {@code true} if the message is held off and will be processed later, {@code false} if |
| * the message should be posted. |
| */ |
| private boolean holdOffMessageIfNeeded( |
| Message originalMessage, int callingPid, long callingTid) { |
| synchronized (mLock) { |
| // If a request is already pending, queue this request for when it's finished |
| if (mNumActiveRequestPreparers != 0) { |
| queueMessageToHandleOncePrepared(originalMessage, callingPid, callingTid); |
| return true; |
| } |
| |
| // Currently the only message that can hold things off is findByA11yId with extra data. |
| if (originalMessage.what |
| != PrivateHandler.MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID) { |
| return false; |
| } |
| SomeArgs originalMessageArgs = (SomeArgs) originalMessage.obj; |
| Bundle requestArguments = (Bundle) originalMessageArgs.arg4; |
| if (requestArguments == null) { |
| return false; |
| } |
| |
| // If nothing it registered for this view, nothing to do |
| int accessibilityViewId = originalMessageArgs.argi1; |
| final List<AccessibilityRequestPreparer> preparers = |
| mA11yManager.getRequestPreparersForAccessibilityId(accessibilityViewId); |
| if (preparers == null) { |
| return false; |
| } |
| |
| // If the bundle doesn't request the extra data, nothing to do |
| final String extraDataKey = requestArguments.getString(EXTRA_DATA_REQUESTED_KEY); |
| if (extraDataKey == null) { |
| return false; |
| } |
| |
| // Send the request to the AccessibilityRequestPreparers on the UI thread |
| mNumActiveRequestPreparers = preparers.size(); |
| for (int i = 0; i < preparers.size(); i++) { |
| final Message requestPreparerMessage = mHandler.obtainMessage( |
| PrivateHandler.MSG_PREPARE_FOR_EXTRA_DATA_REQUEST); |
| final SomeArgs requestPreparerArgs = SomeArgs.obtain(); |
| // virtualDescendentId |
| requestPreparerArgs.argi1 = |
| (originalMessageArgs.argi2 == AccessibilityNodeInfo.UNDEFINED_ITEM_ID) |
| ? AccessibilityNodeProvider.HOST_VIEW_ID : originalMessageArgs.argi2; |
| requestPreparerArgs.arg1 = preparers.get(i); |
| requestPreparerArgs.arg2 = extraDataKey; |
| requestPreparerArgs.arg3 = requestArguments; |
| Message preparationFinishedMessage = mHandler.obtainMessage( |
| PrivateHandler.MSG_APP_PREPARATION_FINISHED); |
| preparationFinishedMessage.arg1 = ++mActiveRequestPreparerId; |
| requestPreparerArgs.arg4 = preparationFinishedMessage; |
| |
| requestPreparerMessage.obj = requestPreparerArgs; |
| scheduleMessage(requestPreparerMessage, callingPid, callingTid, |
| IGNORE_REQUEST_PREPARERS); |
| mHandler.obtainMessage(PrivateHandler.MSG_APP_PREPARATION_TIMEOUT); |
| mHandler.sendEmptyMessageDelayed(PrivateHandler.MSG_APP_PREPARATION_TIMEOUT, |
| REQUEST_PREPARER_TIMEOUT_MS); |
| } |
| |
| // Set the initial request aside |
| queueMessageToHandleOncePrepared(originalMessage, callingPid, callingTid); |
| return true; |
| } |
| } |
| |
| private void prepareForExtraDataRequestUiThread(Message message) { |
| SomeArgs args = (SomeArgs) message.obj; |
| final int virtualDescendantId = args.argi1; |
| final AccessibilityRequestPreparer preparer = (AccessibilityRequestPreparer) args.arg1; |
| final String extraDataKey = (String) args.arg2; |
| final Bundle requestArguments = (Bundle) args.arg3; |
| final Message preparationFinishedMessage = (Message) args.arg4; |
| |
| preparer.onPrepareExtraData(virtualDescendantId, extraDataKey, |
| requestArguments, preparationFinishedMessage); |
| } |
| |
| private void queueMessageToHandleOncePrepared(Message message, int interrogatingPid, |
| long interrogatingTid) { |
| if (mMessagesWaitingForRequestPreparer == null) { |
| mMessagesWaitingForRequestPreparer = new ArrayList<>(1); |
| } |
| MessageHolder messageHolder = |
| new MessageHolder(message, interrogatingPid, interrogatingTid); |
| mMessagesWaitingForRequestPreparer.add(messageHolder); |
| } |
| |
| private void requestPreparerDoneUiThread(Message message) { |
| synchronized (mLock) { |
| if (message.arg1 != mActiveRequestPreparerId) { |
| Slog.e(LOG_TAG, "Surprising AccessibilityRequestPreparer callback (likely late)"); |
| return; |
| } |
| mNumActiveRequestPreparers--; |
| if (mNumActiveRequestPreparers <= 0) { |
| mHandler.removeMessages(PrivateHandler.MSG_APP_PREPARATION_TIMEOUT); |
| scheduleAllMessagesWaitingForRequestPreparerLocked(); |
| } |
| } |
| } |
| |
| private void requestPreparerTimeoutUiThread() { |
| synchronized (mLock) { |
| Slog.e(LOG_TAG, "AccessibilityRequestPreparer timed out"); |
| scheduleAllMessagesWaitingForRequestPreparerLocked(); |
| } |
| } |
| |
| @GuardedBy("mLock") |
| private void scheduleAllMessagesWaitingForRequestPreparerLocked() { |
| int numMessages = mMessagesWaitingForRequestPreparer.size(); |
| for (int i = 0; i < numMessages; i++) { |
| MessageHolder request = mMessagesWaitingForRequestPreparer.get(i); |
| scheduleMessage(request.mMessage, request.mInterrogatingPid, |
| request.mInterrogatingTid, |
| (i == 0) /* the app is ready for the first request */); |
| } |
| mMessagesWaitingForRequestPreparer.clear(); |
| mNumActiveRequestPreparers = 0; // Just to be safe - should be unnecessary |
| mActiveRequestPreparerId = -1; |
| } |
| |
| private void findAccessibilityNodeInfoByAccessibilityIdUiThread(Message message) { |
| final int flags = message.arg1; |
| |
| SomeArgs args = (SomeArgs) message.obj; |
| final int accessibilityViewId = args.argi1; |
| final int virtualDescendantId = args.argi2; |
| final int interactionId = args.argi3; |
| final IAccessibilityInteractionConnectionCallback callback = |
| (IAccessibilityInteractionConnectionCallback) args.arg1; |
| final MagnificationSpec spec = (MagnificationSpec) args.arg2; |
| final Region interactiveRegion = (Region) args.arg3; |
| final Bundle arguments = (Bundle) args.arg4; |
| |
| args.recycle(); |
| |
| List<AccessibilityNodeInfo> infos = mTempAccessibilityNodeInfoList; |
| infos.clear(); |
| try { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) { |
| return; |
| } |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags; |
| final View root = findViewByAccessibilityId(accessibilityViewId); |
| if (root != null && isShown(root)) { |
| mPrefetcher.prefetchAccessibilityNodeInfos( |
| root, virtualDescendantId, flags, infos, arguments); |
| } |
| } finally { |
| updateInfosForViewportAndReturnFindNodeResult( |
| infos, callback, interactionId, spec, interactiveRegion); |
| } |
| } |
| |
| public void findAccessibilityNodeInfosByViewIdClientThread(long accessibilityNodeId, |
| String viewId, Region interactiveRegion, int interactionId, |
| IAccessibilityInteractionConnectionCallback callback, int flags, int interrogatingPid, |
| long interrogatingTid, MagnificationSpec spec) { |
| Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID; |
| message.arg1 = flags; |
| message.arg2 = AccessibilityNodeInfo.getAccessibilityViewId(accessibilityNodeId); |
| |
| SomeArgs args = SomeArgs.obtain(); |
| args.argi1 = interactionId; |
| args.arg1 = callback; |
| args.arg2 = spec; |
| args.arg3 = viewId; |
| args.arg4 = interactiveRegion; |
| message.obj = args; |
| |
| scheduleMessage(message, interrogatingPid, interrogatingTid, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void findAccessibilityNodeInfosByViewIdUiThread(Message message) { |
| final int flags = message.arg1; |
| final int accessibilityViewId = message.arg2; |
| |
| SomeArgs args = (SomeArgs) message.obj; |
| final int interactionId = args.argi1; |
| final IAccessibilityInteractionConnectionCallback callback = |
| (IAccessibilityInteractionConnectionCallback) args.arg1; |
| final MagnificationSpec spec = (MagnificationSpec) args.arg2; |
| final String viewId = (String) args.arg3; |
| final Region interactiveRegion = (Region) args.arg4; |
| args.recycle(); |
| |
| final List<AccessibilityNodeInfo> infos = mTempAccessibilityNodeInfoList; |
| infos.clear(); |
| try { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) { |
| return; |
| } |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags; |
| final View root = findViewByAccessibilityId(accessibilityViewId); |
| if (root != null) { |
| final int resolvedViewId = root.getContext().getResources() |
| .getIdentifier(viewId, null, null); |
| if (resolvedViewId <= 0) { |
| return; |
| } |
| if (mAddNodeInfosForViewId == null) { |
| mAddNodeInfosForViewId = new AddNodeInfosForViewId(); |
| } |
| mAddNodeInfosForViewId.init(resolvedViewId, infos); |
| root.findViewByPredicate(mAddNodeInfosForViewId); |
| mAddNodeInfosForViewId.reset(); |
| } |
| } finally { |
| updateInfosForViewportAndReturnFindNodeResult( |
| infos, callback, interactionId, spec, interactiveRegion); |
| } |
| } |
| |
| public void findAccessibilityNodeInfosByTextClientThread(long accessibilityNodeId, |
| String text, Region interactiveRegion, int interactionId, |
| IAccessibilityInteractionConnectionCallback callback, int flags, int interrogatingPid, |
| long interrogatingTid, MagnificationSpec spec) { |
| Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT; |
| message.arg1 = flags; |
| |
| SomeArgs args = SomeArgs.obtain(); |
| args.arg1 = text; |
| args.arg2 = callback; |
| args.arg3 = spec; |
| args.argi1 = AccessibilityNodeInfo.getAccessibilityViewId(accessibilityNodeId); |
| args.argi2 = AccessibilityNodeInfo.getVirtualDescendantId(accessibilityNodeId); |
| args.argi3 = interactionId; |
| args.arg4 = interactiveRegion; |
| message.obj = args; |
| |
| scheduleMessage(message, interrogatingPid, interrogatingTid, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void findAccessibilityNodeInfosByTextUiThread(Message message) { |
| final int flags = message.arg1; |
| |
| SomeArgs args = (SomeArgs) message.obj; |
| final String text = (String) args.arg1; |
| final IAccessibilityInteractionConnectionCallback callback = |
| (IAccessibilityInteractionConnectionCallback) args.arg2; |
| final MagnificationSpec spec = (MagnificationSpec) args.arg3; |
| final int accessibilityViewId = args.argi1; |
| final int virtualDescendantId = args.argi2; |
| final int interactionId = args.argi3; |
| final Region interactiveRegion = (Region) args.arg4; |
| args.recycle(); |
| |
| List<AccessibilityNodeInfo> infos = null; |
| try { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) { |
| return; |
| } |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags; |
| final View root = findViewByAccessibilityId(accessibilityViewId); |
| if (root != null && isShown(root)) { |
| AccessibilityNodeProvider provider = root.getAccessibilityNodeProvider(); |
| if (provider != null) { |
| infos = provider.findAccessibilityNodeInfosByText(text, |
| virtualDescendantId); |
| } else if (virtualDescendantId == AccessibilityNodeProvider.HOST_VIEW_ID) { |
| ArrayList<View> foundViews = mTempArrayList; |
| foundViews.clear(); |
| root.findViewsWithText(foundViews, text, View.FIND_VIEWS_WITH_TEXT |
| | View.FIND_VIEWS_WITH_CONTENT_DESCRIPTION |
| | View.FIND_VIEWS_WITH_ACCESSIBILITY_NODE_PROVIDERS); |
| if (!foundViews.isEmpty()) { |
| infos = mTempAccessibilityNodeInfoList; |
| infos.clear(); |
| final int viewCount = foundViews.size(); |
| for (int i = 0; i < viewCount; i++) { |
| View foundView = foundViews.get(i); |
| if (isShown(foundView)) { |
| provider = foundView.getAccessibilityNodeProvider(); |
| if (provider != null) { |
| List<AccessibilityNodeInfo> infosFromProvider = |
| provider.findAccessibilityNodeInfosByText(text, |
| AccessibilityNodeProvider.HOST_VIEW_ID); |
| if (infosFromProvider != null) { |
| infos.addAll(infosFromProvider); |
| } |
| } else { |
| infos.add(foundView.createAccessibilityNodeInfo()); |
| } |
| } |
| } |
| } |
| } |
| } |
| } finally { |
| updateInfosForViewportAndReturnFindNodeResult( |
| infos, callback, interactionId, spec, interactiveRegion); |
| } |
| } |
| |
| public void findFocusClientThread(long accessibilityNodeId, int focusType, |
| Region interactiveRegion, int interactionId, |
| IAccessibilityInteractionConnectionCallback callback, int flags, int interrogatingPid, |
| long interrogatingTid, MagnificationSpec spec) { |
| Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_FIND_FOCUS; |
| message.arg1 = flags; |
| message.arg2 = focusType; |
| |
| SomeArgs args = SomeArgs.obtain(); |
| args.argi1 = interactionId; |
| args.argi2 = AccessibilityNodeInfo.getAccessibilityViewId(accessibilityNodeId); |
| args.argi3 = AccessibilityNodeInfo.getVirtualDescendantId(accessibilityNodeId); |
| args.arg1 = callback; |
| args.arg2 = spec; |
| args.arg3 = interactiveRegion; |
| |
| message.obj = args; |
| |
| scheduleMessage(message, interrogatingPid, interrogatingTid, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void findFocusUiThread(Message message) { |
| final int flags = message.arg1; |
| final int focusType = message.arg2; |
| |
| SomeArgs args = (SomeArgs) message.obj; |
| final int interactionId = args.argi1; |
| final int accessibilityViewId = args.argi2; |
| final int virtualDescendantId = args.argi3; |
| final IAccessibilityInteractionConnectionCallback callback = |
| (IAccessibilityInteractionConnectionCallback) args.arg1; |
| final MagnificationSpec spec = (MagnificationSpec) args.arg2; |
| final Region interactiveRegion = (Region) args.arg3; |
| args.recycle(); |
| |
| AccessibilityNodeInfo focused = null; |
| try { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) { |
| return; |
| } |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags; |
| final View root = findViewByAccessibilityId(accessibilityViewId); |
| if (root != null && isShown(root)) { |
| switch (focusType) { |
| case AccessibilityNodeInfo.FOCUS_ACCESSIBILITY: { |
| View host = mViewRootImpl.mAccessibilityFocusedHost; |
| // If there is no accessibility focus host or it is not a descendant |
| // of the root from which to start the search, then the search failed. |
| if (host == null || !ViewRootImpl.isViewDescendantOf(host, root)) { |
| break; |
| } |
| // The focused view not shown, we failed. |
| if (!isShown(host)) { |
| break; |
| } |
| // If the host has a provider ask this provider to search for the |
| // focus instead fetching all provider nodes to do the search here. |
| AccessibilityNodeProvider provider = host.getAccessibilityNodeProvider(); |
| if (provider != null) { |
| if (mViewRootImpl.mAccessibilityFocusedVirtualView != null) { |
| focused = AccessibilityNodeInfo.obtain( |
| mViewRootImpl.mAccessibilityFocusedVirtualView); |
| } |
| } else if (virtualDescendantId == AccessibilityNodeProvider.HOST_VIEW_ID) { |
| focused = host.createAccessibilityNodeInfo(); |
| } |
| } break; |
| case AccessibilityNodeInfo.FOCUS_INPUT: { |
| View target = root.findFocus(); |
| if (!isShown(target)) { |
| break; |
| } |
| AccessibilityNodeProvider provider = target.getAccessibilityNodeProvider(); |
| if (provider != null) { |
| focused = provider.findFocus(focusType); |
| } |
| if (focused == null) { |
| focused = target.createAccessibilityNodeInfo(); |
| } |
| } break; |
| default: |
| throw new IllegalArgumentException("Unknown focus type: " + focusType); |
| } |
| } |
| } finally { |
| updateInfoForViewportAndReturnFindNodeResult( |
| focused, callback, interactionId, spec, interactiveRegion); |
| } |
| } |
| |
| public void focusSearchClientThread(long accessibilityNodeId, int direction, |
| Region interactiveRegion, int interactionId, |
| IAccessibilityInteractionConnectionCallback callback, int flags, int interrogatingPid, |
| long interrogatingTid, MagnificationSpec spec) { |
| Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_FOCUS_SEARCH; |
| message.arg1 = flags; |
| message.arg2 = AccessibilityNodeInfo.getAccessibilityViewId(accessibilityNodeId); |
| |
| SomeArgs args = SomeArgs.obtain(); |
| args.argi2 = direction; |
| args.argi3 = interactionId; |
| args.arg1 = callback; |
| args.arg2 = spec; |
| args.arg3 = interactiveRegion; |
| |
| message.obj = args; |
| |
| scheduleMessage(message, interrogatingPid, interrogatingTid, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void focusSearchUiThread(Message message) { |
| final int flags = message.arg1; |
| final int accessibilityViewId = message.arg2; |
| |
| SomeArgs args = (SomeArgs) message.obj; |
| final int direction = args.argi2; |
| final int interactionId = args.argi3; |
| final IAccessibilityInteractionConnectionCallback callback = |
| (IAccessibilityInteractionConnectionCallback) args.arg1; |
| final MagnificationSpec spec = (MagnificationSpec) args.arg2; |
| final Region interactiveRegion = (Region) args.arg3; |
| |
| args.recycle(); |
| |
| AccessibilityNodeInfo next = null; |
| try { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) { |
| return; |
| } |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags; |
| final View root = findViewByAccessibilityId(accessibilityViewId); |
| if (root != null && isShown(root)) { |
| View nextView = root.focusSearch(direction); |
| if (nextView != null) { |
| next = nextView.createAccessibilityNodeInfo(); |
| } |
| } |
| } finally { |
| updateInfoForViewportAndReturnFindNodeResult( |
| next, callback, interactionId, spec, interactiveRegion); |
| } |
| } |
| |
| public void performAccessibilityActionClientThread(long accessibilityNodeId, int action, |
| Bundle arguments, int interactionId, |
| IAccessibilityInteractionConnectionCallback callback, int flags, int interrogatingPid, |
| long interrogatingTid) { |
| Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_PERFORM_ACCESSIBILITY_ACTION; |
| message.arg1 = flags; |
| message.arg2 = AccessibilityNodeInfo.getAccessibilityViewId(accessibilityNodeId); |
| |
| SomeArgs args = SomeArgs.obtain(); |
| args.argi1 = AccessibilityNodeInfo.getVirtualDescendantId(accessibilityNodeId); |
| args.argi2 = action; |
| args.argi3 = interactionId; |
| args.arg1 = callback; |
| args.arg2 = arguments; |
| |
| message.obj = args; |
| |
| scheduleMessage(message, interrogatingPid, interrogatingTid, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void performAccessibilityActionUiThread(Message message) { |
| final int flags = message.arg1; |
| final int accessibilityViewId = message.arg2; |
| |
| SomeArgs args = (SomeArgs) message.obj; |
| final int virtualDescendantId = args.argi1; |
| final int action = args.argi2; |
| final int interactionId = args.argi3; |
| final IAccessibilityInteractionConnectionCallback callback = |
| (IAccessibilityInteractionConnectionCallback) args.arg1; |
| Bundle arguments = (Bundle) args.arg2; |
| |
| args.recycle(); |
| |
| boolean succeeded = false; |
| try { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null || |
| mViewRootImpl.mStopped || mViewRootImpl.mPausedForTransition) { |
| return; |
| } |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = flags; |
| final View target = findViewByAccessibilityId(accessibilityViewId); |
| if (target != null && isShown(target)) { |
| if (action == R.id.accessibilityActionClickOnClickableSpan) { |
| // Handle this hidden action separately |
| succeeded = handleClickableSpanActionUiThread( |
| target, virtualDescendantId, arguments); |
| } else { |
| AccessibilityNodeProvider provider = target.getAccessibilityNodeProvider(); |
| if (provider != null) { |
| succeeded = provider.performAction(virtualDescendantId, action, |
| arguments); |
| } else if (virtualDescendantId == AccessibilityNodeProvider.HOST_VIEW_ID) { |
| succeeded = target.performAccessibilityAction(action, arguments); |
| } |
| } |
| } |
| } finally { |
| try { |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = 0; |
| callback.setPerformAccessibilityActionResult(succeeded, interactionId); |
| } catch (RemoteException re) { |
| /* ignore - the other side will time out */ |
| } |
| } |
| } |
| |
| /** |
| * Finds the accessibility focused node in the root, and clears the accessibility focus. |
| */ |
| public void clearAccessibilityFocusClientThread() { |
| final Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_CLEAR_ACCESSIBILITY_FOCUS; |
| |
| // Don't care about pid and tid because there's no interrogating client for this message. |
| scheduleMessage(message, 0, 0, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void clearAccessibilityFocusUiThread() { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null) { |
| return; |
| } |
| try { |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = |
| AccessibilityNodeInfo.FLAG_INCLUDE_NOT_IMPORTANT_VIEWS; |
| final View root = mViewRootImpl.mView; |
| if (root != null && isShown(root)) { |
| final View host = mViewRootImpl.mAccessibilityFocusedHost; |
| // If there is no accessibility focus host or it is not a descendant |
| // of the root from which to start the search, then the search failed. |
| if (host == null || !ViewRootImpl.isViewDescendantOf(host, root)) { |
| return; |
| } |
| final AccessibilityNodeProvider provider = host.getAccessibilityNodeProvider(); |
| final AccessibilityNodeInfo focusNode = |
| mViewRootImpl.mAccessibilityFocusedVirtualView; |
| if (provider != null && focusNode != null) { |
| final int virtualNodeId = AccessibilityNodeInfo.getVirtualDescendantId( |
| focusNode.getSourceNodeId()); |
| provider.performAction(virtualNodeId, |
| AccessibilityAction.ACTION_CLEAR_ACCESSIBILITY_FOCUS.getId(), |
| null); |
| } else { |
| host.performAccessibilityAction( |
| AccessibilityAction.ACTION_CLEAR_ACCESSIBILITY_FOCUS.getId(), |
| null); |
| } |
| } |
| } finally { |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = 0; |
| } |
| } |
| |
| /** |
| * Notify outside touch event to the target window. |
| */ |
| public void notifyOutsideTouchClientThread() { |
| final Message message = mHandler.obtainMessage(); |
| message.what = PrivateHandler.MSG_NOTIFY_OUTSIDE_TOUCH; |
| |
| // Don't care about pid and tid because there's no interrogating client for this message. |
| scheduleMessage(message, 0, 0, CONSIDER_REQUEST_PREPARERS); |
| } |
| |
| private void notifyOutsideTouchUiThread() { |
| if (mViewRootImpl.mView == null || mViewRootImpl.mAttachInfo == null |
| || mViewRootImpl.mStopped || mViewRootImpl.mPausedForTransition) { |
| return; |
| } |
| final View root = mViewRootImpl.mView; |
| if (root != null && isShown(root)) { |
| // trigger ACTION_OUTSIDE to notify windows |
| final long now = SystemClock.uptimeMillis(); |
| final MotionEvent event = MotionEvent.obtain(now, now, MotionEvent.ACTION_OUTSIDE, |
| 0, 0, 0); |
| event.setSource(InputDevice.SOURCE_TOUCHSCREEN); |
| mViewRootImpl.dispatchInputEvent(event); |
| } |
| } |
| |
| private View findViewByAccessibilityId(int accessibilityId) { |
| if (accessibilityId == AccessibilityNodeInfo.ROOT_ITEM_ID) { |
| return mViewRootImpl.mView; |
| } else { |
| return AccessibilityNodeIdManager.getInstance().findView(accessibilityId); |
| } |
| } |
| |
| private void applyAppScaleAndMagnificationSpecIfNeeded(List<AccessibilityNodeInfo> infos, |
| MagnificationSpec spec) { |
| if (infos == null) { |
| return; |
| } |
| final float applicationScale = mViewRootImpl.mAttachInfo.mApplicationScale; |
| if (shouldApplyAppScaleAndMagnificationSpec(applicationScale, spec)) { |
| final int infoCount = infos.size(); |
| for (int i = 0; i < infoCount; i++) { |
| AccessibilityNodeInfo info = infos.get(i); |
| applyAppScaleAndMagnificationSpecIfNeeded(info, spec); |
| } |
| } |
| } |
| |
| private void adjustIsVisibleToUserIfNeeded(List<AccessibilityNodeInfo> infos, |
| Region interactiveRegion) { |
| if (interactiveRegion == null || infos == null) { |
| return; |
| } |
| final int infoCount = infos.size(); |
| for (int i = 0; i < infoCount; i++) { |
| AccessibilityNodeInfo info = infos.get(i); |
| adjustIsVisibleToUserIfNeeded(info, interactiveRegion); |
| } |
| } |
| |
| private void adjustIsVisibleToUserIfNeeded(AccessibilityNodeInfo info, |
| Region interactiveRegion) { |
| if (interactiveRegion == null || info == null) { |
| return; |
| } |
| Rect boundsInScreen = mTempRect; |
| info.getBoundsInScreen(boundsInScreen); |
| if (interactiveRegion.quickReject(boundsInScreen) && !shouldBypassAdjustIsVisible()) { |
| info.setVisibleToUser(false); |
| } |
| } |
| |
| private boolean shouldBypassAdjustIsVisible() { |
| final int windowType = mViewRootImpl.mOrigWindowType; |
| if (windowType == TYPE_INPUT_METHOD) { |
| return true; |
| } |
| return false; |
| } |
| |
| private void applyAppScaleAndMagnificationSpecIfNeeded(AccessibilityNodeInfo info, |
| MagnificationSpec spec) { |
| if (info == null) { |
| return; |
| } |
| |
| final float applicationScale = mViewRootImpl.mAttachInfo.mApplicationScale; |
| if (!shouldApplyAppScaleAndMagnificationSpec(applicationScale, spec)) { |
| return; |
| } |
| |
| Rect boundsInParent = mTempRect; |
| Rect boundsInScreen = mTempRect1; |
| |
| info.getBoundsInParent(boundsInParent); |
| info.getBoundsInScreen(boundsInScreen); |
| if (applicationScale != 1.0f) { |
| boundsInParent.scale(applicationScale); |
| boundsInScreen.scale(applicationScale); |
| } |
| if (spec != null) { |
| boundsInParent.scale(spec.scale); |
| // boundsInParent must not be offset. |
| boundsInScreen.scale(spec.scale); |
| boundsInScreen.offset((int) spec.offsetX, (int) spec.offsetY); |
| } |
| info.setBoundsInParent(boundsInParent); |
| info.setBoundsInScreen(boundsInScreen); |
| |
| // Scale text locations if they are present |
| if (info.hasExtras()) { |
| Bundle extras = info.getExtras(); |
| Parcelable[] textLocations = |
| extras.getParcelableArray(EXTRA_DATA_TEXT_CHARACTER_LOCATION_KEY); |
| if (textLocations != null) { |
| for (int i = 0; i < textLocations.length; i++) { |
| // Unchecked cast - an app that puts other objects in this bundle with this |
| // key will crash. |
| RectF textLocation = ((RectF) textLocations[i]); |
| textLocation.scale(applicationScale); |
| if (spec != null) { |
| textLocation.scale(spec.scale); |
| textLocation.offset(spec.offsetX, spec.offsetY); |
| } |
| } |
| } |
| } |
| |
| if (spec != null) { |
| AttachInfo attachInfo = mViewRootImpl.mAttachInfo; |
| if (attachInfo.mDisplay == null) { |
| return; |
| } |
| |
| final float scale = attachInfo.mApplicationScale * spec.scale; |
| |
| Rect visibleWinFrame = mTempRect1; |
| visibleWinFrame.left = (int) (attachInfo.mWindowLeft * scale + spec.offsetX); |
| visibleWinFrame.top = (int) (attachInfo.mWindowTop * scale + spec.offsetY); |
| visibleWinFrame.right = (int) (visibleWinFrame.left + mViewRootImpl.mWidth * scale); |
| visibleWinFrame.bottom = (int) (visibleWinFrame.top + mViewRootImpl.mHeight * scale); |
| |
| attachInfo.mDisplay.getRealSize(mTempPoint); |
| final int displayWidth = mTempPoint.x; |
| final int displayHeight = mTempPoint.y; |
| |
| Rect visibleDisplayFrame = mTempRect2; |
| visibleDisplayFrame.set(0, 0, displayWidth, displayHeight); |
| |
| if (!visibleWinFrame.intersect(visibleDisplayFrame)) { |
| // If there's no intersection with display, set visibleWinFrame empty. |
| visibleDisplayFrame.setEmpty(); |
| } |
| |
| if (!visibleWinFrame.intersects(boundsInScreen.left, boundsInScreen.top, |
| boundsInScreen.right, boundsInScreen.bottom)) { |
| info.setVisibleToUser(false); |
| } |
| } |
| } |
| |
| private boolean shouldApplyAppScaleAndMagnificationSpec(float appScale, |
| MagnificationSpec spec) { |
| return (appScale != 1.0f || (spec != null && !spec.isNop())); |
| } |
| |
| private void updateInfosForViewportAndReturnFindNodeResult(List<AccessibilityNodeInfo> infos, |
| IAccessibilityInteractionConnectionCallback callback, int interactionId, |
| MagnificationSpec spec, Region interactiveRegion) { |
| try { |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = 0; |
| applyAppScaleAndMagnificationSpecIfNeeded(infos, spec); |
| adjustIsVisibleToUserIfNeeded(infos, interactiveRegion); |
| callback.setFindAccessibilityNodeInfosResult(infos, interactionId); |
| if (infos != null) { |
| infos.clear(); |
| } |
| } catch (RemoteException re) { |
| /* ignore - the other side will time out */ |
| } finally { |
| recycleMagnificationSpecAndRegionIfNeeded(spec, interactiveRegion); |
| } |
| } |
| |
| private void updateInfoForViewportAndReturnFindNodeResult(AccessibilityNodeInfo info, |
| IAccessibilityInteractionConnectionCallback callback, int interactionId, |
| MagnificationSpec spec, Region interactiveRegion) { |
| try { |
| mViewRootImpl.mAttachInfo.mAccessibilityFetchFlags = 0; |
| applyAppScaleAndMagnificationSpecIfNeeded(info, spec); |
| adjustIsVisibleToUserIfNeeded(info, interactiveRegion); |
| callback.setFindAccessibilityNodeInfoResult(info, interactionId); |
| } catch (RemoteException re) { |
| /* ignore - the other side will time out */ |
| } finally { |
| recycleMagnificationSpecAndRegionIfNeeded(spec, interactiveRegion); |
| } |
| } |
| |
| private void recycleMagnificationSpecAndRegionIfNeeded(MagnificationSpec spec, Region region) { |
| if (android.os.Process.myPid() != Binder.getCallingPid()) { |
| // Specs are cached in the system process and obtained from a pool when read from |
| // a parcel, so only recycle the spec if called from another process. |
| if (spec != null) { |
| spec.recycle(); |
| } |
| } else { |
| // Regions are obtained in the system process and instantiated when read from |
| // a parcel, so only recycle the region if caled from the same process. |
| if (region != null) { |
| region.recycle(); |
| } |
| } |
| } |
| |
| private boolean handleClickableSpanActionUiThread( |
| View view, int virtualDescendantId, Bundle arguments) { |
| Parcelable span = arguments.getParcelable(ACTION_ARGUMENT_ACCESSIBLE_CLICKABLE_SPAN); |
| if (!(span instanceof AccessibilityClickableSpan)) { |
| return false; |
| } |
| |
| // Find the original ClickableSpan if it's still on the screen |
| AccessibilityNodeInfo infoWithSpan = null; |
| AccessibilityNodeProvider provider = view.getAccessibilityNodeProvider(); |
| if (provider != null) { |
| infoWithSpan = provider.createAccessibilityNodeInfo(virtualDescendantId); |
| } else if (virtualDescendantId == AccessibilityNodeProvider.HOST_VIEW_ID) { |
| infoWithSpan = view.createAccessibilityNodeInfo(); |
| } |
| if (infoWithSpan == null) { |
| return false; |
| } |
| |
| // Click on the corresponding span |
| ClickableSpan clickableSpan = ((AccessibilityClickableSpan) span).findClickableSpan( |
| infoWithSpan.getOriginalText()); |
| if (clickableSpan != null) { |
| clickableSpan.onClick(view); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * This class encapsulates a prefetching strategy for the accessibility APIs for |
| * querying window content. It is responsible to prefetch a batch of |
| * AccessibilityNodeInfos in addition to the one for a requested node. |
| */ |
| private class AccessibilityNodePrefetcher { |
| |
| private static final int MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE = 50; |
| |
| private final ArrayList<View> mTempViewList = new ArrayList<View>(); |
| |
| public void prefetchAccessibilityNodeInfos(View view, int virtualViewId, int fetchFlags, |
| List<AccessibilityNodeInfo> outInfos, Bundle arguments) { |
| AccessibilityNodeProvider provider = view.getAccessibilityNodeProvider(); |
| // Determine if we'll be populating extra data |
| final String extraDataRequested = (arguments == null) ? null |
| : arguments.getString(EXTRA_DATA_REQUESTED_KEY); |
| if (provider == null) { |
| AccessibilityNodeInfo root = view.createAccessibilityNodeInfo(); |
| if (root != null) { |
| if (extraDataRequested != null) { |
| view.addExtraDataToAccessibilityNodeInfo( |
| root, extraDataRequested, arguments); |
| } |
| outInfos.add(root); |
| if ((fetchFlags & AccessibilityNodeInfo.FLAG_PREFETCH_PREDECESSORS) != 0) { |
| prefetchPredecessorsOfRealNode(view, outInfos); |
| } |
| if ((fetchFlags & AccessibilityNodeInfo.FLAG_PREFETCH_SIBLINGS) != 0) { |
| prefetchSiblingsOfRealNode(view, outInfos); |
| } |
| if ((fetchFlags & AccessibilityNodeInfo.FLAG_PREFETCH_DESCENDANTS) != 0) { |
| prefetchDescendantsOfRealNode(view, outInfos); |
| } |
| } |
| } else { |
| final AccessibilityNodeInfo root = |
| provider.createAccessibilityNodeInfo(virtualViewId); |
| if (root != null) { |
| if (extraDataRequested != null) { |
| provider.addExtraDataToAccessibilityNodeInfo( |
| virtualViewId, root, extraDataRequested, arguments); |
| } |
| outInfos.add(root); |
| if ((fetchFlags & AccessibilityNodeInfo.FLAG_PREFETCH_PREDECESSORS) != 0) { |
| prefetchPredecessorsOfVirtualNode(root, view, provider, outInfos); |
| } |
| if ((fetchFlags & AccessibilityNodeInfo.FLAG_PREFETCH_SIBLINGS) != 0) { |
| prefetchSiblingsOfVirtualNode(root, view, provider, outInfos); |
| } |
| if ((fetchFlags & AccessibilityNodeInfo.FLAG_PREFETCH_DESCENDANTS) != 0) { |
| prefetchDescendantsOfVirtualNode(root, provider, outInfos); |
| } |
| } |
| } |
| if (ENFORCE_NODE_TREE_CONSISTENT) { |
| enforceNodeTreeConsistent(outInfos); |
| } |
| } |
| |
| private void enforceNodeTreeConsistent(List<AccessibilityNodeInfo> nodes) { |
| LongSparseArray<AccessibilityNodeInfo> nodeMap = |
| new LongSparseArray<AccessibilityNodeInfo>(); |
| final int nodeCount = nodes.size(); |
| for (int i = 0; i < nodeCount; i++) { |
| AccessibilityNodeInfo node = nodes.get(i); |
| nodeMap.put(node.getSourceNodeId(), node); |
| } |
| |
| // If the nodes are a tree it does not matter from |
| // which node we start to search for the root. |
| AccessibilityNodeInfo root = nodeMap.valueAt(0); |
| AccessibilityNodeInfo parent = root; |
| while (parent != null) { |
| root = parent; |
| parent = nodeMap.get(parent.getParentNodeId()); |
| } |
| |
| // Traverse the tree and do some checks. |
| AccessibilityNodeInfo accessFocus = null; |
| AccessibilityNodeInfo inputFocus = null; |
| HashSet<AccessibilityNodeInfo> seen = new HashSet<AccessibilityNodeInfo>(); |
| Queue<AccessibilityNodeInfo> fringe = new LinkedList<AccessibilityNodeInfo>(); |
| fringe.add(root); |
| |
| while (!fringe.isEmpty()) { |
| AccessibilityNodeInfo current = fringe.poll(); |
| |
| // Check for duplicates |
| if (!seen.add(current)) { |
| throw new IllegalStateException("Duplicate node: " |
| + current + " in window:" |
| + mViewRootImpl.mAttachInfo.mAccessibilityWindowId); |
| } |
| |
| // Check for one accessibility focus. |
| if (current.isAccessibilityFocused()) { |
| if (accessFocus != null) { |
| throw new IllegalStateException("Duplicate accessibility focus:" |
| + current |
| + " in window:" + mViewRootImpl.mAttachInfo.mAccessibilityWindowId); |
| } else { |
| accessFocus = current; |
| } |
| } |
| |
| // Check for one input focus. |
| if (current.isFocused()) { |
| if (inputFocus != null) { |
| throw new IllegalStateException("Duplicate input focus: " |
| + current + " in window:" |
| + mViewRootImpl.mAttachInfo.mAccessibilityWindowId); |
| } else { |
| inputFocus = current; |
| } |
| } |
| |
| final int childCount = current.getChildCount(); |
| for (int j = 0; j < childCount; j++) { |
| final long childId = current.getChildId(j); |
| final AccessibilityNodeInfo child = nodeMap.get(childId); |
| if (child != null) { |
| fringe.add(child); |
| } |
| } |
| } |
| |
| // Check for disconnected nodes. |
| for (int j = nodeMap.size() - 1; j >= 0; j--) { |
| AccessibilityNodeInfo info = nodeMap.valueAt(j); |
| if (!seen.contains(info)) { |
| throw new IllegalStateException("Disconnected node: " + info); |
| } |
| } |
| } |
| |
| private void prefetchPredecessorsOfRealNode(View view, |
| List<AccessibilityNodeInfo> outInfos) { |
| ViewParent parent = view.getParentForAccessibility(); |
| while (parent instanceof View |
| && outInfos.size() < MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| View parentView = (View) parent; |
| AccessibilityNodeInfo info = parentView.createAccessibilityNodeInfo(); |
| if (info != null) { |
| outInfos.add(info); |
| } |
| parent = parent.getParentForAccessibility(); |
| } |
| } |
| |
| private void prefetchSiblingsOfRealNode(View current, |
| List<AccessibilityNodeInfo> outInfos) { |
| ViewParent parent = current.getParentForAccessibility(); |
| if (parent instanceof ViewGroup) { |
| ViewGroup parentGroup = (ViewGroup) parent; |
| ArrayList<View> children = mTempViewList; |
| children.clear(); |
| try { |
| parentGroup.addChildrenForAccessibility(children); |
| final int childCount = children.size(); |
| for (int i = 0; i < childCount; i++) { |
| if (outInfos.size() >= MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| return; |
| } |
| View child = children.get(i); |
| if (child.getAccessibilityViewId() != current.getAccessibilityViewId() |
| && isShown(child)) { |
| AccessibilityNodeInfo info = null; |
| AccessibilityNodeProvider provider = |
| child.getAccessibilityNodeProvider(); |
| if (provider == null) { |
| info = child.createAccessibilityNodeInfo(); |
| } else { |
| info = provider.createAccessibilityNodeInfo( |
| AccessibilityNodeProvider.HOST_VIEW_ID); |
| } |
| if (info != null) { |
| outInfos.add(info); |
| } |
| } |
| } |
| } finally { |
| children.clear(); |
| } |
| } |
| } |
| |
| private void prefetchDescendantsOfRealNode(View root, |
| List<AccessibilityNodeInfo> outInfos) { |
| if (!(root instanceof ViewGroup)) { |
| return; |
| } |
| HashMap<View, AccessibilityNodeInfo> addedChildren = |
| new HashMap<View, AccessibilityNodeInfo>(); |
| ArrayList<View> children = mTempViewList; |
| children.clear(); |
| try { |
| root.addChildrenForAccessibility(children); |
| final int childCount = children.size(); |
| for (int i = 0; i < childCount; i++) { |
| if (outInfos.size() >= MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| return; |
| } |
| View child = children.get(i); |
| if (isShown(child)) { |
| AccessibilityNodeProvider provider = child.getAccessibilityNodeProvider(); |
| if (provider == null) { |
| AccessibilityNodeInfo info = child.createAccessibilityNodeInfo(); |
| if (info != null) { |
| outInfos.add(info); |
| addedChildren.put(child, null); |
| } |
| } else { |
| AccessibilityNodeInfo info = provider.createAccessibilityNodeInfo( |
| AccessibilityNodeProvider.HOST_VIEW_ID); |
| if (info != null) { |
| outInfos.add(info); |
| addedChildren.put(child, info); |
| } |
| } |
| } |
| } |
| } finally { |
| children.clear(); |
| } |
| if (outInfos.size() < MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| for (Map.Entry<View, AccessibilityNodeInfo> entry : addedChildren.entrySet()) { |
| View addedChild = entry.getKey(); |
| AccessibilityNodeInfo virtualRoot = entry.getValue(); |
| if (virtualRoot == null) { |
| prefetchDescendantsOfRealNode(addedChild, outInfos); |
| } else { |
| AccessibilityNodeProvider provider = |
| addedChild.getAccessibilityNodeProvider(); |
| prefetchDescendantsOfVirtualNode(virtualRoot, provider, outInfos); |
| } |
| } |
| } |
| } |
| |
| private void prefetchPredecessorsOfVirtualNode(AccessibilityNodeInfo root, |
| View providerHost, AccessibilityNodeProvider provider, |
| List<AccessibilityNodeInfo> outInfos) { |
| final int initialResultSize = outInfos.size(); |
| long parentNodeId = root.getParentNodeId(); |
| int accessibilityViewId = AccessibilityNodeInfo.getAccessibilityViewId(parentNodeId); |
| while (accessibilityViewId != AccessibilityNodeInfo.UNDEFINED_ITEM_ID) { |
| if (outInfos.size() >= MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| return; |
| } |
| final int virtualDescendantId = |
| AccessibilityNodeInfo.getVirtualDescendantId(parentNodeId); |
| if (virtualDescendantId != AccessibilityNodeProvider.HOST_VIEW_ID |
| || accessibilityViewId == providerHost.getAccessibilityViewId()) { |
| final AccessibilityNodeInfo parent; |
| parent = provider.createAccessibilityNodeInfo(virtualDescendantId); |
| if (parent == null) { |
| // Going up the parent relation we found a null predecessor, |
| // so remove these disconnected nodes form the result. |
| final int currentResultSize = outInfos.size(); |
| for (int i = currentResultSize - 1; i >= initialResultSize; i--) { |
| outInfos.remove(i); |
| } |
| // Couldn't obtain the parent, which means we have a |
| // disconnected sub-tree. Abort prefetch immediately. |
| return; |
| } |
| outInfos.add(parent); |
| parentNodeId = parent.getParentNodeId(); |
| accessibilityViewId = AccessibilityNodeInfo.getAccessibilityViewId( |
| parentNodeId); |
| } else { |
| prefetchPredecessorsOfRealNode(providerHost, outInfos); |
| return; |
| } |
| } |
| } |
| |
| private void prefetchSiblingsOfVirtualNode(AccessibilityNodeInfo current, View providerHost, |
| AccessibilityNodeProvider provider, List<AccessibilityNodeInfo> outInfos) { |
| final long parentNodeId = current.getParentNodeId(); |
| final int parentAccessibilityViewId = |
| AccessibilityNodeInfo.getAccessibilityViewId(parentNodeId); |
| final int parentVirtualDescendantId = |
| AccessibilityNodeInfo.getVirtualDescendantId(parentNodeId); |
| if (parentVirtualDescendantId != AccessibilityNodeProvider.HOST_VIEW_ID |
| || parentAccessibilityViewId == providerHost.getAccessibilityViewId()) { |
| final AccessibilityNodeInfo parent = |
| provider.createAccessibilityNodeInfo(parentVirtualDescendantId); |
| if (parent != null) { |
| final int childCount = parent.getChildCount(); |
| for (int i = 0; i < childCount; i++) { |
| if (outInfos.size() >= MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| return; |
| } |
| final long childNodeId = parent.getChildId(i); |
| if (childNodeId != current.getSourceNodeId()) { |
| final int childVirtualDescendantId = |
| AccessibilityNodeInfo.getVirtualDescendantId(childNodeId); |
| AccessibilityNodeInfo child = provider.createAccessibilityNodeInfo( |
| childVirtualDescendantId); |
| if (child != null) { |
| outInfos.add(child); |
| } |
| } |
| } |
| } |
| } else { |
| prefetchSiblingsOfRealNode(providerHost, outInfos); |
| } |
| } |
| |
| private void prefetchDescendantsOfVirtualNode(AccessibilityNodeInfo root, |
| AccessibilityNodeProvider provider, List<AccessibilityNodeInfo> outInfos) { |
| final int initialOutInfosSize = outInfos.size(); |
| final int childCount = root.getChildCount(); |
| for (int i = 0; i < childCount; i++) { |
| if (outInfos.size() >= MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| return; |
| } |
| final long childNodeId = root.getChildId(i); |
| AccessibilityNodeInfo child = provider.createAccessibilityNodeInfo( |
| AccessibilityNodeInfo.getVirtualDescendantId(childNodeId)); |
| if (child != null) { |
| outInfos.add(child); |
| } |
| } |
| if (outInfos.size() < MAX_ACCESSIBILITY_NODE_INFO_BATCH_SIZE) { |
| final int addedChildCount = outInfos.size() - initialOutInfosSize; |
| for (int i = 0; i < addedChildCount; i++) { |
| AccessibilityNodeInfo child = outInfos.get(initialOutInfosSize + i); |
| prefetchDescendantsOfVirtualNode(child, provider, outInfos); |
| } |
| } |
| } |
| } |
| |
| private class PrivateHandler extends Handler { |
| private static final int MSG_PERFORM_ACCESSIBILITY_ACTION = 1; |
| private static final int MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID = 2; |
| private static final int MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID = 3; |
| private static final int MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT = 4; |
| private static final int MSG_FIND_FOCUS = 5; |
| private static final int MSG_FOCUS_SEARCH = 6; |
| private static final int MSG_PREPARE_FOR_EXTRA_DATA_REQUEST = 7; |
| private static final int MSG_APP_PREPARATION_FINISHED = 8; |
| private static final int MSG_APP_PREPARATION_TIMEOUT = 9; |
| |
| // Uses FIRST_NO_ACCESSIBILITY_CALLBACK_MSG for messages that don't need to call back |
| // results to interrogating client. |
| private static final int FIRST_NO_ACCESSIBILITY_CALLBACK_MSG = 100; |
| private static final int MSG_CLEAR_ACCESSIBILITY_FOCUS = |
| FIRST_NO_ACCESSIBILITY_CALLBACK_MSG + 1; |
| private static final int MSG_NOTIFY_OUTSIDE_TOUCH = |
| FIRST_NO_ACCESSIBILITY_CALLBACK_MSG + 2; |
| |
| public PrivateHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public String getMessageName(Message message) { |
| final int type = message.what; |
| switch (type) { |
| case MSG_PERFORM_ACCESSIBILITY_ACTION: |
| return "MSG_PERFORM_ACCESSIBILITY_ACTION"; |
| case MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID: |
| return "MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID"; |
| case MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID: |
| return "MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID"; |
| case MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT: |
| return "MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT"; |
| case MSG_FIND_FOCUS: |
| return "MSG_FIND_FOCUS"; |
| case MSG_FOCUS_SEARCH: |
| return "MSG_FOCUS_SEARCH"; |
| case MSG_PREPARE_FOR_EXTRA_DATA_REQUEST: |
| return "MSG_PREPARE_FOR_EXTRA_DATA_REQUEST"; |
| case MSG_APP_PREPARATION_FINISHED: |
| return "MSG_APP_PREPARATION_FINISHED"; |
| case MSG_APP_PREPARATION_TIMEOUT: |
| return "MSG_APP_PREPARATION_TIMEOUT"; |
| case MSG_CLEAR_ACCESSIBILITY_FOCUS: |
| return "MSG_CLEAR_ACCESSIBILITY_FOCUS"; |
| case MSG_NOTIFY_OUTSIDE_TOUCH: |
| return "MSG_NOTIFY_OUTSIDE_TOUCH"; |
| default: |
| throw new IllegalArgumentException("Unknown message type: " + type); |
| } |
| } |
| |
| @Override |
| public void handleMessage(Message message) { |
| final int type = message.what; |
| switch (type) { |
| case MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID: { |
| findAccessibilityNodeInfoByAccessibilityIdUiThread(message); |
| } break; |
| case MSG_PERFORM_ACCESSIBILITY_ACTION: { |
| performAccessibilityActionUiThread(message); |
| } break; |
| case MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID: { |
| findAccessibilityNodeInfosByViewIdUiThread(message); |
| } break; |
| case MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT: { |
| findAccessibilityNodeInfosByTextUiThread(message); |
| } break; |
| case MSG_FIND_FOCUS: { |
| findFocusUiThread(message); |
| } break; |
| case MSG_FOCUS_SEARCH: { |
| focusSearchUiThread(message); |
| } break; |
| case MSG_PREPARE_FOR_EXTRA_DATA_REQUEST: { |
| prepareForExtraDataRequestUiThread(message); |
| } break; |
| case MSG_APP_PREPARATION_FINISHED: { |
| requestPreparerDoneUiThread(message); |
| } break; |
| case MSG_APP_PREPARATION_TIMEOUT: { |
| requestPreparerTimeoutUiThread(); |
| } break; |
| case MSG_CLEAR_ACCESSIBILITY_FOCUS: { |
| clearAccessibilityFocusUiThread(); |
| } break; |
| case MSG_NOTIFY_OUTSIDE_TOUCH: { |
| notifyOutsideTouchUiThread(); |
| } break; |
| default: |
| throw new IllegalArgumentException("Unknown message type: " + type); |
| } |
| } |
| |
| boolean hasAccessibilityCallback(Message message) { |
| return message.what < FIRST_NO_ACCESSIBILITY_CALLBACK_MSG ? true : false; |
| } |
| } |
| |
| private final class AddNodeInfosForViewId implements Predicate<View> { |
| private int mViewId = View.NO_ID; |
| private List<AccessibilityNodeInfo> mInfos; |
| |
| public void init(int viewId, List<AccessibilityNodeInfo> infos) { |
| mViewId = viewId; |
| mInfos = infos; |
| } |
| |
| public void reset() { |
| mViewId = View.NO_ID; |
| mInfos = null; |
| } |
| |
| @Override |
| public boolean test(View view) { |
| if (view.getId() == mViewId && isShown(view)) { |
| mInfos.add(view.createAccessibilityNodeInfo()); |
| } |
| return false; |
| } |
| } |
| |
| private static final class MessageHolder { |
| final Message mMessage; |
| final int mInterrogatingPid; |
| final long mInterrogatingTid; |
| |
| MessageHolder(Message message, int interrogatingPid, long interrogatingTid) { |
| mMessage = message; |
| mInterrogatingPid = interrogatingPid; |
| mInterrogatingTid = interrogatingTid; |
| } |
| } |
| } |
