Gamepad API for Android

content/browser/gamepad/gamepad_platform_data_fetcher_android.cc

Index: content/browser/gamepad/gamepad_platform_data_fetcher_android.cc
diff --git a/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc b/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc
new file mode 100644
index 0000000000000000000000000000000000000000..eb86875fa79e179e84bbe15f90dc8f4b3adddcd6
--- /dev/null
+++ b/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc
@@ -0,0 +1,100 @@
+// 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.
+
+#include "content/browser/gamepad/gamepad_platform_data_fetcher_android.h"
+
+#include "base/debug/trace_event.h"
+#include "base/strings/utf_string_conversions.h"
+#include "jni/GamepadAdapter_jni.h"
+#include "third_party/WebKit/public/platform/WebGamepad.h"
+
+namespace content {
+
+namespace {
+
+void copyJavaStringToWebUCharArray(

[bulach, 2014/03/05 12:34:39]

nit: s/copy/Copy/

+    JNIEnv* env, jstring src, blink::WebUChar* array, int array_lenght) {

[bulach, 2014/03/05 12:34:39]

nit: s/lenght/length/
also, it should probably be size_t

+  jsize length = env->GetStringLength(src);
+  const jchar* utf16 = env->GetStringChars(src, 0);

[bulach, 2014/03/05 12:34:39]

hmm... we try to avoid calling into "env->" directly..
also, the length * sizeof can overflow, should probably do everything in
"size_t" space.
something like:

COMPILE_ASSERT(sizeof(string16::char_type) == sizeof(blink::WebUChar),
               string16_and_WebUChar_are_same_size);
base::string16 data;
base::ConvertJavaStringToUTF16(env, src, &data);
CHECK(array_length > static_cast<size_t>(0));
const size_t bytes_to_copy = std::min(data.size(), array_length - 1);
memcpy(array, data.data(), bytes_to_copy);
array[bytes_to_copy] = 0;

+  COMPILE_ASSERT(sizeof(jchar) == sizeof(blink::WebUChar),
+                 jchar_and_WebUChar_are_same_size);
+  DCHECK(array_lenght >= 1);
+  const size_t bytes_to_copy =
+      std::min(length * sizeof(jchar), static_cast<size_t>(array_lenght - 1));
+  memcpy(array, utf16, bytes_to_copy);
+  array[bytes_to_copy] = 0;
+  env->ReleaseStringChars(src, utf16);
+}
+
+}
+
+using base::android::AttachCurrentThread;
+using blink::WebGamepad;
+using blink::WebGamepads;
+
+GamepadPlatformDataFetcherAndroid::GamepadPlatformDataFetcherAndroid() {
+  j_gamepad_adapter_ =
+      Java_GamepadAdapter_attach(AttachCurrentThread(),
+                                 reinterpret_cast<intptr_t>(this));
+}
+
+GamepadPlatformDataFetcherAndroid::~GamepadPlatformDataFetcherAndroid() {
+}
+
+void GamepadPlatformDataFetcherAndroid::GetGamepadData(
+    blink::WebGamepads* pads,
+    bool devices_changed_hint) {
+  TRACE_EVENT0("GAMEPAD", "GetGamepadData");
+  data_ = pads;
+  data_->length = WebGamepads::itemsLengthCap;
+  Java_GamepadAdapter_getGamepadData(
+      AttachCurrentThread(), j_gamepad_adapter_.obj());
+  data_ = NULL;
+}
+
+void GamepadPlatformDataFetcherAndroid::PauseHint(bool paused) {
+  Java_GamepadAdapter_setFetched(
+        AttachCurrentThread(), j_gamepad_adapter_.obj(), !paused);
+}
+
+void GamepadPlatformDataFetcherAndroid::RefreshDevice(
+    JNIEnv* env,
+    jobject obj,
+    int index,
+    bool connected,
+    jstring id,
+    jstring mapping,
+    long timestamp,
+    jfloatArray axes,
+    jfloatArray buttons) {
+  CHECK(data_);
+  WebGamepad& pad = data_->items[index];
+  pad.connected = connected;
+  if (!connected)
+    return;
+  copyJavaStringToWebUCharArray(env, id, pad.id, WebGamepad::idLengthCap);
+  copyJavaStringToWebUCharArray(env, mapping, pad.mapping,
+                                WebGamepad::mappingLengthCap);
+  pad.timestamp = timestamp;
+  pad.axesLength = std::min(env->GetArrayLength(axes),
+                            static_cast<int>(WebGamepad::axesLengthCap));
+  jfloat* raw_axes = env->GetFloatArrayElements(axes, 0);

[bulach, 2014/03/05 12:34:39]

ditto, use base::android::JavaFloatArrayToFloatVector(...) and work with a
std::vector

[kbalazs, 2014/03/05 19:56:11]

Ok. For the record I used the jni api's directly to avoid an extra copy. It
shouldn't be a real problem though.

+  memcpy(pad.axes, raw_axes, pad.axesLength * sizeof(float));
+  env->ReleaseFloatArrayElements(axes, raw_axes, 0);
+  pad.buttonsLength = std::min(env->GetArrayLength(buttons),
+                               static_cast<int>(WebGamepad::buttonsLengthCap));
+  jfloat* raw_buttons = env->GetFloatArrayElements(buttons, 0);
+  for (unsigned i = 0; i < pad.buttonsLength; ++i) {
+    float value = raw_buttons[i];
+    pad.buttons[i].pressed = value;
+    pad.buttons[i].value = value;
+  }
+  env->ReleaseFloatArrayElements(buttons, raw_buttons, 0);
+}
+
+bool GamepadPlatformDataFetcherAndroid::RegisterGamepadAdapter(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+}