event_forwarder.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251
  1. // Copyright 2017 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. #include "ui/android/event_forwarder.h"
  5. #include "base/android/jni_array.h"
  6. #include "ui/android/ui_android_jni_headers/EventForwarder_jni.h"
  7. #include "ui/android/window_android.h"
  8. #include "ui/base/ui_base_switches_util.h"
  9. #include "ui/events/android/drag_event_android.h"
  10. #include "ui/events/android/gesture_event_android.h"
  11. #include "ui/events/android/gesture_event_type.h"
  12. #include "ui/events/android/key_event_android.h"
  13. #include "ui/events/android/motion_event_android.h"
  14. namespace ui {
  15. using base::android::AppendJavaStringArrayToStringVector;
  16. using base::android::JavaParamRef;
  17. using base::android::ScopedJavaLocalRef;
  18. EventForwarder::EventForwarder(ViewAndroid* view) : view_(view) {}
  19. EventForwarder::~EventForwarder() {
  20. if (!java_obj_.is_null()) {
  21. Java_EventForwarder_destroy(base::android::AttachCurrentThread(),
  22. java_obj_);
  23. java_obj_.Reset();
  24. }
  25. }
  26. ScopedJavaLocalRef<jobject> EventForwarder::GetJavaObject() {
  27. if (java_obj_.is_null()) {
  28. JNIEnv* env = base::android::AttachCurrentThread();
  29. java_obj_.Reset(
  30. Java_EventForwarder_create(env, reinterpret_cast<intptr_t>(this),
  31. switches::IsTouchDragDropEnabled()));
  32. }
  33. return ScopedJavaLocalRef<jobject>(java_obj_);
  34. }
  35. ScopedJavaLocalRef<jobject> EventForwarder::GetJavaWindowAndroid(
  36. JNIEnv* env,
  37. const JavaParamRef<jobject>& obj) {
  38. return view_->GetWindowAndroid()->GetJavaObject();
  39. }
  40. jboolean EventForwarder::OnTouchEvent(JNIEnv* env,
  41. const JavaParamRef<jobject>& obj,
  42. const JavaParamRef<jobject>& motion_event,
  43. jlong time_ms,
  44. jint android_action,
  45. jint pointer_count,
  46. jint history_size,
  47. jint action_index,
  48. jfloat pos_x_0,
  49. jfloat pos_y_0,
  50. jfloat pos_x_1,
  51. jfloat pos_y_1,
  52. jint pointer_id_0,
  53. jint pointer_id_1,
  54. jfloat touch_major_0,
  55. jfloat touch_major_1,
  56. jfloat touch_minor_0,
  57. jfloat touch_minor_1,
  58. jfloat orientation_0,
  59. jfloat orientation_1,
  60. jfloat tilt_0,
  61. jfloat tilt_1,
  62. jfloat raw_pos_x,
  63. jfloat raw_pos_y,
  64. jint android_tool_type_0,
  65. jint android_tool_type_1,
  66. jint android_gesture_classification,
  67. jint android_button_state,
  68. jint android_meta_state,
  69. jboolean for_touch_handle) {
  70. ui::MotionEventAndroid::Pointer pointer0(
  71. pointer_id_0, pos_x_0, pos_y_0, touch_major_0, touch_minor_0,
  72. orientation_0, tilt_0, android_tool_type_0);
  73. ui::MotionEventAndroid::Pointer pointer1(
  74. pointer_id_1, pos_x_1, pos_y_1, touch_major_1, touch_minor_1,
  75. orientation_1, tilt_1, android_tool_type_1);
  76. ui::MotionEventAndroid event(
  77. env, motion_event.obj(), 1.f / view_->GetDipScale(), 0.f, 0.f, 0.f,
  78. time_ms, android_action, pointer_count, history_size, action_index,
  79. 0 /* action_button */, android_gesture_classification,
  80. android_button_state, android_meta_state, raw_pos_x - pos_x_0,
  81. raw_pos_y - pos_y_0, for_touch_handle, &pointer0, &pointer1);
  82. return view_->OnTouchEvent(event);
  83. }
  84. void EventForwarder::OnMouseEvent(JNIEnv* env,
  85. const JavaParamRef<jobject>& obj,
  86. jlong time_ms,
  87. jint android_action,
  88. jfloat x,
  89. jfloat y,
  90. jint pointer_id,
  91. jfloat orientation,
  92. jfloat pressure,
  93. jfloat tilt,
  94. jint android_action_button,
  95. jint android_button_state,
  96. jint android_meta_state,
  97. jint android_tool_type) {
  98. // Construct a motion_event object minimally, only to convert the raw
  99. // parameters to ui::MotionEvent values. Since we used only the cached values
  100. // at index=0, it is okay to even pass a null event to the constructor.
  101. ui::MotionEventAndroid::Pointer pointer(
  102. pointer_id, x, y, 0.0f /* touch_major */, 0.0f /* touch_minor */,
  103. orientation, tilt, android_tool_type);
  104. ui::MotionEventAndroid event(
  105. env, nullptr /* event */, 1.f / view_->GetDipScale(), 0.f, 0.f, 0.f,
  106. time_ms, android_action, 1 /* pointer_count */, 0 /* history_size */,
  107. 0 /* action_index */, android_action_button,
  108. 0 /* gesture_classification */, android_button_state, android_meta_state,
  109. 0 /* raw_offset_x_pixels */, 0 /* raw_offset_y_pixels */,
  110. false /* for_touch_handle */, &pointer, nullptr);
  111. view_->OnMouseEvent(event);
  112. }
  113. void EventForwarder::OnDragEvent(JNIEnv* env,
  114. const JavaParamRef<jobject>& jobj,
  115. jint action,
  116. jfloat x,
  117. jfloat y,
  118. jfloat screen_x,
  119. jfloat screen_y,
  120. const JavaParamRef<jobjectArray>& j_mimeTypes,
  121. const JavaParamRef<jstring>& j_content) {
  122. float dip_scale = view_->GetDipScale();
  123. gfx::PointF location(x / dip_scale, y / dip_scale);
  124. gfx::PointF root_location(screen_x / dip_scale, screen_y / dip_scale);
  125. std::vector<std::u16string> mime_types;
  126. AppendJavaStringArrayToStringVector(env, j_mimeTypes, &mime_types);
  127. DragEventAndroid event(env, action, location, root_location, mime_types,
  128. j_content.obj());
  129. view_->OnDragEvent(event);
  130. }
  131. jboolean EventForwarder::OnGestureEvent(JNIEnv* env,
  132. const JavaParamRef<jobject>& jobj,
  133. jint type,
  134. jlong time_ms,
  135. jfloat scale) {
  136. float dip_scale = view_->GetDipScale();
  137. auto size = view_->GetSize();
  138. float x = size.width() / 2;
  139. float y = size.height() / 2;
  140. gfx::PointF root_location =
  141. ScalePoint(view_->GetLocationOnScreen(x, y), 1.f / dip_scale);
  142. return view_->OnGestureEvent(GestureEventAndroid(
  143. type, gfx::PointF(x / dip_scale, y / dip_scale), root_location, time_ms,
  144. scale, 0, 0, 0, 0, /*target_viewport*/ false, /*synthetic_scroll*/ false,
  145. /*prevent_boosting*/ false));
  146. }
  147. jboolean EventForwarder::OnGenericMotionEvent(
  148. JNIEnv* env,
  149. const JavaParamRef<jobject>& obj,
  150. const JavaParamRef<jobject>& motion_event,
  151. jlong time_ms) {
  152. auto size = view_->GetSize();
  153. float x = size.width() / 2;
  154. float y = size.height() / 2;
  155. ui::MotionEventAndroid::Pointer pointer0(0, x, y, 0, 0, 0, 0, 0);
  156. ui::MotionEventAndroid event(
  157. env, motion_event.obj(), 1.f / view_->GetDipScale(), 0.f, 0.f, 0.f,
  158. time_ms, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, false, &pointer0, nullptr);
  159. return view_->OnGenericMotionEvent(event);
  160. }
  161. jboolean EventForwarder::OnKeyUp(JNIEnv* env,
  162. const JavaParamRef<jobject>& obj,
  163. const JavaParamRef<jobject>& key_event,
  164. jint key_code) {
  165. return view_->OnKeyUp(KeyEventAndroid(env, key_event, key_code));
  166. }
  167. jboolean EventForwarder::DispatchKeyEvent(
  168. JNIEnv* env,
  169. const JavaParamRef<jobject>& obj,
  170. const JavaParamRef<jobject>& key_event) {
  171. return view_->DispatchKeyEvent(KeyEventAndroid(env, key_event, 0));
  172. }
  173. void EventForwarder::ScrollBy(JNIEnv* env,
  174. const JavaParamRef<jobject>& jobj,
  175. jfloat delta_x,
  176. jfloat delta_y) {
  177. view_->ScrollBy(delta_x, delta_y);
  178. }
  179. void EventForwarder::ScrollTo(JNIEnv* env,
  180. const JavaParamRef<jobject>& jobj,
  181. jfloat x,
  182. jfloat y) {
  183. view_->ScrollTo(x, y);
  184. }
  185. void EventForwarder::DoubleTap(JNIEnv* env,
  186. const JavaParamRef<jobject>& jobj,
  187. jlong time_ms,
  188. jint x,
  189. jint y) {
  190. float dip_scale = view_->GetDipScale();
  191. view_->OnGestureEvent(GestureEventAndroid(
  192. GESTURE_EVENT_TYPE_DOUBLE_TAP, gfx::PointF(x / dip_scale, y / dip_scale),
  193. gfx::PointF(), time_ms, 0, 0, 0, 0, 0, /*target_viewport*/ true,
  194. /*synthetic_scroll*/ false, /*prevent_boosting*/ false));
  195. }
  196. void EventForwarder::StartFling(JNIEnv* env,
  197. const JavaParamRef<jobject>& jobj,
  198. jlong time_ms,
  199. jfloat velocity_x,
  200. jfloat velocity_y,
  201. jboolean synthetic_scroll,
  202. jboolean prevent_boosting) {
  203. CancelFling(env, jobj, time_ms, prevent_boosting);
  204. if (velocity_x == 0 && velocity_y == 0)
  205. return;
  206. float dip_scale = view_->GetDipScale();
  207. // Use velocity as delta in scroll event.
  208. view_->OnGestureEvent(GestureEventAndroid(
  209. GESTURE_EVENT_TYPE_SCROLL_START, gfx::PointF(), gfx::PointF(), time_ms, 0,
  210. velocity_x / dip_scale, velocity_y / dip_scale, 0, 0,
  211. /*target_viewport*/ true, synthetic_scroll,
  212. /*prevent_boosting*/ false));
  213. view_->OnGestureEvent(GestureEventAndroid(
  214. GESTURE_EVENT_TYPE_FLING_START, gfx::PointF(), gfx::PointF(), time_ms, 0,
  215. 0, 0, velocity_x / dip_scale, velocity_y / dip_scale,
  216. /*target_viewport*/ true, synthetic_scroll,
  217. /*prevent_boosting*/ false));
  218. }
  219. void EventForwarder::CancelFling(JNIEnv* env,
  220. const JavaParamRef<jobject>& jobj,
  221. jlong time_ms,
  222. jboolean prevent_boosting) {
  223. view_->OnGestureEvent(GestureEventAndroid(
  224. GESTURE_EVENT_TYPE_FLING_CANCEL, gfx::PointF(), gfx::PointF(), time_ms, 0,
  225. 0, 0, 0, 0,
  226. /*target_viewport*/ false, /*synthetic_scroll*/ false, prevent_boosting));
  227. }
  228. } // namespace ui