Handle UI operations through gamepad

chrome/android/java/src/org/chromium/chrome/browser/KeyboardShortcuts.java

 // Copyright 2015 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.chrome.browser;
 
 import android.view.KeyEvent;
 
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.chrome.R;
@@ skipping 16 matching lines @@
     private static final int SHIFT = 1 << 29;
 
     private KeyboardShortcuts() {}
 
     private static int getMetaState(KeyEvent event) {
         return (event.isCtrlPressed() ? CTRL : 0)
                 | (event.isAltPressed() ? ALT : 0)
                 | (event.isShiftPressed() ? SHIFT : 0);
     }
 
+    private static boolean isGamepadAPIActive(ChromeActivity activity) {
+        if (activity.getCurrentContentViewCore() != null) {

[newt (away), 2015/08/10 18:52:07]

nit: store the reference to the ContentViewCore (since
activity.getCurrentContentViewCore() is not a trivial getter):

   ContentViewCore viewCore = activity.getCurrentContentViewCore();
   return viewCore == null ? false : viewCore.isGamepadAPIActive();

[sshelke, 2015/08/11 13:49:07]

Done.

+            return activity.getCurrentContentViewCore().isGamepadAPIActive();
+        }
+        return false;
+    }
+
     /**
      * This should be called from the Activity's dispatchKeyEvent() to handle keyboard shortcuts.
      *
      * Note: dispatchKeyEvent() is called before the active view or web page gets a chance to handle
      * the key event. So the keys handled here cannot be overridden by any view or web page.
      *
      * @param event The KeyEvent to handle.
      * @param activity The ChromeActivity in which the key was pressed.
      * @param uiInitialized Whether the UI has been initialized. If this is false, most keys will
      *                      not be handled.
@@ skipping 51 matching lines @@
      * @param isCurrentTabVisible Whether page-related actions are valid, e.g. reload, zoom in.
      *                            This should be false when in the tab switcher.
      * @param tabSwitchingEnabled Whether shortcuts that switch between tabs are enabled (e.g.
      *                            Ctrl+Tab, Ctrl+3).
      * @return Whether the key event was handled.
      */
     public static boolean onKeyDown(KeyEvent event, ChromeActivity activity,
             boolean isCurrentTabVisible, boolean tabSwitchingEnabled) {
         int keyCode = event.getKeyCode();
         if (event.getRepeatCount() != 0 || KeyEvent.isModifierKey(keyCode)) return false;
-        if (!event.isCtrlPressed() && !event.isAltPressed()
+        if (KeyEvent.isGamepadButton(keyCode)) {
+            if (isGamepadAPIActive(activity)) return false;
+        } else if (!event.isCtrlPressed() && !event.isAltPressed()
                 && keyCode != KeyEvent.KEYCODE_F3
                 && keyCode != KeyEvent.KEYCODE_F5
                 && keyCode != KeyEvent.KEYCODE_FORWARD) {
             return false;
         }
 
         TabModel curModel = activity.getCurrentTabModel();
         int count = curModel.getCount();
 
         int metaState = getMetaState(event);
@@ skipping 20 matching lines @@
                 if (currentTab != null && isCurrentTabVisible) {
                     currentTab.loadUrl(new LoadUrlParams(url, PageTransition.AUTO_BOOKMARK));
                 } else {
                     TabCreator tabCreator = activity.getCurrentTabCreator();
                     if (tabCreator != null) {
                         tabCreator.launchUrl(url, TabLaunchType.FROM_KEYBOARD);
                     }
                 }
                 return true;
             case ALT | KeyEvent.KEYCODE_F:
+            case KeyEvent.KEYCODE_BUTTON_Y:
                 activity.onMenuOrKeyboardAction(R.id.show_menu, false);
                 return true;
         }
 
         if (isCurrentTabVisible) {
             if (tabSwitchingEnabled && (metaState == CTRL || metaState == ALT)) {
                 int numCode = keyCode - KeyEvent.KEYCODE_0;
                 if (numCode > 0 && numCode <= Math.min(count, 8)) {
                     // Ctrl+1 to Ctrl+8: select tab by index
                     TabModelUtils.setIndex(curModel, numCode - 1);
                     return true;
                 } else if (numCode == 9 && count != 0) {
                     // Ctrl+9: select last tab
                     TabModelUtils.setIndex(curModel, count - 1);
                     return true;
                 }
             }
 
             switch (keyCodeAndMeta) {
                 case CTRL | KeyEvent.KEYCODE_TAB:
                 case CTRL | KeyEvent.KEYCODE_PAGE_DOWN:
+                case KeyEvent.KEYCODE_BUTTON_R1:
                     if (tabSwitchingEnabled && count > 1) {
                         TabModelUtils.setIndex(curModel, (curModel.index() + 1) % count);
                     }
                     return true;
                 case CTRL | SHIFT | KeyEvent.KEYCODE_TAB:
                 case CTRL | KeyEvent.KEYCODE_PAGE_UP:
+                case KeyEvent.KEYCODE_BUTTON_L1:
                     if (tabSwitchingEnabled && count > 1) {
                         TabModelUtils.setIndex(curModel, (curModel.index() + count - 1) % count);
                     }
                     return true;
                 case CTRL | KeyEvent.KEYCODE_W:
                 case CTRL | KeyEvent.KEYCODE_F4:
+                case KeyEvent.KEYCODE_BUTTON_B:
                     TabModelUtils.closeCurrentTab(curModel);
                     return true;
                 case CTRL | KeyEvent.KEYCODE_F:
                 case CTRL | KeyEvent.KEYCODE_G:
                 case CTRL | SHIFT | KeyEvent.KEYCODE_G:
                 case KeyEvent.KEYCODE_F3:
                 case SHIFT | KeyEvent.KEYCODE_F3:
                     activity.onMenuOrKeyboardAction(R.id.find_in_page_id, false);
                     return true;
                 case CTRL | KeyEvent.KEYCODE_L:
                 case ALT | KeyEvent.KEYCODE_D:
+                case KeyEvent.KEYCODE_BUTTON_X:
                     activity.onMenuOrKeyboardAction(R.id.focus_url_bar, false);
                     return true;
                 case KeyEvent.KEYCODE_BOOKMARK:
                 case CTRL | KeyEvent.KEYCODE_D:
                     activity.onMenuOrKeyboardAction(R.id.bookmark_this_page_id, false);
                     return true;
                 case CTRL | KeyEvent.KEYCODE_P:
                     activity.onMenuOrKeyboardAction(R.id.print_id, false);
                     return true;
                 case CTRL | KeyEvent.KEYCODE_PLUS:
@@ skipping 17 matching lines @@
                 case KeyEvent.KEYCODE_F5:
                     Tab tab = activity.getActivityTab();
                     if (tab != null) tab.reload();
                     return true;
                 case ALT | KeyEvent.KEYCODE_DPAD_LEFT:
                     tab = activity.getActivityTab();
                     if (tab != null && tab.canGoBack()) tab.goBack();
                     return true;
                 case ALT | KeyEvent.KEYCODE_DPAD_RIGHT:
                 case KeyEvent.KEYCODE_FORWARD:
+                case KeyEvent.KEYCODE_BUTTON_START:
                     tab = activity.getActivityTab();
                     if (tab != null && tab.canGoForward()) tab.goForward();
                     return true;
                 case CTRL | SHIFT | KeyEvent.KEYCODE_SLASH:  // i.e. Ctrl+?
                     activity.onMenuOrKeyboardAction(R.id.help_id, false);
                     return true;
             }
         }
 
         return false;
     }
 }