view_android.cc 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739
  1. // Copyright 2016 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/view_android.h"
  5. #include <algorithm>
  6. #include <cmath>
  7. #include <utility>
  8. #include "base/android/jni_android.h"
  9. #include "base/android/jni_string.h"
  10. #include "base/containers/adapters.h"
  11. #include "base/containers/contains.h"
  12. #include "cc/layers/layer.h"
  13. #include "components/viz/common/frame_sinks/copy_output_request.h"
  14. #include "third_party/skia/include/core/SkBitmap.h"
  15. #include "ui/android/event_forwarder.h"
  16. #include "ui/android/ui_android_jni_headers/ViewAndroidDelegate_jni.h"
  17. #include "ui/android/window_android.h"
  18. #include "ui/base/cursor/cursor.h"
  19. #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
  20. #include "ui/base/layout.h"
  21. #include "ui/events/android/drag_event_android.h"
  22. #include "ui/events/android/event_handler_android.h"
  23. #include "ui/events/android/gesture_event_android.h"
  24. #include "ui/events/android/key_event_android.h"
  25. #include "ui/events/android/motion_event_android.h"
  26. #include "ui/gfx/android/java_bitmap.h"
  27. #include "ui/gfx/geometry/point.h"
  28. #include "url/gurl.h"
  29. namespace ui {
  30. using base::android::ConvertUTF8ToJavaString;
  31. using base::android::JavaRef;
  32. using base::android::ScopedJavaLocalRef;
  33. ViewAndroid::ScopedAnchorView::ScopedAnchorView(
  34. JNIEnv* env,
  35. const JavaRef<jobject>& jview,
  36. const JavaRef<jobject>& jdelegate)
  37. : view_(env, jview.obj()), delegate_(env, jdelegate.obj()) {
  38. // If there's a view, then we need a delegate to remove it.
  39. DCHECK(!jdelegate.is_null() || jview.is_null());
  40. }
  41. ViewAndroid::ScopedAnchorView::ScopedAnchorView() { }
  42. ViewAndroid::ScopedAnchorView::ScopedAnchorView(ScopedAnchorView&& other) {
  43. view_ = other.view_;
  44. other.view_.reset();
  45. delegate_ = other.delegate_;
  46. other.delegate_.reset();
  47. }
  48. ViewAndroid::ScopedAnchorView&
  49. ViewAndroid::ScopedAnchorView::operator=(ScopedAnchorView&& other) {
  50. if (this != &other) {
  51. view_ = other.view_;
  52. other.view_.reset();
  53. delegate_ = other.delegate_;
  54. other.delegate_.reset();
  55. }
  56. return *this;
  57. }
  58. ViewAndroid::ScopedAnchorView::~ScopedAnchorView() {
  59. Reset();
  60. }
  61. void ViewAndroid::ScopedAnchorView::Reset() {
  62. JNIEnv* env = base::android::AttachCurrentThread();
  63. const ScopedJavaLocalRef<jobject> view = view_.get(env);
  64. const ScopedJavaLocalRef<jobject> delegate = delegate_.get(env);
  65. if (!view.is_null() && !delegate.is_null()) {
  66. Java_ViewAndroidDelegate_removeView(env, delegate, view);
  67. }
  68. view_.reset();
  69. delegate_.reset();
  70. }
  71. const base::android::ScopedJavaLocalRef<jobject>
  72. ViewAndroid::ScopedAnchorView::view() const {
  73. JNIEnv* env = base::android::AttachCurrentThread();
  74. return view_.get(env);
  75. }
  76. ViewAndroid::ViewAndroid(LayoutType layout_type)
  77. : parent_(nullptr), layout_type_(layout_type) {}
  78. ViewAndroid::ViewAndroid() : ViewAndroid(LayoutType::NORMAL) {}
  79. ViewAndroid::~ViewAndroid() {
  80. RemoveAllChildren(GetWindowAndroid() != nullptr);
  81. for (auto& observer : observer_list_)
  82. observer.OnViewAndroidDestroyed();
  83. observer_list_.Clear();
  84. RemoveFromParent();
  85. }
  86. void ViewAndroid::SetDelegate(const JavaRef<jobject>& delegate) {
  87. // A ViewAndroid may have its own delegate or otherwise will use the next
  88. // available parent's delegate.
  89. JNIEnv* env = base::android::AttachCurrentThread();
  90. delegate_ = JavaObjectWeakGlobalRef(env, delegate);
  91. }
  92. void ViewAndroid::UpdateFrameInfo(const FrameInfo& frame_info) {
  93. frame_info_ = frame_info;
  94. }
  95. float ViewAndroid::GetDipScale() {
  96. return ui::GetScaleFactorForNativeView(this);
  97. }
  98. absl::optional<gfx::Rect> ViewAndroid::GetDisplayFeature() {
  99. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  100. if (delegate.is_null())
  101. return absl::nullopt;
  102. JNIEnv* env = base::android::AttachCurrentThread();
  103. base::android::ScopedJavaLocalRef<jintArray> jni_display_feature =
  104. Java_ViewAndroidDelegate_getDisplayFeature(env, delegate);
  105. std::vector<int> display_feature_values;
  106. if (jni_display_feature.obj()) {
  107. // In order to reduce jni overhead, the DisplayFeature is returned in
  108. // an integer array. This array must have 4 items in it (or the return
  109. // value should be null).
  110. base::android::JavaIntArrayToIntVector(env, jni_display_feature,
  111. &display_feature_values);
  112. CHECK(display_feature_values.size() == 4);
  113. gfx::Rect display_feature;
  114. display_feature.SetByBounds(
  115. display_feature_values[0], display_feature_values[1],
  116. display_feature_values[2], display_feature_values[3]);
  117. return display_feature;
  118. }
  119. return absl::nullopt;
  120. }
  121. ScopedJavaLocalRef<jobject> ViewAndroid::GetEventForwarder() {
  122. if (!event_forwarder_) {
  123. DCHECK(!RootPathHasEventForwarder(parent_))
  124. << "The view tree path already has an event forwarder.";
  125. DCHECK(!SubtreeHasEventForwarder(this))
  126. << "The view tree path already has an event forwarder.";
  127. event_forwarder_.reset(new EventForwarder(this));
  128. }
  129. return event_forwarder_->GetJavaObject();
  130. }
  131. void ViewAndroid::AddChild(ViewAndroid* child) {
  132. DCHECK(child);
  133. DCHECK(!base::Contains(children_, child));
  134. DCHECK(!RootPathHasEventForwarder(this) || !SubtreeHasEventForwarder(child))
  135. << "Some view tree path will have more than one event forwarder "
  136. "if the child is added.";
  137. // The new child goes to the top, which is the end of the list.
  138. children_.push_back(child);
  139. if (child->parent_)
  140. child->RemoveFromParent();
  141. child->parent_ = this;
  142. // Empty physical backing size need not propagating down since it can
  143. // accidentally overwrite the valid ones in the children.
  144. if (!physical_size_.IsEmpty())
  145. child->OnPhysicalBackingSizeChanged(physical_size_);
  146. child->OnControlsResizeViewChanged(controls_resize_view_);
  147. // Empty view size also need not propagating down in order to prevent
  148. // spurious events with empty size from being sent down.
  149. if (child->match_parent() && !bounds_.IsEmpty() &&
  150. child->GetSize() != bounds_.size()) {
  151. child->OnSizeChangedInternal(bounds_.size());
  152. child->DispatchOnSizeChanged();
  153. }
  154. if (GetWindowAndroid())
  155. child->OnAttachedToWindow();
  156. }
  157. // static
  158. bool ViewAndroid::RootPathHasEventForwarder(ViewAndroid* view) {
  159. while (view) {
  160. if (view->has_event_forwarder())
  161. return true;
  162. view = view->parent_;
  163. }
  164. return false;
  165. }
  166. // static
  167. bool ViewAndroid::SubtreeHasEventForwarder(ViewAndroid* view) {
  168. if (view->has_event_forwarder())
  169. return true;
  170. for (auto* child : view->children_) {
  171. if (SubtreeHasEventForwarder(child))
  172. return true;
  173. }
  174. return false;
  175. }
  176. void ViewAndroid::MoveToFront(ViewAndroid* child) {
  177. DCHECK(child);
  178. auto it = std::find(children_.begin(), children_.end(), child);
  179. DCHECK(it != children_.end());
  180. // Top element is placed at the end of the list.
  181. if (*it != children_.back())
  182. children_.splice(children_.end(), children_, it);
  183. }
  184. void ViewAndroid::MoveToBack(ViewAndroid* child) {
  185. DCHECK(child);
  186. auto it = std::find(children_.begin(), children_.end(), child);
  187. DCHECK(it != children_.end());
  188. // Bottom element is placed at the beginning of the list.
  189. if (*it != children_.front())
  190. children_.splice(children_.begin(), children_, it);
  191. }
  192. void ViewAndroid::RemoveFromParent() {
  193. if (parent_)
  194. parent_->RemoveChild(this);
  195. }
  196. ViewAndroid::ScopedAnchorView ViewAndroid::AcquireAnchorView() {
  197. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  198. if (delegate.is_null())
  199. return ViewAndroid::ScopedAnchorView();
  200. JNIEnv* env = base::android::AttachCurrentThread();
  201. return ViewAndroid::ScopedAnchorView(
  202. env, Java_ViewAndroidDelegate_acquireView(env, delegate), delegate);
  203. }
  204. void ViewAndroid::SetAnchorRect(const JavaRef<jobject>& anchor,
  205. const gfx::RectF& bounds_dip) {
  206. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  207. if (delegate.is_null())
  208. return;
  209. float dip_scale = GetDipScale();
  210. int left_margin = std::round(bounds_dip.x() * dip_scale);
  211. // Note that content_offset() is in CSS scale and bounds_dip is in DIP scale
  212. // (i.e., CSS pixels * page scale factor), but the height of browser control
  213. // is not affected by page scale factor. Thus, content_offset() in CSS scale
  214. // is also in DIP scale.
  215. int top_margin = std::round((content_offset() + bounds_dip.y()) * dip_scale);
  216. const gfx::RectF bounds_px = gfx::ScaleRect(bounds_dip, dip_scale);
  217. JNIEnv* env = base::android::AttachCurrentThread();
  218. Java_ViewAndroidDelegate_setViewPosition(
  219. env, delegate, anchor, bounds_px.x(), bounds_px.y(), bounds_px.width(),
  220. bounds_px.height(), left_margin, top_margin);
  221. }
  222. ScopedJavaLocalRef<jobject> ViewAndroid::GetContainerView() {
  223. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  224. if (delegate.is_null())
  225. return nullptr;
  226. JNIEnv* env = base::android::AttachCurrentThread();
  227. return Java_ViewAndroidDelegate_getContainerView(env, delegate);
  228. }
  229. gfx::Point ViewAndroid::GetLocationOfContainerViewInWindow() {
  230. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  231. if (delegate.is_null())
  232. return gfx::Point();
  233. JNIEnv* env = base::android::AttachCurrentThread();
  234. gfx::Point result(
  235. Java_ViewAndroidDelegate_getXLocationOfContainerViewInWindow(env,
  236. delegate),
  237. Java_ViewAndroidDelegate_getYLocationOfContainerViewInWindow(env,
  238. delegate));
  239. return result;
  240. }
  241. gfx::PointF ViewAndroid::GetLocationOnScreen(float x, float y) {
  242. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  243. if (delegate.is_null())
  244. return gfx::PointF();
  245. JNIEnv* env = base::android::AttachCurrentThread();
  246. float loc_x = Java_ViewAndroidDelegate_getXLocationOnScreen(env, delegate);
  247. float loc_y = Java_ViewAndroidDelegate_getYLocationOnScreen(env, delegate);
  248. return gfx::PointF(x + loc_x, y + loc_y);
  249. }
  250. void ViewAndroid::RemoveAllChildren(bool attached_to_window) {
  251. auto it = children_.begin();
  252. while (it != children_.end()) {
  253. if (attached_to_window)
  254. (*it)->OnDetachedFromWindow();
  255. (*it)->parent_ = nullptr;
  256. // erase returns a new iterator for the element following the ereased one.
  257. it = children_.erase(it);
  258. }
  259. }
  260. void ViewAndroid::RemoveChild(ViewAndroid* child) {
  261. DCHECK(child);
  262. DCHECK_EQ(child->parent_, this);
  263. if (GetWindowAndroid())
  264. child->OnDetachedFromWindow();
  265. std::list<ViewAndroid*>::iterator it =
  266. std::find(children_.begin(), children_.end(), child);
  267. DCHECK(it != children_.end());
  268. children_.erase(it);
  269. child->parent_ = nullptr;
  270. }
  271. void ViewAndroid::AddObserver(ViewAndroidObserver* observer) {
  272. observer_list_.AddObserver(observer);
  273. }
  274. void ViewAndroid::RemoveObserver(ViewAndroidObserver* observer) {
  275. observer_list_.RemoveObserver(observer);
  276. }
  277. void ViewAndroid::RequestDisallowInterceptTouchEvent() {
  278. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  279. if (delegate.is_null())
  280. return;
  281. JNIEnv* env = base::android::AttachCurrentThread();
  282. Java_ViewAndroidDelegate_requestDisallowInterceptTouchEvent(env, delegate);
  283. }
  284. void ViewAndroid::RequestUnbufferedDispatch(const MotionEventAndroid& event) {
  285. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  286. if (delegate.is_null())
  287. return;
  288. JNIEnv* env = base::android::AttachCurrentThread();
  289. Java_ViewAndroidDelegate_requestUnbufferedDispatch(env, delegate,
  290. event.GetJavaObject());
  291. }
  292. void ViewAndroid::SetCopyOutputCallback(CopyViewCallback callback) {
  293. copy_view_callback_ = std::move(callback);
  294. }
  295. // If view does not support copy request, return back the request.
  296. std::unique_ptr<viz::CopyOutputRequest> ViewAndroid::MaybeRequestCopyOfView(
  297. std::unique_ptr<viz::CopyOutputRequest> request) {
  298. if (copy_view_callback_.is_null())
  299. return request;
  300. copy_view_callback_.Run(std::move(request));
  301. return nullptr;
  302. }
  303. void ViewAndroid::OnAttachedToWindow() {
  304. for (auto& observer : observer_list_)
  305. observer.OnAttachedToWindow();
  306. for (auto* child : children_)
  307. child->OnAttachedToWindow();
  308. }
  309. void ViewAndroid::OnDetachedFromWindow() {
  310. for (auto& observer : observer_list_)
  311. observer.OnDetachedFromWindow();
  312. for (auto* child : children_)
  313. child->OnDetachedFromWindow();
  314. }
  315. WindowAndroid* ViewAndroid::GetWindowAndroid() const {
  316. return parent_ ? parent_->GetWindowAndroid() : nullptr;
  317. }
  318. const ScopedJavaLocalRef<jobject> ViewAndroid::GetViewAndroidDelegate()
  319. const {
  320. JNIEnv* env = base::android::AttachCurrentThread();
  321. const ScopedJavaLocalRef<jobject> delegate = delegate_.get(env);
  322. if (!delegate.is_null())
  323. return delegate;
  324. return parent_ ? parent_->GetViewAndroidDelegate() : delegate;
  325. }
  326. cc::Layer* ViewAndroid::GetLayer() const {
  327. return layer_.get();
  328. }
  329. bool ViewAndroid::HasFocus() {
  330. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  331. if (delegate.is_null())
  332. return false;
  333. JNIEnv* env = base::android::AttachCurrentThread();
  334. return Java_ViewAndroidDelegate_hasFocus(env, delegate);
  335. }
  336. void ViewAndroid::RequestFocus() {
  337. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  338. if (delegate.is_null())
  339. return;
  340. JNIEnv* env = base::android::AttachCurrentThread();
  341. Java_ViewAndroidDelegate_requestFocus(env, delegate);
  342. }
  343. void ViewAndroid::SetLayer(scoped_refptr<cc::Layer> layer) {
  344. layer_ = layer;
  345. }
  346. bool ViewAndroid::StartDragAndDrop(const JavaRef<jobject>& jshadow_image,
  347. const JavaRef<jobject>& jdrop_data) {
  348. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  349. if (delegate.is_null())
  350. return false;
  351. JNIEnv* env = base::android::AttachCurrentThread();
  352. return Java_ViewAndroidDelegate_startDragAndDrop(env, delegate, jshadow_image,
  353. jdrop_data);
  354. }
  355. void ViewAndroid::OnCursorChanged(const Cursor& cursor) {
  356. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  357. if (delegate.is_null())
  358. return;
  359. JNIEnv* env = base::android::AttachCurrentThread();
  360. if (cursor.type() == mojom::CursorType::kCustom) {
  361. const SkBitmap& bitmap = cursor.custom_bitmap();
  362. const gfx::Point& hotspot = cursor.custom_hotspot();
  363. if (bitmap.drawsNothing()) {
  364. Java_ViewAndroidDelegate_onCursorChanged(
  365. env, delegate, static_cast<int>(mojom::CursorType::kPointer));
  366. return;
  367. }
  368. ScopedJavaLocalRef<jobject> java_bitmap = gfx::ConvertToJavaBitmap(bitmap);
  369. Java_ViewAndroidDelegate_onCursorChangedToCustom(env, delegate, java_bitmap,
  370. hotspot.x(), hotspot.y());
  371. } else {
  372. Java_ViewAndroidDelegate_onCursorChanged(env, delegate,
  373. static_cast<int>(cursor.type()));
  374. }
  375. }
  376. void ViewAndroid::SetHoverActionStylusWritable(bool stylus_writable) {
  377. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  378. if (delegate.is_null())
  379. return;
  380. JNIEnv* env = base::android::AttachCurrentThread();
  381. Java_ViewAndroidDelegate_setHoverActionStylusWritable(env, delegate,
  382. stylus_writable);
  383. }
  384. void ViewAndroid::OnBackgroundColorChanged(unsigned int color) {
  385. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  386. if (delegate.is_null())
  387. return;
  388. JNIEnv* env = base::android::AttachCurrentThread();
  389. Java_ViewAndroidDelegate_onBackgroundColorChanged(env, delegate, color);
  390. }
  391. void ViewAndroid::OnTopControlsChanged(float top_controls_offset,
  392. float top_content_offset,
  393. float top_controls_min_height_offset) {
  394. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  395. if (delegate.is_null())
  396. return;
  397. JNIEnv* env = base::android::AttachCurrentThread();
  398. Java_ViewAndroidDelegate_onTopControlsChanged(
  399. env, delegate, std::round(top_controls_offset),
  400. std::round(top_content_offset),
  401. std::round(top_controls_min_height_offset));
  402. }
  403. void ViewAndroid::OnBottomControlsChanged(
  404. float bottom_controls_offset,
  405. float bottom_controls_min_height_offset) {
  406. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  407. if (delegate.is_null())
  408. return;
  409. JNIEnv* env = base::android::AttachCurrentThread();
  410. Java_ViewAndroidDelegate_onBottomControlsChanged(
  411. env, delegate, std::round(bottom_controls_offset),
  412. std::round(bottom_controls_min_height_offset));
  413. }
  414. int ViewAndroid::GetViewportInsetBottom() {
  415. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  416. if (delegate.is_null())
  417. return 0;
  418. JNIEnv* env = base::android::AttachCurrentThread();
  419. return Java_ViewAndroidDelegate_getViewportInsetBottom(env, delegate);
  420. }
  421. void ViewAndroid::OnBrowserControlsHeightChanged() {
  422. if (event_handler_)
  423. event_handler_->OnBrowserControlsHeightChanged();
  424. for (auto* child : children_) {
  425. if (child->match_parent())
  426. child->OnBrowserControlsHeightChanged();
  427. }
  428. }
  429. void ViewAndroid::OnVerticalScrollDirectionChanged(bool direction_up,
  430. float current_scroll_ratio) {
  431. ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
  432. if (delegate.is_null())
  433. return;
  434. JNIEnv* env = base::android::AttachCurrentThread();
  435. Java_ViewAndroidDelegate_onVerticalScrollDirectionChanged(
  436. env, delegate, direction_up, current_scroll_ratio);
  437. }
  438. void ViewAndroid::OnSizeChanged(int width, int height) {
  439. // Match-parent view must not receive size events.
  440. DCHECK(!match_parent());
  441. float scale = GetDipScale();
  442. gfx::Size size(std::ceil(width / scale), std::ceil(height / scale));
  443. if (bounds_.size() == size)
  444. return;
  445. OnSizeChangedInternal(size);
  446. // Signal resize event after all the views in the tree get the updated size.
  447. DispatchOnSizeChanged();
  448. }
  449. void ViewAndroid::OnSizeChangedInternal(const gfx::Size& size) {
  450. if (bounds_.size() == size)
  451. return;
  452. bounds_.set_size(size);
  453. for (auto* child : children_) {
  454. if (child->match_parent())
  455. child->OnSizeChangedInternal(size);
  456. }
  457. }
  458. void ViewAndroid::DispatchOnSizeChanged() {
  459. if (event_handler_)
  460. event_handler_->OnSizeChanged();
  461. for (auto* child : children_) {
  462. if (child->match_parent())
  463. child->DispatchOnSizeChanged();
  464. }
  465. }
  466. void ViewAndroid::OnPhysicalBackingSizeChanged(
  467. const gfx::Size& size,
  468. absl::optional<base::TimeDelta> deadline_override) {
  469. if (physical_size_ == size)
  470. return;
  471. physical_size_ = size;
  472. if (event_handler_)
  473. event_handler_->OnPhysicalBackingSizeChanged(deadline_override);
  474. for (auto* child : children_)
  475. child->OnPhysicalBackingSizeChanged(size, deadline_override);
  476. }
  477. void ViewAndroid::OnControlsResizeViewChanged(bool controls_resize_view) {
  478. if (controls_resize_view == controls_resize_view_)
  479. return;
  480. controls_resize_view_ = controls_resize_view;
  481. if (event_handler_)
  482. event_handler_->OnControlsResizeViewChanged();
  483. for (auto* child : children_)
  484. child->OnControlsResizeViewChanged(controls_resize_view);
  485. }
  486. gfx::Size ViewAndroid::GetPhysicalBackingSize() const {
  487. return physical_size_;
  488. }
  489. gfx::Size ViewAndroid::GetSize() const {
  490. return bounds_.size();
  491. }
  492. bool ViewAndroid::OnDragEvent(const DragEventAndroid& event) {
  493. return HitTest(base::BindRepeating(&ViewAndroid::SendDragEventToHandler),
  494. event, event.location());
  495. }
  496. // static
  497. bool ViewAndroid::SendDragEventToHandler(EventHandlerAndroid* handler,
  498. const DragEventAndroid& event) {
  499. return handler->OnDragEvent(event);
  500. }
  501. bool ViewAndroid::OnTouchEvent(const MotionEventAndroid& event) {
  502. return HitTest(base::BindRepeating(&ViewAndroid::SendTouchEventToHandler),
  503. event, event.GetPoint());
  504. }
  505. // static
  506. bool ViewAndroid::SendTouchEventToHandler(EventHandlerAndroid* handler,
  507. const MotionEventAndroid& event) {
  508. return handler->OnTouchEvent(event);
  509. }
  510. bool ViewAndroid::OnMouseEvent(const MotionEventAndroid& event) {
  511. return HitTest(base::BindRepeating(&ViewAndroid::SendMouseEventToHandler),
  512. event, event.GetPoint());
  513. }
  514. // static
  515. bool ViewAndroid::SendMouseEventToHandler(EventHandlerAndroid* handler,
  516. const MotionEventAndroid& event) {
  517. return handler->OnMouseEvent(event);
  518. }
  519. bool ViewAndroid::OnMouseWheelEvent(const MotionEventAndroid& event) {
  520. return HitTest(
  521. base::BindRepeating(&ViewAndroid::SendMouseWheelEventToHandler), event,
  522. event.GetPoint());
  523. }
  524. // static
  525. bool ViewAndroid::SendMouseWheelEventToHandler(
  526. EventHandlerAndroid* handler,
  527. const MotionEventAndroid& event) {
  528. return handler->OnMouseWheelEvent(event);
  529. }
  530. bool ViewAndroid::OnGestureEvent(const GestureEventAndroid& event) {
  531. return HitTest(base::BindRepeating(&ViewAndroid::SendGestureEventToHandler),
  532. event, event.location());
  533. }
  534. // static
  535. bool ViewAndroid::SendGestureEventToHandler(EventHandlerAndroid* handler,
  536. const GestureEventAndroid& event) {
  537. return handler->OnGestureEvent(event);
  538. }
  539. bool ViewAndroid::OnGenericMotionEvent(const MotionEventAndroid& event) {
  540. if (event_handler_ && event_handler_->OnGenericMotionEvent(event))
  541. return true;
  542. for (auto* child : children_) {
  543. if (child->OnGenericMotionEvent(event))
  544. return true;
  545. }
  546. return false;
  547. }
  548. bool ViewAndroid::OnKeyUp(const KeyEventAndroid& event) {
  549. if (event_handler_ && event_handler_->OnKeyUp(event))
  550. return true;
  551. for (auto* child : children_) {
  552. if (child->OnKeyUp(event))
  553. return true;
  554. }
  555. return false;
  556. }
  557. bool ViewAndroid::DispatchKeyEvent(const KeyEventAndroid& event) {
  558. if (event_handler_ && event_handler_->DispatchKeyEvent(event))
  559. return true;
  560. for (auto* child : children_) {
  561. if (child->DispatchKeyEvent(event))
  562. return true;
  563. }
  564. return false;
  565. }
  566. bool ViewAndroid::ScrollBy(float delta_x, float delta_y) {
  567. if (event_handler_ && event_handler_->ScrollBy(delta_x, delta_y))
  568. return true;
  569. for (auto* child : children_) {
  570. if (child->ScrollBy(delta_x, delta_y))
  571. return true;
  572. }
  573. return false;
  574. }
  575. bool ViewAndroid::ScrollTo(float x, float y) {
  576. if (event_handler_ && event_handler_->ScrollTo(x, y))
  577. return true;
  578. for (auto* child : children_) {
  579. if (child->ScrollTo(x, y))
  580. return true;
  581. }
  582. return false;
  583. }
  584. void ViewAndroid::NotifyVirtualKeyboardOverlayRect(
  585. const gfx::Rect& keyboard_rect) {
  586. if (event_handler_)
  587. event_handler_->NotifyVirtualKeyboardOverlayRect(keyboard_rect);
  588. for (auto* child : children_) {
  589. child->NotifyVirtualKeyboardOverlayRect(keyboard_rect);
  590. }
  591. }
  592. template <typename E>
  593. bool ViewAndroid::HitTest(EventHandlerCallback<E> handler_callback,
  594. const E& event,
  595. const gfx::PointF& point) {
  596. if (event_handler_) {
  597. if (bounds_.origin().IsOrigin()) { // (x, y) == (0, 0)
  598. if (handler_callback.Run(event_handler_.get(), event))
  599. return true;
  600. } else {
  601. std::unique_ptr<E> e(event.CreateFor(point));
  602. if (handler_callback.Run(event_handler_.get(), *e))
  603. return true;
  604. }
  605. }
  606. if (!children_.empty()) {
  607. gfx::PointF offset_point(point);
  608. offset_point.Offset(-bounds_.x(), -bounds_.y());
  609. gfx::Point int_point = gfx::ToFlooredPoint(offset_point);
  610. // Match from back to front for hit testing.
  611. for (auto* child : base::Reversed(children_)) {
  612. bool matched = child->match_parent();
  613. if (!matched)
  614. matched = child->bounds_.Contains(int_point);
  615. if (matched && child->HitTest(handler_callback, event, offset_point))
  616. return true;
  617. }
  618. }
  619. return false;
  620. }
  621. void ViewAndroid::SetLayoutForTesting(int x, int y, int width, int height) {
  622. bounds_.SetRect(x, y, width, height);
  623. }
  624. } // namespace ui