Gamepad API support for chrome on android

content/browser/gamepad/gamepad_platform_data_fetcher_android.cc

+// Copyright (c) 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.
+
+#include "content/browser/gamepad/gamepad_platform_data_fetcher_android.h"
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_array.h"
+#include "base/android/jni_string.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+
+#include "jni/GamepadList_jni.h"
+
+#include "third_party/WebKit/public/platform/WebGamepads.h"
+
+using base::android::AttachCurrentThread;
+using base::android::CheckException;
+using base::android::ClearException;
+using base::android::ConvertJavaStringToUTF8;
+using base::android::ScopedJavaLocalRef;
+using blink::WebGamepad;
+using blink::WebGamepads;
+
+namespace content {
+
+bool
+GamepadPlatformDataFetcherAndroid::RegisterGamepadPlatformDataFetcherAndroid(
+    JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+GamepadPlatformDataFetcherAndroid::GamepadPlatformDataFetcherAndroid() {
+  PauseHint(false);
+}
+
+GamepadPlatformDataFetcherAndroid::~GamepadPlatformDataFetcherAndroid() {
+}
+
+void GamepadPlatformDataFetcherAndroid::GetGamepadData(blink::WebGamepads* pads,
+                                                       bool) {
+  JNIEnv* env = AttachCurrentThread();
+  if (!env)
+    return;
+
+  pads->length = 0;
+  Java_GamepadList_getGamepadData(env, reinterpret_cast<intptr_t>(pads));
+}
+
+void GamepadPlatformDataFetcherAndroid::PauseHint(bool isaccesspaused) {
+  JNIEnv* env = AttachCurrentThread();
+  if (!env)
+    return;
+
+  Java_GamepadList_notifyForGamepadsAccess(env, isaccesspaused);
+}
+
+static void SetGamepadData(JNIEnv* env,
+                           jobject obj,
+                           jlong gamepads,
+                           jint index,
+                           jstring mapping,
+                           jboolean connected,
+                           jstring devicename,
+                           jlong timestamp,
+                           jfloatArray jaxes,
+                           jfloatArray jbuttons) {
+  DCHECK(gamepads);
+  blink::WebGamepads* pads = reinterpret_cast<WebGamepads*>(gamepads);
+  DCHECK_EQ(pads->length, unsigned(index));
+  DCHECK_LT(unsigned(index), WebGamepads::itemsLengthCap);
+
+  ++pads->length;
+
+  blink::WebGamepad& pad = pads->items[index];
+
+  pad.connected = connected;
+
+  pad.timestamp = timestamp;

[jdduke (slow), 2014/03/26 16:37:58]

Hmm, do you know if the time measurement matters here, i.e., milliseconds vs
microseconds? Or just as long as they're monotonically increasing?

[SaurabhK, 2014/03/27 13:32:31]

On 2014/03/26 16:37:58, jdduke wrote:

timestamp is of type DOMHighResTimeStamp which is a double representing a number
of milliseconds. I am assigning the timestamp to event time using |getEventTime|
which also returns milliseconds.

+
+  // Do not set gamepad parameters for all the gamepad devices that are not
+  // attached.
+  if (!connected)
+    return;
+
+  // Map the Gamepad DeviceName String to the WebGamepad Id. Ideally it should
+  // be mapped to vendor and product information but it is only available at
+  // kernel level and it can not be queried using class
+  // android.hardware.input.InputManager.
+  base::string16 device_name;
+  base::android::ConvertJavaStringToUTF16(env, devicename, &device_name);
+  const size_t name_to_copy =
+      std::min(device_name.size(), WebGamepad::idLengthCap - 1);
+  memcpy(pad.id,
+         device_name.data(),
+         name_to_copy * sizeof(base::string16::value_type));
+  pad.id[name_to_copy] = 0;
+
+  base::string16 mapping_name;
+  base::android::ConvertJavaStringToUTF16(env, devicename, &mapping_name);
+  const size_t mapping_to_copy =
+      std::min(mapping_name.size(), WebGamepad::mappingLengthCap - 1);
+  memcpy(pad.mapping,
+         mapping_name.data(),
+         mapping_to_copy * sizeof(base::string16::value_type));
+  pad.mapping[mapping_to_copy] = 0;
+
+  pad.timestamp = timestamp;
+
+  std::vector<float> axes;
+  base::android::JavaFloatArrayToFloatVector(env, jaxes, &axes);
+
+  // Set WebGamepad axeslength to total number of axes on the gamepad device.
+  // Only return the first axesLengthCap if axeslength captured by GamepadList
+  // is larger than axesLengthCap.
+  pad.axesLength = std::min(axes.size(), WebGamepad::axesLengthCap);
+
+  memcpy(pad.axes, axes.begin(), pad.axesLength * sizeof(float));
+
+  std::vector<float> buttons;
+  base::android::JavaFloatArrayToFloatVector(env, jbuttons, &buttons);
+
+  // Set WebGamepad buttonslength to total number of axes on the gamepad
+  // device. Only return the first buttonsLengthCap if axeslength captured by
+  // GamepadList is larger than buttonsLengthCap.
+  pad.buttonsLength = std::min(buttons.size(), WebGamepad::buttonsLengthCap);
+
+  // Copy buttons state to the WebGamepad buttons[].
+  for (unsigned int j = 0; j < pad.buttonsLength; j++) {

[jdduke (slow), 2014/03/26 16:37:58]

Hmm, what guarantees do we have that the button indices in blink and the button
indices from Java are in sync? Don't we need a translation method for
canonical_{axis,button}_index_list.h to map between the two?

[kbalazs, 2014/03/26 19:24:53]

This data should be already mapped if a mapping is possible. The indices for the
so called standard gamepad are defined by the standard, and we implement the
mapping according to that. Blink doesn't have it's own definition represented as
an enum or something. I think this is ok.

[SaurabhK, 2014/03/27 13:32:31]

On 2014/03/26 19:24:53, kbalazs wrote:

THe buttons are already mapped to statndard format if the device type is known,
otherwise the buttons will be exposed in raw format.
So for the known devices the buttons in blink and buttons in java will be in
sync.

+    pad.buttons[j].pressed = buttons[j];
+    pad.buttons[j].value = buttons[j];
+  }
+}
+
+}  // namespace content