// Copyright 2017 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "ui/android/event_forwarder.h" #include "base/android/jni_array.h" #include "base/numerics/ranges.h" #include "base/trace_event/typed_macros.h" #include "base/tracing/protos/chrome_track_event.pbzero.h" #include "ui/android/window_android.h" #include "ui/base/ui_base_features.h" #include "ui/events/android/drag_event_android.h" #include "ui/events/android/gesture_event_android.h" #include "ui/events/android/gesture_event_type.h" #include "ui/events/android/key_event_android.h" #include "ui/events/android/motion_event_android_factory.h" #include "ui/events/android/motion_event_android_java.h" #include "ui/events/android/motion_event_android_source_java.h" // Must come after all headers that specialize FromJniType() / ToJniType(). #include "ui/android/ui_android_jni_headers/EventForwarder_jni.h" #include "ui/events/motionevent_jni_headers/MotionEvent_jni.h" namespace ui { namespace { static constexpr float kEpsilon = 1e-5f; using base::android::AppendJavaStringArrayToStringVector; using base::android::JavaRef; using base::android::ScopedJavaLocalRef; } // namespace EventForwarder::EventForwarder(ViewAndroid* view) : view_(view) {} EventForwarder::~EventForwarder() { JNIEnv* env = jni_zero::AttachCurrentThread(); ScopedJavaLocalRef java_obj = GetJavaObject(env); if (!java_obj.is_null()) { Java_EventForwarder_destroy(env, java_obj); } } ScopedJavaLocalRef EventForwarder::GetJavaObject(JNIEnv* env) { return Java_EventForwarder_getJavaObject(env, reinterpret_cast(this)); } ScopedJavaLocalRef EventForwarder::GetOrCreateJavaObject(JNIEnv* env) { ScopedJavaLocalRef java_obj = GetJavaObject(env); if (java_obj.is_null()) { java_obj = Java_EventForwarder_create(env, reinterpret_cast(this), features::IsTouchDragAndDropEnabled()); } DCHECK(!java_obj.is_null()); return java_obj; } bool EventForwarder::OnTouchEvent(JNIEnv* env, const JavaRef& motion_event, int64_t oldest_event_time_ns, int64_t latest_event_time_ns, int32_t android_action, float touch_major_0, float touch_major_1, float touch_minor_0, float touch_minor_1, int32_t android_gesture_classification, bool for_touch_handle, bool is_latest_event_resampled) { std::unique_ptr source = MotionEventAndroidSourceJava::Create(motion_event, is_latest_event_resampled); int32_t pointer_count = JNI_MotionEvent::Java_MotionEvent_getPointerCount(env, motion_event); int32_t history_size = JNI_MotionEvent::Java_MotionEvent_getHistorySize(env, motion_event); TRACE_EVENT( "input", "EventForwarder::OnTouchEvent", [&](perfetto::EventContext ctx) { auto* event = ctx.event(); auto* forwarder = event->set_event_forwarder(); forwarder->set_history_size(history_size); forwarder->set_latest_time_ns(latest_event_time_ns); // In the case of unbuffered input that chrome uses usually history_size // == 0 and oldest_time == latest_time so to save trace buffer space we // emit it only if they are different. if (oldest_event_time_ns != latest_event_time_ns) { forwarder->set_oldest_time_ns(oldest_event_time_ns); } float pos_x_0 = source->GetXPix(0); float pos_y_0 = source->GetYPix(0); forwarder->set_x_pixel(pos_x_0); forwarder->set_y_pixel(pos_y_0); // Only record if there was movement for Action::Move (we'll update the // last position on the first Motion::TouchDown). if (android_action == MotionEventAndroid::GetAndroidAction(MotionEvent::Action::MOVE)) { forwarder->set_has_x_movement( !base::IsApproximatelyEqual(pos_x_0, last_x_pos_, kEpsilon)); forwarder->set_has_y_movement( !base::IsApproximatelyEqual(pos_y_0, last_y_pos_, kEpsilon)); } int64_t down_time_ms = JNI_MotionEvent::Java_MotionEvent_getDownTime(env, motion_event); forwarder->set_down_time_ns(down_time_ms * base::Time::kNanosecondsPerMillisecond); forwarder->set_action( static_cast< perfetto::protos::pbzero::EventForwarder::AMotionEventAction>( android_action)); }); float pos_x_0 = source->GetXPix(0); float pos_y_0 = source->GetYPix(0); last_x_pos_ = pos_x_0; last_y_pos_ = pos_y_0; MotionEventAndroid::Pointer pointer0( source->GetPointerId(0), /*pos_x_pixels=*/pos_x_0, /*pos_y_pixels=*/pos_y_0, /*touch_major_pixels=*/touch_major_0, /*touch_minor_pixels=*/touch_minor_0, source->GetPressure(0), source->GetRawOrientation(0), source->GetRawTilt(0), MotionEventAndroid::GetAndroidToolType(source->GetToolType(0))); std::unique_ptr pointer1; if (pointer_count > 1) { pointer1 = std::make_unique( source->GetPointerId(1), /*pos_x_pixels=*/source->GetXPix(1), /*pos_y_pixels=*/source->GetYPix(1), /*touch_major_pixels=*/touch_major_1, /*touch_minor_pixels=*/touch_minor_1, source->GetPressure(1), source->GetRawOrientation(1), source->GetRawTilt(1), MotionEventAndroid::GetAndroidToolType(source->GetToolType(1))); } // Java |MotionEvent.getDownTime| returns the value in milliseconds, use // base::TimeTicks::FromUptimeMillis to get base::TimeTicks for this // milliseconds timestamp. base::TimeTicks down_time = base::TimeTicks::FromUptimeMillis( JNI_MotionEvent::Java_MotionEvent_getDownTime(env, motion_event)); auto event = ui::MotionEventAndroidFactory::CreateFromJava( env, /*event=*/motion_event, /*pix_to_dip=*/1.f / view_->GetDipScale(), /*ticks_x=*/0.f, /*ticks_y=*/0.f, /*tick_multiplier=*/0.f, base::TimeTicks::FromJavaNanoTime(oldest_event_time_ns), base::TimeTicks::FromJavaNanoTime(latest_event_time_ns), down_time, android_action, pointer_count, history_size, JNI_MotionEvent::Java_MotionEvent_getActionIndex(env, motion_event), /*android_action_button=*/0, android_gesture_classification, JNI_MotionEvent::Java_MotionEvent_getButtonState(env, motion_event), /*raw_offset_x_pixels=*/ JNI_MotionEvent::Java_MotionEvent_getRawX(env, motion_event) - pos_x_0, /*raw_offset_y_pixels=*/ JNI_MotionEvent::Java_MotionEvent_getRawY(env, motion_event) - pos_y_0, for_touch_handle, &pointer0, pointer1.get(), is_latest_event_resampled); return view_->OnTouchEvent(*event); } void EventForwarder::OnMouseEvent( JNIEnv* env, const base::android::JavaRef& motion_event, int64_t time_ns, int32_t android_action, int32_t android_action_button, int32_t android_tool_type) { std::unique_ptr source = MotionEventAndroidSourceJava::Create( motion_event, /*is_latest_event_time_resampled=*/false); // Construct a motion_event object minimally, only to convert the raw // parameters to ui::MotionEvent values. Since we used only the cached values // at index=0, it is okay to even pass a null event to the constructor. ui::MotionEventAndroid::Pointer pointer( source->GetPointerId(0), /*pos_x_pixels=*/source->GetXPix(0), /*pos_y_pixels=*/source->GetYPix(0), /*touch_major_pixels=*/0.0f, /*touch_minor_pixels=*/0.0f, source->GetPressure(0), source->GetRawOrientation(0), source->GetRawTilt(0), /*tool_type=*/android_tool_type); auto event = ui::MotionEventAndroidFactory::CreateFromJava( env, /*event=*/motion_event, /*pix_to_dip=*/1.f / view_->GetDipScale(), /*ticks_x=*/0.f, /*ticks_y=*/0.f, /*tick_multiplier=*/0.f, /*oldest_event_time=*/base::TimeTicks::FromJavaNanoTime(time_ns), android_action, /*pointer_count=*/1, /*history_size=*/0, /*action_index=*/0, android_action_button, /*android_gesture_classification=*/0, JNI_MotionEvent::Java_MotionEvent_getButtonState(env, motion_event), /*raw_offset_x_pixels=*/ JNI_MotionEvent::Java_MotionEvent_getRawX(env, motion_event) - source->GetXPix(0), /*raw_offset_y_pixels=*/ JNI_MotionEvent::Java_MotionEvent_getRawY(env, motion_event) - source->GetYPix(0), /*for_touch_handle=*/false, /*pointer0=*/&pointer, /*pointer1=*/nullptr); observers_.Notify(&Observer::OnMouseEvent, *event); view_->OnMouseEvent(*event); } void EventForwarder::OnDragEvent(JNIEnv* env, int32_t action, float x, float y, float screen_x, float screen_y, const JavaRef& j_mimeTypes, const JavaRef& j_content, const JavaRef& j_filenames, const JavaRef& j_text, const JavaRef& j_html, const JavaRef& j_url, const JavaRef& j_customData, const JavaRef& j_effectAllowed) { float dip_scale = view_->GetDipScale(); gfx::PointF location(x / dip_scale, y / dip_scale); gfx::PointF root_location(screen_x / dip_scale, screen_y / dip_scale); std::vector mime_types; AppendJavaStringArrayToStringVector(env, j_mimeTypes, &mime_types); DragEventAndroid event(env, action, location, root_location, mime_types, j_content, j_filenames, j_text, j_html, j_url, j_customData, j_effectAllowed); view_->OnDragEvent(event); } bool EventForwarder::OnGestureEvent(JNIEnv* env, int32_t type, int64_t time_ms, float scale) { float dip_scale = view_->GetDipScale(); auto size = view_->GetSizeDIPs(); float x = size.width() / 2; float y = size.height() / 2; gfx::PointF root_location = ScalePoint(view_->GetLocationOnScreen(x, y), 1.f / dip_scale); return view_->OnGestureEvent(GestureEventAndroid( type, gfx::PointF(x / dip_scale, y / dip_scale), root_location, time_ms, ui::GestureDeviceType::DEVICE_TOUCHSCREEN, scale, 0, 0, 0, 0, /*target_viewport*/ false, /*synthetic_scroll*/ false, /*prevent_boosting*/ false)); } bool EventForwarder::OnGenericMotionEvent(JNIEnv* env, const JavaRef& motion_event, int64_t event_time_ns, int64_t down_time_ms) { auto size = view_->GetSizeDIPs(); float x = size.width() / 2; float y = size.height() / 2; ui::MotionEventAndroid::Pointer pointer0( /*id=*/0, /*pos_x_pixels=*/x, /*pos_y_pixels=*/y, /*touch_major_pixels=*/0, /*touch_minor_pixels=*/0, /*pressure=*/0, /*orientation_rad=*/0, /*tilt_rad=*/0, /*tool_type=*/0); // Java |MotionEvent.getDownTime| returns the value in milliseconds, use // base::TimeTicks::FromUptimeMillis to get base::TimeTicks for this // milliseconds timestamp. base::TimeTicks down_time = base::TimeTicks::FromUptimeMillis(down_time_ms); auto event = ui::MotionEventAndroidFactory::CreateFromJava( env, /*event=*/motion_event, /*pix_to_dip=*/1.f / view_->GetDipScale(), /*ticks_x=*/0.f, /*ticks_y=*/0.f, /*tick_multiplier=*/0.f, /*oldest_event_time=*/base::TimeTicks::FromJavaNanoTime(event_time_ns), /*latest_event_time=*/base::TimeTicks::FromJavaNanoTime(event_time_ns), down_time, /*android_action=*/0, /*pointer_count=*/1, /*history_size=*/0, /*action_index=*/0, /*android_action_button=*/0, /*android_gesture_classification=*/0, /*android_button_state=*/0, /*raw_offset_x_pixels=*/0, /*raw_offset_y_pixels=*/0, /*for_touch_handle=*/false, /*pointer0=*/&pointer0, /*pointer1=*/nullptr, /*is_latest_event_time_resampled=*/false); observers_.Notify(&Observer::OnGenericMotionEvent, *event); return view_->OnGenericMotionEvent(*event); } void EventForwarder::OnMouseWheelEvent(JNIEnv* env, const JavaRef& motion_event, int64_t time_ns, int32_t action, float x, float y, float raw_x, float raw_y, float delta_x, float delta_y) { ui::MotionEventAndroid::Pointer pointer( /*id=*/0, x, y, /*touch_major_pixels=*/0.0f, /*touch_minor_pixels=*/0.0f, /*pressure=*/0, /*orientation_rad=*/0.0f, /*tilt_rad=*/0.0f, /*tool_type=*/0); auto* window = view_->GetWindowAndroid(); float pixels_per_tick = window ? window->mouse_wheel_scroll_factor() : ui::kDefaultMouseWheelTickMultiplier * view_->GetDipScale(); auto event = ui::MotionEventAndroidFactory::CreateFromJava( env, motion_event, /*pix_to_dip=*/1.f / view_->GetDipScale(), /*ticks_x=*/delta_x / pixels_per_tick, /*ticks_y=*/delta_y / pixels_per_tick, /*tick_multiplier=*/pixels_per_tick, /*oldest_event_time=*/base::TimeTicks::FromJavaNanoTime(time_ns), /*android_action=*/action, /*pointer_count=*/1, /*history_size=*/0, /*action_index=*/0, /*android_action_button=*/0, /*android_gesture_classification=*/0, /*android_button_state=*/0, /*raw_offset_x_pixels=*/raw_x - x, /*raw_offset_y_pixels=*/raw_y - y, /*for_touch_handle=*/false, &pointer, nullptr); view_->OnMouseWheelEvent(*event); } bool EventForwarder::OnKeyUp(JNIEnv* env, const ui::KeyEventAndroid& key_event) { return view_->OnKeyUp(key_event); } bool EventForwarder::DispatchKeyEvent(JNIEnv* env, const ui::KeyEventAndroid& key_event) { return view_->DispatchKeyEvent(key_event); } void EventForwarder::ScrollBy(JNIEnv* env, float delta_x, float delta_y) { view_->ScrollBy(delta_x, delta_y); } void EventForwarder::ScrollTo(JNIEnv* env, float x, float y) { view_->ScrollTo(x, y); } void EventForwarder::DoubleTap(JNIEnv* env, int64_t time_ms, int32_t x, int32_t y) { float dip_scale = view_->GetDipScale(); view_->OnGestureEvent(GestureEventAndroid( GESTURE_EVENT_TYPE_DOUBLE_TAP, gfx::PointF(x / dip_scale, y / dip_scale), gfx::PointF(), time_ms, ui::GestureDeviceType::DEVICE_TOUCHSCREEN, 0, 0, 0, 0, 0, /*target_viewport*/ true, /*synthetic_scroll*/ false, /*prevent_boosting*/ false)); } void EventForwarder::StartFling(JNIEnv* env, int64_t time_ms, float x, float y, float raw_x, float raw_y, float velocity_x, float velocity_y, bool synthetic_scroll, bool prevent_boosting, bool is_touchpad_event, bool target_viewport) { CancelFling(env, time_ms, prevent_boosting, is_touchpad_event); if (velocity_x == 0 && velocity_y == 0) return; float dip_scale = view_->GetDipScale(); ui::GestureDeviceType source = is_touchpad_event ? ui::GestureDeviceType::DEVICE_TOUCHPAD : ui::GestureDeviceType::DEVICE_TOUCHSCREEN; gfx::PointF location(x / dip_scale, y / dip_scale); gfx::PointF screen_location(raw_x / dip_scale, raw_y / dip_scale); // Fling start event is expected to always be following a scroll start event. // Flings from e.g. joystick start from stopped state; send a synthetic scroll // start first. This is not required by touchpad flings which happen at the // end of a scroll. if (!is_touchpad_event) { // Use velocity as delta in scroll event. view_->OnGestureEvent(GestureEventAndroid( GESTURE_EVENT_TYPE_SCROLL_START, location, screen_location, time_ms, source, 0, velocity_x / dip_scale, velocity_y / dip_scale, 0, 0, target_viewport, synthetic_scroll, /*prevent_boosting*/ false)); } view_->OnGestureEvent(GestureEventAndroid( GESTURE_EVENT_TYPE_FLING_START, location, screen_location, time_ms, source, 0, 0, 0, velocity_x / dip_scale, velocity_y / dip_scale, target_viewport, synthetic_scroll, /*prevent_boosting*/ false)); } void EventForwarder::CancelFling(JNIEnv* env, int64_t time_ms, bool prevent_boosting, bool is_touchpad_event) { ui::GestureDeviceType source = is_touchpad_event ? ui::GestureDeviceType::DEVICE_TOUCHPAD : ui::GestureDeviceType::DEVICE_TOUCHSCREEN; view_->OnGestureEvent(GestureEventAndroid( GESTURE_EVENT_TYPE_FLING_CANCEL, gfx::PointF(), gfx::PointF(), time_ms, source, 0, 0, 0, 0, 0, /*target_viewport*/ false, /*synthetic_scroll*/ false, prevent_boosting)); } void EventForwarder::AddObserver(Observer* observer) { observers_.AddObserver(observer); } void EventForwarder::RemoveObserver(Observer* observer) { observers_.RemoveObserver(observer); } gfx::PointF EventForwarder::GetCurrentTouchSequenceOffset() { JNIEnv* env = jni_zero::AttachCurrentThread(); auto java_obj = GetJavaObject(env); CHECK(!java_obj.is_null()); return gfx::PointF( Java_EventForwarder_getWebContentsOffsetXInWindow(env, java_obj), Java_EventForwarder_getWebContentsOffsetYInWindow(env, java_obj)); } } // namespace ui DEFINE_JNI(EventForwarder)