Index: content/public/android/java/src/org/chromium/content/browser/GamepadList.java |
diff --git a/content/public/android/java/src/org/chromium/content/browser/GamepadList.java b/content/public/android/java/src/org/chromium/content/browser/GamepadList.java |
new file mode 100644 |
index 0000000000000000000000000000000000000000..ea66e93c6b83fc8644d709fa5f6d62aef890c18e |
--- /dev/null |
+++ b/content/public/android/java/src/org/chromium/content/browser/GamepadList.java |
@@ -0,0 +1,294 @@ |
+// 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; |
+ |
+import android.content.Context; |
+import android.hardware.input.InputManager; |
+import android.hardware.input.InputManager.InputDeviceListener; |
+import android.view.InputDevice; |
+import android.view.InputEvent; |
+import android.view.KeyEvent; |
+import android.view.MotionEvent; |
+ |
+import org.chromium.base.CalledByNative; |
+import org.chromium.base.JNINamespace; |
+import org.chromium.base.ThreadUtils; |
+ |
+/* |
+ * Class to manage connected gamepad devices list. |
+ */ |
+@JNINamespace("content") |
+class GamepadList implements InputDeviceListener { |
+ private static final int MAX_GAMEPADS = 4; |
+ private GamepadDevice[] mGamepadDevices = new GamepadDevice[MAX_GAMEPADS]; |
+ private boolean mIsGamepadAccessed = false; |
+ private final Object mLock = new Object(); |
+ private InputManager mInputManager; |
+ private int mAttachedToWindowCounter; |
+ |
+ private GamepadList() {} |
+ |
+ private void initializeDevices() { |
+ // Get list of all the attached input devices. |
+ int[] deviceIds = mInputManager.getInputDeviceIds(); |
+ for (int i = 0; i < deviceIds.length; i++) { |
+ InputDevice inputDevice = InputDevice.getDevice(deviceIds[i]); |
+ // Check for gamepad device |
+ if (isGamepadDevice(inputDevice)) { |
+ // Register a new gamepad device. |
+ registerGamepad(inputDevice); |
+ } |
+ } |
+ } |
+ |
+ private static GamepadList sGamepadList = null; |
+ |
+ public static void onAttachedToWindow(Context context) { |
+ assert ThreadUtils.runningOnUiThread(); |
+ createInstance(); |
+ sGamepadList.attachedToWindow(context); |
+ } |
+ |
+ private void attachedToWindow(Context context) { |
+ if (mAttachedToWindowCounter++ == 0) { |
+ mInputManager = (InputManager) context.getSystemService(Context.INPUT_SERVICE); |
+ synchronized (mLock) { |
+ initializeDevices(); |
+ } |
+ // Register an input device listener. |
+ mInputManager.registerInputDeviceListener(this, null); |
+ } |
+ } |
+ |
+ public static void onDetachedFromWindow() { |
+ assert ThreadUtils.runningOnUiThread(); |
+ sGamepadList.detachedFromWindow(); |
+ } |
+ |
+ private void detachedFromWindow() { |
+ if (--mAttachedToWindowCounter == 0) { |
+ synchronized (mLock) { |
+ for (int i = 0; i < MAX_GAMEPADS; ++i) { |
+ mGamepadDevices[i] = null; |
+ } |
+ } |
+ mInputManager.unregisterInputDeviceListener(this); |
+ mInputManager = null; |
+ } |
+ } |
+ |
+ // Override InputDeviceListener methods |
+ @Override |
+ public void onInputDeviceChanged(int deviceId) { |
+ } |
+ |
+ @Override |
+ public void onInputDeviceRemoved(int deviceId) { |
+ synchronized (mLock) { |
+ unregisterGamepad(deviceId); |
+ } |
+ } |
+ |
+ @Override |
+ public void onInputDeviceAdded(int deviceId) { |
+ InputDevice inputDevice = InputDevice.getDevice(deviceId); |
+ if(!isGamepadDevice(inputDevice)) return; |
+ synchronized (mLock) { |
+ registerGamepad(inputDevice); |
+ } |
+ } |
+ |
+ public static void createInstance() { |
+ if (sGamepadList == null) { |
+ sGamepadList = new GamepadList(); |
+ } |
+ } |
+ |
+ private int getDeviceCount() { |
+ int count = 0; |
+ for (int i = 0; i < MAX_GAMEPADS; ++i) { |
+ if (getDevice(i) != null) { |
+ count++; |
+ } |
+ } |
+ return count; |
+ } |
+ |
+ private boolean isDeviceConnected(int index) { |
+ if (index < MAX_GAMEPADS && getDevice(index) != null) { |
+ return true; |
+ } |
+ return false; |
+ } |
+ |
+ private GamepadDevice getDeviceById(int deviceId) { |
+ for (int i = 0; i < MAX_GAMEPADS; ++i) { |
+ GamepadDevice gamepad = mGamepadDevices[i]; |
+ if (gamepad != null && gamepad.getId() == deviceId) { |
+ return gamepad; |
+ } |
+ } |
+ return null; |
+ } |
+ |
+ private GamepadDevice getDevice(int index) { |
+ // Maximum 4 Gamepads can be connected at a time starting at index zero. |
+ assert index >= 0 && index < MAX_GAMEPADS; |
+ return mGamepadDevices[index]; |
+ } |
+ |
+ public static boolean dispatchKeyEvent(KeyEvent event) { |
+ if (!isGamepadEvent(event)) return false; |
+ return sGamepadList.updateForEvent(event); |
+ } |
+ |
+ private static boolean updateForEvent(KeyEvent event) { |
+ synchronized (sGamepadList.mLock) { |
+ if (!sGamepadList.mIsGamepadAccessed) return false; |
+ GamepadDevice gamepad = sGamepadList.getGamepadForEvent(event); |
+ if (gamepad != null) { |
+ return gamepad.updateForEvent(event); |
+ } |
+ return false; |
+ } |
+ } |
+ |
+ public static boolean onGenericMotionEvent(MotionEvent event) { |
+ if (!isGamepadEvent(event)) return false; |
+ return sGamepadList.updateForEvent(event); |
+ } |
+ |
+ private static boolean updateForEvent(MotionEvent event) { |
+ synchronized (sGamepadList.mLock) { |
+ if (!sGamepadList.mIsGamepadAccessed) return false; |
+ GamepadDevice gamepad = sGamepadList.getGamepadForEvent(event); |
+ if (gamepad != null) { |
jdduke (slow)
2014/03/26 16:37:58
if (gamepad == null) return false;
return gamepad.
SaurabhK
2014/03/27 13:32:31
On 2014/03/26 16:37:58, jdduke wrote:
Done.
|
+ return gamepad.updateForEvent(event); |
+ } |
+ return false; |
+ } |
+ } |
+ |
+ 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. |
+ // However, if a gamepad is disconnected, and subsequently the same or a different |
+ // gamepad is then connected, index entries must be reused. |
+ |
+ for (int i = 0; i < MAX_GAMEPADS; ++i) { |
+ if (getDevice(i) == null) { |
+ return i; |
+ } |
+ } |
+ // Reached maximum gamepads limit. |
+ return -1; |
+ } |
+ |
+ private boolean registerGamepad(InputDevice inputDevice) { |
+ int index = getNextAvailableIndex(); |
+ if (index == -1) { |
+ return false; // invalid index |
+ } |
+ |
+ GamepadDevice gamepad = new GamepadDevice(index, inputDevice); |
+ mGamepadDevices[index] = gamepad; |
+ return true; |
+ } |
+ |
+ private void unregisterGamepad(int deviceId) { |
+ GamepadDevice gamepadDevice = getDeviceById(deviceId); |
+ if (gamepadDevice == null) { |
jdduke (slow)
2014/03/26 16:37:58
Nit: No braces, return on same line.
SaurabhK
2014/03/27 13:32:31
On 2014/03/26 16:37:58, jdduke wrote:
Done.
|
+ return; // Not a registered device. |
+ } |
+ int index = gamepadDevice.getIndex(); |
+ mGamepadDevices[index] = null; |
+ } |
+ |
+ private static boolean isGamepadDevice(InputDevice inputDevice) { |
+ int sources = inputDevice.getSources(); |
+ if ((sources & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK ) { |
+ //Found gamepad device |
+ return true; |
+ } |
+ return false; |
+ } |
+ |
+ private GamepadDevice getGamepadForEvent(InputEvent event) { |
+ int deviceId = event.getDeviceId(); |
+ GamepadDevice gamepad = getDeviceById(deviceId); |
+ return gamepad; |
+ } |
+ |
+ private static boolean isGamepadEvent(MotionEvent event) { |
+ if ((event.getSource() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK) { |
jdduke (slow)
2014/03/26 16:37:58
Just
return (event.getSource() & InputDevice.SOU
SaurabhK
2014/03/27 13:32:31
On 2014/03/26 16:37:58, jdduke wrote:
Done.
|
+ return true; |
+ } |
+ return false; |
+ } |
+ |
+ // Returns true if event's keycode corresponds to a gamepad key. |
+ // Specific handling for dpad keys is required because |
+ // KeyEvent.isGamepadButton doesn't consider dpad keys. |
+ private static boolean isGamepadEvent(KeyEvent event) { |
+ int keyCode = event.getKeyCode(); |
+ switch (keyCode) { |
+ case KeyEvent.KEYCODE_DPAD_UP: |
+ case KeyEvent.KEYCODE_DPAD_DOWN: |
+ case KeyEvent.KEYCODE_DPAD_LEFT: |
+ case KeyEvent.KEYCODE_DPAD_RIGHT: |
+ return true; |
+ default: |
+ return KeyEvent.isGamepadButton(keyCode); |
+ } |
+ } |
+ |
+ @CalledByNative |
+ static void getGamepadData(long gamepads) { |
+ assert sGamepadList != null; |
+ sGamepadList.grabGamepadData(gamepads); |
+ } |
+ |
+ private void grabGamepadData(long gamepads) { |
+ synchronized (mLock) { |
+ for (int i = 0; i < MAX_GAMEPADS; i++) { |
+ final GamepadDevice device = getDevice(i); |
+ if (device != null && device.hasDeviceBeenInteractedWith()) { |
kbalazs
2014/03/26 19:24:53
The gesture check (a la hasBeenInteractedWith()) i
SaurabhK
2014/03/27 13:32:31
On 2014/03/26 19:24:53, kbalazs wrote:
Correctly
|
+ device.mapButtonsAndAxes(); |
+ nativeSetGamepadData(gamepads, i, device.getMapping(), true, |
+ device.getName(), device.getTimestamp(), device.getAxes(), |
+ device.getButtons()); |
+ } |
+ else |
+ nativeSetGamepadData(gamepads, i, null, false, null, 0, null, null); |
+ } |
+ } |
+ } |
+ |
+ @CalledByNative |
+ static void notifyForGamepadsAccess(boolean isaccesspaused) { |
+ assert sGamepadList != null; |
+ synchronized (sGamepadList.mLock) { |
+ sGamepadList.mIsGamepadAccessed = !isaccesspaused; |
+ if (isaccesspaused) { |
+ for (int i = 0; i < MAX_GAMEPADS; i++) { |
+ GamepadDevice gamepadDevice = sGamepadList.getDevice(i); |
+ if(gamepadDevice != null) |
+ gamepadDevice.clearData(); |
jdduke (slow)
2014/03/26 16:37:58
Nit:
if (gamepadDevice == null) continue;
gamepad
SaurabhK
2014/03/27 13:32:31
On 2014/03/26 16:37:58, jdduke wrote:
Done.
|
+ } |
+ } |
+ } |
+ } |
+ |
+ private native void nativeSetGamepadData(long gamepads, |
+ int index, |
+ String mapping, |
+ boolean connected, |
+ String devicename, |
+ long timestamp, |
+ float[] axes, |
+ float[] buttons); |
+ |
+} |