OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/browser/gamepad/gamepad_platform_data_fetcher_android.h" | |
6 | |
7 #include "base/android/jni_android.h" | |
8 #include "base/android/jni_array.h" | |
9 #include "base/android/jni_string.h" | |
10 #include "base/strings/string_number_conversions.h" | |
11 #include "base/strings/string_util.h" | |
12 #include "base/strings/utf_string_conversions.h" | |
13 | |
14 #include "jni/GamepadList_jni.h" | |
15 | |
16 #include "third_party/WebKit/public/platform/WebGamepads.h" | |
17 | |
18 using base::android::AttachCurrentThread; | |
19 using base::android::CheckException; | |
20 using base::android::ClearException; | |
21 using base::android::ConvertJavaStringToUTF8; | |
22 using base::android::ScopedJavaLocalRef; | |
23 using blink::WebGamepad; | |
24 using blink::WebGamepads; | |
25 | |
26 namespace content { | |
27 | |
28 bool | |
29 GamepadPlatformDataFetcherAndroid::RegisterGamepadPlatformDataFetcherAndroid( | |
30 JNIEnv* env) { | |
31 return RegisterNativesImpl(env); | |
32 } | |
33 | |
34 GamepadPlatformDataFetcherAndroid::GamepadPlatformDataFetcherAndroid() { | |
35 PauseHint(false); | |
36 } | |
37 | |
38 GamepadPlatformDataFetcherAndroid::~GamepadPlatformDataFetcherAndroid() { | |
39 } | |
jdduke (slow)
2014/04/04 15:10:17
PauseHint(true);?
SaurabhK
2014/04/11 14:41:42
On 2014/04/04 15:10:17, jdduke wrote:
Done.
| |
40 | |
41 void GamepadPlatformDataFetcherAndroid::GetGamepadData(blink::WebGamepads* pads, | |
42 bool) { | |
43 JNIEnv* env = AttachCurrentThread(); | |
jdduke (slow)
2014/04/04 15:10:17
Let's add |TRACE_EVENT0("GAMEPAD", "GetGamepadData
SaurabhK
2014/04/11 14:41:42
On 2014/04/04 15:10:17, jdduke wrote:
Done.
| |
44 if (!env) | |
45 return; | |
46 | |
47 pads->length = 0; | |
jdduke (slow)
2014/04/04 15:10:17
Should we unconditionally set pads->length = 0, be
SaurabhK
2014/04/11 14:41:42
On 2014/04/04 15:10:17, jdduke wrote:
Yes, that s
| |
48 Java_GamepadList_getGamepadData(env, reinterpret_cast<intptr_t>(pads)); | |
49 } | |
50 | |
51 void GamepadPlatformDataFetcherAndroid::PauseHint(bool isaccesspaused) { | |
52 JNIEnv* env = AttachCurrentThread(); | |
53 if (!env) | |
54 return; | |
55 | |
56 Java_GamepadList_notifyForGamepadsAccess(env, isaccesspaused); | |
57 } | |
58 | |
59 static void SetGamepadData(JNIEnv* env, | |
60 jobject obj, | |
61 jlong gamepads, | |
62 jint index, | |
63 jstring mapping, | |
jdduke (slow)
2014/04/04 15:10:17
The mapping should only ever be "standard" or "",
SaurabhK
2014/04/11 14:41:42
On 2014/04/04 15:10:17, jdduke wrote:
Done.
| |
64 jboolean connected, | |
65 jstring devicename, | |
66 jlong timestamp, | |
67 jfloatArray jaxes, | |
68 jfloatArray jbuttons) { | |
69 DCHECK(gamepads); | |
70 blink::WebGamepads* pads = reinterpret_cast<WebGamepads*>(gamepads); | |
71 DCHECK_EQ(pads->length, unsigned(index)); | |
72 DCHECK_LT(unsigned(index), WebGamepads::itemsLengthCap); | |
73 | |
74 ++pads->length; | |
75 | |
76 blink::WebGamepad& pad = pads->items[index]; | |
77 | |
78 pad.connected = connected; | |
79 | |
80 pad.timestamp = timestamp; | |
81 | |
82 // Do not set gamepad parameters for all the gamepad devices that are not | |
83 // attached. | |
84 if (!connected) | |
85 return; | |
86 | |
87 // Map the Gamepad DeviceName String to the WebGamepad Id. Ideally it should | |
88 // be mapped to vendor and product information but it is only available at | |
89 // kernel level and it can not be queried using class | |
90 // android.hardware.input.InputManager. | |
91 base::string16 device_name; | |
92 base::android::ConvertJavaStringToUTF16(env, devicename, &device_name); | |
93 const size_t name_to_copy = | |
94 std::min(device_name.size(), WebGamepad::idLengthCap - 1); | |
95 memcpy(pad.id, | |
96 device_name.data(), | |
97 name_to_copy * sizeof(base::string16::value_type)); | |
98 pad.id[name_to_copy] = 0; | |
99 | |
100 base::string16 mapping_name; | |
101 base::android::ConvertJavaStringToUTF16(env, devicename, &mapping_name); | |
102 const size_t mapping_to_copy = | |
103 std::min(mapping_name.size(), WebGamepad::mappingLengthCap - 1); | |
104 memcpy(pad.mapping, | |
105 mapping_name.data(), | |
106 mapping_to_copy * sizeof(base::string16::value_type)); | |
107 pad.mapping[mapping_to_copy] = 0; | |
108 | |
109 pad.timestamp = timestamp; | |
110 | |
111 std::vector<float> axes; | |
112 base::android::JavaFloatArrayToFloatVector(env, jaxes, &axes); | |
113 | |
114 // Set WebGamepad axeslength to total number of axes on the gamepad device. | |
115 // Only return the first axesLengthCap if axeslength captured by GamepadList | |
116 // is larger than axesLengthCap. | |
117 pad.axesLength = std::min(axes.size(), WebGamepad::axesLengthCap); | |
118 | |
119 memcpy(pad.axes, axes.begin(), pad.axesLength * sizeof(float)); | |
120 | |
121 std::vector<float> buttons; | |
122 base::android::JavaFloatArrayToFloatVector(env, jbuttons, &buttons); | |
123 | |
124 // Set WebGamepad buttonslength to total number of axes on the gamepad | |
125 // device. Only return the first buttonsLengthCap if axeslength captured by | |
126 // GamepadList is larger than buttonsLengthCap. | |
127 pad.buttonsLength = std::min(buttons.size(), WebGamepad::buttonsLengthCap); | |
128 | |
129 // Copy buttons state to the WebGamepad buttons[]. | |
130 for (unsigned int j = 0; j < pad.buttonsLength; j++) { | |
131 pad.buttons[j].pressed = buttons[j]; | |
132 pad.buttons[j].value = buttons[j]; | |
133 } | |
134 } | |
135 | |
136 } // namespace content | |
OLD | NEW |