Android accessibility: automatically focus links

content/public/android/java/src/org/chromium/content/browser/accessibility/BrowserAccessibilityManager.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser.accessibility;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Rect;
 import android.os.Build;
@@ skipping 19 matching lines @@
 import java.util.List;
 import java.util.Locale;
 
 /**
  * Native accessibility for a {@link ContentViewCore}.
  */
 @JNINamespace("content")
 public class BrowserAccessibilityManager {
     private static final String TAG = "BrowserAccessibilityManager";
 
+    private static final int WINDOW_CONTENT_CHANGED_DELAY_MS = 500;
+    private static final int ACCESSIBILITY_FOCUS_LOCATION_CHANGED_DELAY_MS = 100;
+
     // Constants from AccessibilityNodeInfo defined in the K SDK.
     private static final int ACTION_COLLAPSE = 0x00080000;
     private static final int ACTION_EXPAND = 0x00040000;
 
     // Constants from AccessibilityNodeInfo defined in the L SDK.
     private static final int ACTION_SET_TEXT = 0x200000;
     private static final String ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE =
             "ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE";
-    private static final int WINDOW_CONTENT_CHANGED_DELAY_MS = 500;
 
     // Constants from AccessibilityNodeInfo defined in the M SDK.
     // Source: https://developer.android.com/reference/android/R.id.html
     protected static final int ACTION_CONTEXT_CLICK = 0x0102003c;
     protected static final int ACTION_SHOW_ON_SCREEN = 0x01020036;
     protected static final int ACTION_SCROLL_UP = 0x01020038;
     protected static final int ACTION_SCROLL_DOWN = 0x0102003a;
     protected static final int ACTION_SCROLL_LEFT = 0x01020039;
     protected static final int ACTION_SCROLL_RIGHT = 0x0102003b;
 
     private final AccessibilityNodeProvider mAccessibilityNodeProvider;
     private ContentViewCore mContentViewCore;
     private final AccessibilityManager mAccessibilityManager;
     private final RenderCoordinates mRenderCoordinates;
     private long mNativeObj;
     private Rect mAccessibilityFocusRect;
     private boolean mIsHovering;
     private int mLastHoverId = View.NO_ID;
     protected int mCurrentRootId;
     private final int[] mTempLocation = new int[2];
     private final ViewGroup mView;
     private boolean mUserHasTouchExplored;
     private boolean mPendingScrollToMakeNodeVisible;
     private boolean mNotifyFrameInfoInitializedCalled;
     private int mSelectionGranularity;
     private int mSelectionStartIndex;
     private int mSelectionEndIndex;
     protected int mAccessibilityFocusId;
     private Runnable mSendWindowContentChangedRunnable;
+    private Runnable mAccessibilityFocusLocationChangedRunnable;
 
     /**
      * Create a BrowserAccessibilityManager object, which is owned by the C++
      * BrowserAccessibilityManagerAndroid instance, and connects to the content view.
      * @param nativeBrowserAccessibilityManagerAndroid A pointer to the counterpart native
      *     C++ object that owns this object.
      * @param contentViewCore The content view that this object provides accessibility for.
      */
     @CalledByNative
     private static BrowserAccessibilityManager create(long nativeBrowserAccessibilityManagerAndroid,
@@ skipping 142 matching lines @@
                 }
                 return true;
             case AccessibilityNodeInfo.ACTION_CLEAR_ACCESSIBILITY_FOCUS:
                 // ALWAYS respond with TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED whether we thought
                 // it had focus or not, so that the Android framework cache is correct.
                 sendAccessibilityEvent(virtualViewId,
                         AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED);
                 if (mAccessibilityFocusId == virtualViewId) {
                     mAccessibilityFocusId = View.NO_ID;
                     mAccessibilityFocusRect = null;
+                    // If we had a pending callback to update the location of the previous object
+                    // with accessibility focus, remove it.
+                    if (mAccessibilityFocusLocationChangedRunnable != null) {
+                        mView.removeCallbacks(mAccessibilityFocusLocationChangedRunnable);
+                        mAccessibilityFocusLocationChangedRunnable = null;
+                    }
                 }
                 return true;
             case AccessibilityNodeInfo.ACTION_CLICK:
                 nativeClick(mNativeObj, virtualViewId);
                 return true;
             case AccessibilityNodeInfo.ACTION_FOCUS:
                 nativeFocus(mNativeObj, virtualViewId);
                 return true;
             case AccessibilityNodeInfo.ACTION_CLEAR_FOCUS:
                 nativeBlur(mNativeObj);
@@ skipping 280 matching lines @@
 
     private boolean moveAccessibilityFocusToId(int newAccessibilityFocusId) {
         if (newAccessibilityFocusId == mAccessibilityFocusId) return false;
 
         mAccessibilityFocusId = newAccessibilityFocusId;
         mAccessibilityFocusRect = null;
         mSelectionGranularity = 0;
         mSelectionStartIndex = 0;
         mSelectionEndIndex = 0;
 
+        // If we had a pending callback to update the location of the previous object with
+        // accessibility focus, remove it.
+        if (mAccessibilityFocusLocationChangedRunnable != null) {
+            mView.removeCallbacks(mAccessibilityFocusLocationChangedRunnable);
+            mAccessibilityFocusLocationChangedRunnable = null;
+        }
+
+        // Call nativeSetAccessibilityFocus. For the most part Chrome doesn't have a
+        // concept of accessibility focus, but we do two things: (1) auto-focus certain
+        // roles like links when they get accessibility focus and (2) load inline text boxes
+        // for nodes when they get accessibility focus since inline text boxes are expensive
+        // to load and on Android they're only needed for nodes that have input focus or
+        // accessibility focus.
+        //
         // Calling nativeSetAccessibilityFocus will asynchronously load inline text boxes for
         // this node and its subtree. If accessibility focus is on anything other than
         // the root, do it - otherwise set it to -1 so we don't load inline text boxes
         // for the whole subtree of the root.
         if (mAccessibilityFocusId == mCurrentRootId) {
             nativeSetAccessibilityFocus(mNativeObj, -1);
         } else {
             nativeSetAccessibilityFocus(mNativeObj, mAccessibilityFocusId);
         }
 
         sendAccessibilityEvent(mAccessibilityFocusId,
                 AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED);
         return true;
     }
 
     private void moveAccessibilityFocusToIdAndRefocusIfNeeded(int newAccessibilityFocusId) {
         // Work around a bug in the Android framework where it doesn't fully update the object
         // with accessibility focus even if you send it a WINDOW_CONTENT_CHANGED. To work around
         // this, clear focus and then set focus again.
         if (newAccessibilityFocusId == mAccessibilityFocusId) {
             sendAccessibilityEvent(newAccessibilityFocusId,
                     AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED);
             mAccessibilityFocusId = View.NO_ID;
         }
 
         moveAccessibilityFocusToId(newAccessibilityFocusId);
     }
 
     /**
+     * Work around a bug in the Android framework where if the object with accessibility
+     *  focus moves, the accessibility focus rect is not updated - both the visual highlight,
+     * and the location on the screen that's clicked if you double-tap. To work around this,
+     * when we know the object with accessibility focus moved, move focus away and then
+     * move focus right back to it, which tricks Android into updating its bounds.
+     *
+     * Do this after a short delay because sometimes the change to the object with accessibility
+     * focus happens just before navigating somewhere else.
+     */
+    private void updateAccessibilityFocusLocationAfterDelay() {
+        if (mNativeObj == 0) return;
+
+        if (mAccessibilityFocusLocationChangedRunnable != null) return;
+
+        mAccessibilityFocusLocationChangedRunnable = new Runnable() {
+            @Override
+            public void run() {
+                updateAccessibilityFocusLocation();
+            }
+        };
+
+        mView.postDelayed(mAccessibilityFocusLocationChangedRunnable,
+                ACCESSIBILITY_FOCUS_LOCATION_CHANGED_DELAY_MS);
+    }
+
+    /**
+     * See updateAccessibilityFocusLocationAfterDelay for details.
+     */
+    private void updateAccessibilityFocusLocation() {
+        // This can be called from a timeout, so we need to make sure we're still valid.
+        if (mNativeObj == 0 || mContentViewCore == null || mView == null) return;
+
+        if (mAccessibilityFocusLocationChangedRunnable != null) {
+            mView.removeCallbacks(mAccessibilityFocusLocationChangedRunnable);
+            mAccessibilityFocusLocationChangedRunnable = null;
+        }
+
+        moveAccessibilityFocusToIdAndRefocusIfNeeded(mAccessibilityFocusId);
+    }
+
+    /**
      * Send a WINDOW_CONTENT_CHANGED event after a short delay. This helps throttle such
      * events from firing too quickly during animations, for example.
      */
     @CalledByNative
     private void sendDelayedWindowContentChangedEvent() {
         if (mNativeObj == 0) return;
 
         if (mSendWindowContentChangedRunnable != null) return;
 
         mSendWindowContentChangedRunnable = new Runnable() {
@@ skipping 415 matching lines @@
         rect.offset(viewLocation[0], viewLocation[1]);
 
         // Clip the node's bounding rect to the viewport bounds.
         int viewportRectTop = viewLocation[1] + (int) mRenderCoordinates.getContentOffsetYPix();
         int viewportRectBottom = viewportRectTop + mContentViewCore.getViewportHeightPix();
         if (rect.top < viewportRectTop) rect.top = viewportRectTop;
         if (rect.bottom > viewportRectBottom) rect.bottom = viewportRectBottom;
 
         node.setBoundsInScreen(rect);
 
-        // Work around a bug in the Android framework where if the object with accessibility
-        // focus moves, the accessibility focus rect is not updated - both the visual highlight,
-        // and the location on the screen that's clicked if you double-tap. To work around this,
-        // when we know the object with accessibility focus moved, move focus away and then
-        // move focus right back to it, which tricks Android into updating its bounds.
+        // If this is the node with accessibility focus, ensure that its location on-screen
+        // is up-to-date.
         if (virtualViewId == mAccessibilityFocusId && virtualViewId != mCurrentRootId) {
             if (mAccessibilityFocusRect == null) {
                 mAccessibilityFocusRect = rect;
             } else if (!mAccessibilityFocusRect.equals(rect)) {
                 mAccessibilityFocusRect = rect;
-                moveAccessibilityFocusToIdAndRefocusIfNeeded(virtualViewId);
+                updateAccessibilityFocusLocationAfterDelay();
             }
         }
     }
 
     @CalledByNative
     protected void setAccessibilityNodeInfoKitKatAttributes(AccessibilityNodeInfo node,
             boolean isRoot, boolean isEditableText, String roleDescription) {
         // Requires KitKat or higher.
     }
 
@@ skipping 184 matching lines @@
             long nativeBrowserAccessibilityManagerAndroid, int id);
     private native boolean nativeIsSlider(
             long nativeBrowserAccessibilityManagerAndroid, int id);
     private native boolean nativeScroll(
             long nativeBrowserAccessibilityManagerAndroid, int id, int direction);
     protected native String nativeGetSupportedHtmlElementTypes(
             long nativeBrowserAccessibilityManagerAndroid);
     private native void nativeShowContextMenu(
             long nativeBrowserAccessibilityManagerAndroid, int id);
 }