Handle UI operations through gamepad

content/public/android/java/src/org/chromium/content/browser/input/GamepadList.java

 // Copyright 2014 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.input;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.hardware.input.InputManager;
 import android.hardware.input.InputManager.InputDeviceListener;
@@ skipping 15 matching lines @@
  */
 @JNINamespace("content")
 public class GamepadList {
     private static final int MAX_GAMEPADS = 4;
 
     private final Object mLock = new Object();
 
     private final GamepadDevice[] mGamepadDevices = new GamepadDevice[MAX_GAMEPADS];
     private InputManager mInputManager;
     private int mAttachedToWindowCounter;
-    private boolean mIsGamepadAccessed;
+    private boolean mIsGamepadAPIActive;
     private InputDeviceListener mInputDeviceListener;
 
     private GamepadList() {
         mInputDeviceListener = new InputDeviceListener() {
             // Override InputDeviceListener methods
             @Override
             public void onInputDeviceChanged(int deviceId) {
                 onInputDeviceChangedImpl(deviceId);
             }
 
@@ skipping 125 matching lines @@
      * Handles key events from the gamepad devices.
      * @return True if the event has been consumed.
      */
     public static boolean dispatchKeyEvent(KeyEvent event) {
         if (!isGamepadEvent(event)) return false;
         return getInstance().handleKeyEvent(event);
     }
 
     private boolean handleKeyEvent(KeyEvent event) {
         synchronized (mLock) {
-            if (!mIsGamepadAccessed) return false;
+            if (!mIsGamepadAPIActive) return false;
             GamepadDevice gamepad = getGamepadForEvent(event);
             if (gamepad == null) return false;
             return gamepad.handleKeyEvent(event);
         }
     }
 
     /**
      * Handles motion events from the gamepad devices.
      * @return True if the event has been consumed.
      */
     public static boolean onGenericMotionEvent(MotionEvent event) {
         if (!isGamepadEvent(event)) return false;
         return getInstance().handleMotionEvent(event);
     }
 
     private boolean handleMotionEvent(MotionEvent event) {
         synchronized (mLock) {
-            if (!mIsGamepadAccessed) return false;
+            if (!mIsGamepadAPIActive) return false;
             GamepadDevice gamepad = getGamepadForEvent(event);
             if (gamepad == null) return false;
             return gamepad.handleMotionEvent(event);
         }
     }
 
     private int getNextAvailableIndex() {
         // When multiple gamepads are connected to a user agent, indices must be assigned on a
         // first-come first-serve basis, starting at zero. If a gamepad is disconnected, previously
         // assigned indices must not be reassigned to gamepads that continue to be connected.
@@ skipping 29 matching lines @@
         if (inputDevice == null) return false;
         return ((inputDevice.getSources()
                 & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK);
     }
 
     private GamepadDevice getGamepadForEvent(InputEvent event) {
         return getDeviceById(event.getDeviceId());
     }
 
     /**
+     * @return True if HTML5 gamepad API is active.
+     */
+    public static boolean isGamepadAPIActive() {
+        return getInstance().mIsGamepadAPIActive;
+    }
+
+    /**
      * @return True if the motion event corresponds to a gamepad event.
      */
     public static boolean isGamepadEvent(MotionEvent event) {
         return ((event.getSource() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK);
     }
 
     /**
      * @return True if event's keycode corresponds to a gamepad key.
      */
     public static boolean isGamepadEvent(KeyEvent event) {
@@ skipping 26 matching lines @@
                             device.getName(), device.getTimestamp(), device.getAxes(),
                             device.getButtons());
                 } else {
                     nativeSetGamepadData(webGamepadsPtr, i, false, false, null, 0, null, null);
                 }
             }
         }
     }
 
     @CalledByNative
-    static void notifyForGamepadsAccess(boolean isAccessPaused) {
-        getInstance().setIsGamepadAccessed(!isAccessPaused);
+    static void setGamepadAPIActive(boolean isActive) {
+        getInstance().setIsGamepadActive(isActive);
     }
 
-    private void setIsGamepadAccessed(boolean isGamepadAccessed) {
+    private void setIsGamepadActive(boolean isGamepadActive) {
         synchronized (mLock) {
-            mIsGamepadAccessed = isGamepadAccessed;
-            if (isGamepadAccessed) {
+            mIsGamepadAPIActive = isGamepadActive;
+            if (isGamepadActive) {
                 for (int i = 0; i < MAX_GAMEPADS; i++) {
                     GamepadDevice gamepadDevice = getDevice(i);
                     if (gamepadDevice == null) continue;
                     gamepadDevice.clearData();
                 }
             }
         }
     }
 
     private native void nativeSetGamepadData(long webGamepadsPtr, int index, boolean mapping,
             boolean connected, String devicename, long timestamp, float[] axes, float[] buttons);
 
     private static class LazyHolder {
         private static final GamepadList INSTANCE = new GamepadList();
     }
 
 }