[Switch Access] Improve interactions with Virtual Keyboard.

Previously, Switch Access would get stuck in the virtual keyboard when
it was hidden, and would not jump to it when it was activated by any
method other than the Switch Access menu.

This change listens to events corresponding to the keyboard being shown
and hidden, and reacts appropriately.

Bug: 996899
Change-Id: Ic6c58c8f66afdbf7422b74a8dc86b0d64c700607
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2062584
Commit-Queue: Anastasia Helfinstein <anastasi@google.com>
Reviewed-by: David Tseng <dtseng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#744039}

chrome/browser/resources/chromeos/accessibility/switch_access/menu_manager.js

@@ -571,11 +571,6 @@ class MenuManager {
       this.exit();
       return;
     }
-    if (action === SAConstants.MenuAction.OPEN_KEYBOARD) {
-      this.navigationManager_.enterKeyboard();
-      this.exit();
-      return;
-    }
 
     // Handle global actions.
     if (action === SAConstants.MenuAction.SETTINGS) {

chrome/browser/resources/chromeos/accessibility/switch_access/navigation_manager.js

@@ -41,6 +41,18 @@ class NavigationManager {
 
   // =============== Static Methods ==============
 
+  /**
+   * Puts focus on the virtual keyboard, if the current node is a text input.
+   * TODO(crbug/946190): Handle the case where the user has not enabled the
+   *     onscreen keyboard.
+   */
+  static enterKeyboard() {
+    const navigator = NavigationManager.instance;
+    const keyboard = KeyboardRootNode.buildTree();
+    navigator.jumpTo_(keyboard);
+    navigator.node_.automationNode.focus();
+  }
+
   /**
    * Open the Switch Access menu for the currently highlighted node. If there
    * are not enough actions available to trigger the menu, the current element
@@ -56,6 +68,28 @@ class NavigationManager {
     }
   }
 
+  static exitKeyboard() {
+    const navigator = NavigationManager.instance;
+    let foundKeyboard = navigator.group_ instanceof KeyboardRootNode;
+    for (const group of navigator.groupStack_) {
+      foundKeyboard |= group instanceof KeyboardRootNode;
+    }
+    // If we are not in the keyboard, do nothing.
+    if (!foundKeyboard) {
+      return;
+    }
+
+    while (navigator.groupStack_.length > 0) {
+      if (navigator.group_ instanceof KeyboardRootNode) {
+        break;
+      }
+      navigator.exitGroup_();
+    }
+    navigator.exitGroup_();
+
+    NavigationManager.moveToValidNode();
+  }
+
   /**
    * Forces the current node to be |node|.
    * Should only be called by subclasses of SARootNode and
@@ -180,6 +214,14 @@ class NavigationManager {
 
   // =============== Instance Methods ==============
 
+  /**
+   * Returns the desktop automation node object.
+   * @return {!chrome.automation.AutomationNode}
+   */
+  get desktopNode() {
+    return this.desktop_;
+  }
+
   /**
    * Enters |this.node_|.
    */
@@ -197,17 +239,6 @@ class NavigationManager {
     }
   }
 
-  /**
-   * Puts focus on the virtual keyboard, if the current node is a text input.
-   * TODO(cbug/946190): Handle the case where the user has not enabled the
-   *     onscreen keyboard.
-   */
-  enterKeyboard() {
-    const keyboard = KeyboardRootNode.buildTree(this.desktop_);
-    this.node_.performAction(SAConstants.MenuAction.OPEN_KEYBOARD);
-    this.jumpTo_(keyboard);
-  }
-
   /**
    * Selects the current node.
    */
@@ -227,7 +258,6 @@ class NavigationManager {
       SwitchAccessMetrics.recordMenuAction(
           SAConstants.MenuAction.OPEN_KEYBOARD);
       this.node_.performAction(SAConstants.MenuAction.OPEN_KEYBOARD);
-      this.enterKeyboard();
       return;
     }
 

chrome/browser/resources/chromeos/accessibility/switch_access/nodes/editable_text_node.js

@@ -39,7 +39,7 @@ class EditableTextNode extends NodeWrapper {
   performAction(action) {
     switch (action) {
       case SAConstants.MenuAction.OPEN_KEYBOARD:
-        this.automationNode.focus();
+        NavigationManager.enterKeyboard();
         return SAConstants.ActionResponse.CLOSE_MENU;
       case SAConstants.MenuAction.DICTATION:
         chrome.accessibilityPrivate.toggleDictation();

chrome/browser/resources/chromeos/accessibility/switch_access/nodes/keyboard_node.js

@@ -90,18 +90,32 @@ class KeyboardNode extends NodeWrapper {
  */
 class KeyboardRootNode extends RootNodeWrapper {
   /**
-   * @param {!chrome.automation.AutomationNode} keyboard
+   * @param {!chrome.automation.AutomationNode} groupNode
    * @private
    */
-  constructor(keyboard) {
-    super(keyboard);
+  constructor(groupNode) {
+    super(groupNode);
   }
 
   // ================= General methods =================
 
+
+  /** @override */
+  isValidGroup() {
+    // To ensure we can find the keyboard root node to appropriately respond to
+    // visibility changes, never mark it as invalid.
+    return true;
+  }
+
   /** @override */
   onExit() {
-    chrome.accessibilityPrivate.setVirtualKeyboardVisible(false);
+    // If the keyboard is currently visible, ignore the corresponding
+    // state change.
+    if (KeyboardRootNode.isVisible_) {
+      KeyboardRootNode.explicitStateChange_ = true;
+      chrome.accessibilityPrivate.setVirtualKeyboardVisible(false);
+    }
+
     AutoScanManager.setInKeyboard(false);
   }
 
@@ -109,20 +123,23 @@ class KeyboardRootNode extends RootNodeWrapper {
 
   /**
    * Creates the tree structure for the system menu.
-   * @param {!chrome.automation.AutomationNode} desktop
    * @return {!KeyboardRootNode}
    */
-  static buildTree(desktop) {
+  static buildTree() {
     KeyboardRootNode.loadKeyboard_();
     AutoScanManager.setInKeyboard(true);
 
-    const keyboardContainer =
-        desktop.find({role: chrome.automation.RoleType.KEYBOARD});
+    if (!KeyboardRootNode.keyboardObject_) {
+      throw SwitchAccess.error(
+          SAConstants.ErrorType.MISSING_KEYBOARD,
+          'Could not find keyboard in the automation tree');
+    }
     const keyboard =
-        new AutomationTreeWalker(keyboardContainer, constants.Dir.FORWARD, {
-          visit: (node) => SwitchAccessPredicate.isGroup(node, null),
-          root: (node) => node === keyboardContainer
-        })
+        new AutomationTreeWalker(
+            KeyboardRootNode.keyboardObject_, constants.Dir.FORWARD, {
+              visit: (node) => SwitchAccessPredicate.isGroup(node, null),
+              root: (node) => node === KeyboardRootNode.keyboardObject_
+            })
             .next()
             .node;
 
@@ -131,11 +148,69 @@ class KeyboardRootNode extends RootNodeWrapper {
     return root;
   }
 
+  /**
+   * Start listening for keyboard open/closed.
+   */
+  static startWatchingVisibility() {
+    KeyboardRootNode.isVisible_ =
+        SwitchAccessPredicate.isVisible(KeyboardRootNode.keyboardObject_);
+
+    KeyboardRootNode.keyboardObject_.addEventListener(
+        chrome.automation.EventType.ARIA_ATTRIBUTE_CHANGED,
+        KeyboardRootNode.checkVisibilityChanged_, false /* capture */);
+  }
+
+  // ================= Private static methods =================
+
+  /**
+   * @param {chrome.automation.AutomationEvent} event
+   * @private
+   */
+  static checkVisibilityChanged_(event) {
+    const currentlyVisible =
+        SwitchAccessPredicate.isVisible(KeyboardRootNode.keyboardObject_);
+    if (currentlyVisible === KeyboardRootNode.isVisible_) {
+      return;
+    }
+
+    KeyboardRootNode.isVisible_ = currentlyVisible;
+
+    if (KeyboardRootNode.explicitStateChange_) {
+      // When the user has explicitly shown / hidden the keyboard, do not
+      // enter / exit the keyboard again to avoid looping / double-calls.
+      KeyboardRootNode.explicitStateChange_ = false;
+      return;
+    }
+
+    if (KeyboardRootNode.isVisible_) {
+      NavigationManager.enterKeyboard();
+    } else {
+      NavigationManager.exitKeyboard();
+    }
+  }
+
+  /**
+   * @return {chrome.automation.AutomationNode}
+   * @private
+   */
+  static get keyboardObject_() {
+    if (!this.object_ || !this.object_.role) {
+      this.object_ = NavigationManager.instance.desktopNode.find(
+          {role: chrome.automation.RoleType.KEYBOARD});
+    }
+    return this.object_;
+  }
+
   /**
    * Loads the keyboard.
    * @private
    */
   static loadKeyboard_() {
+    if (KeyboardRootNode.isVisible_) {
+      return;
+    }
+
+    KeyboardRootNode.explicitStateChange_ = true;
     chrome.accessibilityPrivate.setVirtualKeyboardVisible(true);
   }
 }

chrome/browser/resources/chromeos/accessibility/switch_access/nodes/node_wrapper.js

@@ -138,6 +138,7 @@ class NodeWrapper extends SAChildNode {
     switch (action) {
       case SAConstants.MenuAction.SELECT:
         this.baseNode_.doDefault();
+        return SAConstants.ActionResponse.CLOSE_MENU;
       case SAConstants.MenuAction.SCROLL_DOWN:
         ancestor = this.getScrollableAncestor_();
         if (ancestor.scrollable) {

chrome/browser/resources/chromeos/accessibility/switch_access/switch_access.js

@@ -17,6 +17,7 @@ class SwitchAccess {
 
       BackButtonNode.findAutomationNode(desktop);
       Commands.initialize();
+      KeyboardRootNode.startWatchingVisibility();
       SwitchAccessPreferences.initialize();
     });
   }

chrome/browser/resources/chromeos/accessibility/switch_access/switch_access_constants.js

@@ -69,6 +69,7 @@ const SAConstants = {
     NO_CHILDREN: 7,
     MALFORMED_DESKTOP: 8,
     MISSING_LOCATION: 9,
+    MISSING_KEYBOARD: 10,
   },
 
   /**