arc: Custom notification improvements

ui/arc/notification/arc_custom_notification_view.cc

 // Copyright 2016 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 "ui/arc/notification/arc_custom_notification_view.h"
 
 #include "components/exo/notification_surface.h"
 #include "components/exo/surface.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/compositor/layer_animation_observer.h"
+#include "ui/display/screen.h"
+#include "ui/events/event_handler.h"
+#include "ui/gfx/transform.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/core/window_util.h"
 
 namespace arc {
 
+class ArcCustomNotificationView::EventForwarder : public ui::EventHandler {
+ public:
+  explicit EventForwarder(ArcCustomNotificationView* owner) : owner_(owner) {}
+  ~EventForwarder() override = default;
+
+ private:
+  // ui::EventHandler
+  void OnKeyEvent(ui::KeyEvent* event) override { owner_->OnKeyEvent(event); }
+  void OnMouseEvent(ui::MouseEvent* event) override {
+    owner_->OnMouseEvent(event);
+  }
+  void OnGestureEvent(ui::GestureEvent* event) override {
+    owner_->OnGestureEvent(event);
+  }

[sadrul, 2016/08/10 03:26:39]

Do you only care about these events, or do you want to override just
OnEvent(ui::Event*) instead?

[xiyuan, 2016/08/10 16:28:07]

OnEvent makes more sense. Replace individual handlers with OnEvent.

+
+  ArcCustomNotificationView* const owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventForwarder);
+};
+
+class ArcCustomNotificationView::SlideHelper
+    : public ui::LayerAnimationObserver {
+ public:
+  SlideHelper(ArcCustomNotificationView* owner) : owner_(owner) {

[sadrul, 2016/08/10 03:26:39]

explicit

[xiyuan, 2016/08/10 16:28:07]

Done.

+    owner_->parent()->layer()->GetAnimator()->AddObserver(this);
+
+    // Reset opacity to 1 to handle to case when the surface is sliding before
+    // getting managed by this class, e.g. sliding in a popup before showing
+    // in a message center view.
+    if (owner_->surface_ && owner_->surface_->window())
+      owner_->surface_->window()->layer()->SetOpacity(1.0f);
+  }
+  ~SlideHelper() override {
+    owner_->parent()->layer()->GetAnimator()->RemoveObserver(this);
+  }
+
+  void Update() {
+    const bool has_animation =
+        owner_->parent()->layer()->GetAnimator()->is_animating();
+    const bool has_transform = !owner_->parent()->GetTransform().IsIdentity();
+    const bool sliding = has_transform || has_animation;
+    if (sliding_ == sliding)
+      return;
+
+    sliding_ = sliding;
+
+    if (sliding_)
+      OnSlideStart();
+    else
+      OnSlideEnd();
+  }
+
+ private:
+  void OnSlideStart() {
+    if (!owner_->surface_ || !owner_->surface_->window())
+      return;
+    surface_copy_ = ::wm::RecreateLayers(owner_->surface_->window(), nullptr);
+    owner_->layer()->Add(surface_copy_->root());
+    owner_->surface_->window()->layer()->SetOpacity(0.0f);
+  }
+
+  void OnSlideEnd() {
+    if (!owner_->surface_ || !owner_->surface_->window())
+      return;
+    owner_->surface_->window()->layer()->SetOpacity(1.0f);
+    owner_->Layout();
+    surface_copy_.reset();
+  }
+
+  // ui::LayerAnimationObserver
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) override {
+    Update();
+  }
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* seq) override {
+    Update();
+  }
+  void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq) override {}
+
+  ArcCustomNotificationView* const owner_;
+  bool sliding_ = false;
+  std::unique_ptr<ui::LayerTreeOwner> surface_copy_;
+
+  DISALLOW_COPY_AND_ASSIGN(SlideHelper);
+};
+
 ArcCustomNotificationView::ArcCustomNotificationView(
     ArcCustomNotificationItem* item,
     exo::NotificationSurface* surface)
-    : item_(item), surface_(surface) {
+    : item_(item), event_forwarder_(new EventForwarder(this)) {
+  SetSurface(surface);
   item_->AddObserver(this);
   OnItemPinnedChanged();
-  surface_->window()->AddObserver(this);
+
+  // Create a layer as an anchor to insert surface copy during a slide.
+  SetPaintToLayer(true);
 }
 
 ArcCustomNotificationView::~ArcCustomNotificationView() {
+  SetSurface(nullptr);
   if (item_)
     item_->RemoveObserver(this);
-  if (surface_ && surface_->window())
-    surface_->window()->RemoveObserver(this);
 }
 
 void ArcCustomNotificationView::CreateFloatingCloseButton() {
   floating_close_button_ = new views::ImageButton(this);
   floating_close_button_->set_background(
       views::Background::CreateSolidBackground(SK_ColorTRANSPARENT));
   floating_close_button_->SetBorder(
       views::Border::CreateEmptyBorder(5, 5, 5, 5));
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
@@ skipping 11 matching lines @@
         IDS_MESSAGE_CENTER_CLOSE_NOTIFICATION_BUTTON_ACCESSIBLE_NAME));
 
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = surface_->window();
 
   floating_close_button_widget_.reset(new views::Widget);
   floating_close_button_widget_->Init(params);
   floating_close_button_widget_->SetContentsView(floating_close_button_);
-  floating_close_button_widget_->Show();
 
   Layout();
 }
 
+void ArcCustomNotificationView::SetSurface(exo::NotificationSurface* surface) {
+  if (surface_ == surface)
+    return;
+
+  if (surface_ && surface_->window()) {
+    surface_->window()->RemoveObserver(this);
+    surface_->window()->RemovePreTargetHandler(event_forwarder_.get());
+  }
+
+  surface_ = surface;
+
+  if (surface_ && surface_->window()) {
+    surface_->window()->AddObserver(this);
+    surface_->window()->AddPreTargetHandler(event_forwarder_.get());

[sadrul, 2016/08/10 03:26:39]

Can you clarify why we need a pre-target handler for this? For example, could
you set |this| as the surface_->window()'s target_handler instead (without
needing |event_forwarder_|)?

[xiyuan, 2016/08/10 16:28:07]

This is because |surface_| has children aura::Windows and we want to take over
events dispatched to them as well. The surface is mapped from an Android window
that hosts the notification UI. Each layer of that Android window is mapped to
an exo::Surface and that exo::Surface's aura::Window is added as a child to the
surface's window. We want to pre handle the events on those child windows as
well. The exo::Surface is on the way to get rid of aura::Window and just be a
Layer. But before that, we have to use a pre-target handler.

Added a comment for |event_forwarder_| in header to document this.

+  }
+}
+
 void ArcCustomNotificationView::UpdatePreferredSize() {
   gfx::Size preferred_size = surface_->GetSize();
   if (preferred_size.width() != message_center::kNotificationWidth) {
     const float scale = static_cast<float>(message_center::kNotificationWidth) /
                         preferred_size.width();
     preferred_size.SetSize(message_center::kNotificationWidth,
                            preferred_size.height() * scale);
   }
 
   SetPreferredSize(preferred_size);
 }
 
+void ArcCustomNotificationView::UpdateCloseButtonVisiblity() {
+  if (!surface_ || !floating_close_button_widget_)
+    return;
+
+  const bool target_visiblity =
+      surface_->window()->GetBoundsInScreen().Contains(
+          display::Screen::GetScreen()->GetCursorScreenPoint());
+  if (target_visiblity == floating_close_button_widget_->IsVisible())
+    return;
+
+  if (target_visiblity)
+    floating_close_button_widget_->Show();
+  else
+    floating_close_button_widget_->Hide();
+}

[sadrul, 2016/08/10 03:26:39]

Consider using views::MouseWatcher (with MouseWatcherViewHost) instead to detect
when to hide/show the close button.

[xiyuan, 2016/08/10 16:28:07]

Contains() is needed for determining the visibility on close button creation. We
don't save that with MouseWatcher. Mouse enter/exit detection is provided by
aura::Window's mouse event (OnMouseEntered/Exited). Think the current impl is
simpler and more straightforward.

+
 void ArcCustomNotificationView::ViewHierarchyChanged(
     const views::View::ViewHierarchyChangedDetails& details) {
   views::Widget* widget = GetWidget();
 
+  if (!details.is_add) {
+    // Resets slide helper when this view is removed from its parent.
+    slide_helper_.reset();
+  }
+
   // Bail if native_view() has attached to a different widget.
   if (widget && native_view() &&
       views::Widget::GetTopLevelWidgetForNativeView(native_view()) != widget) {
     return;
   }
 
   views::NativeViewHost::ViewHierarchyChanged(details);
 
   if (!widget || !surface_ || !details.is_add)
     return;
 
   UpdatePreferredSize();
   Attach(surface_->window());
+
+  // Creates slide helper after this view is added to its parent.
+  slide_helper_.reset(new SlideHelper(this));
 }
 
 void ArcCustomNotificationView::Layout() {
   views::NativeViewHost::Layout();
 
   if (!surface_ || !GetWidget())
     return;
 
   // Scale notification surface if necessary.
   gfx::Transform transform;
   const gfx::Size surface_size = surface_->GetSize();
   const gfx::Size contents_size = GetContentsBounds().size();
   if (!surface_size.IsEmpty() && !contents_size.IsEmpty()) {
     transform.Scale(
         static_cast<float>(contents_size.width()) / surface_size.width(),
         static_cast<float>(contents_size.height()) / surface_size.height());
   }
   surface_->window()->SetTransform(transform);
 
   if (!floating_close_button_widget_)
     return;
 
   gfx::Rect surface_local_bounds(surface_->GetSize());
   gfx::Rect close_button_bounds(floating_close_button_->GetPreferredSize());
   close_button_bounds.set_x(surface_local_bounds.right() -
                             close_button_bounds.width());
   close_button_bounds.set_y(surface_local_bounds.y());
   floating_close_button_widget_->SetBounds(close_button_bounds);
+
+  UpdateCloseButtonVisiblity();
+}
+
+void ArcCustomNotificationView::OnKeyEvent(ui::KeyEvent* event) {
+  // Forward to parent CustomNotificationView to handle keyboard dismissal.
+  parent()->OnKeyEvent(event);
+}
+
+void ArcCustomNotificationView::OnGestureEvent(ui::GestureEvent* event) {
+  // Forward to parent CustomNotificationView to handle sliding out.
+  parent()->OnGestureEvent(event);
+  slide_helper_->Update();
+}
+
+void ArcCustomNotificationView::OnMouseEntered(const ui::MouseEvent&) {
+  UpdateCloseButtonVisiblity();
+}
+
+void ArcCustomNotificationView::OnMouseExited(const ui::MouseEvent&) {
+  UpdateCloseButtonVisiblity();
 }
 
 void ArcCustomNotificationView::ButtonPressed(views::Button* sender,
                                               const ui::Event& event) {
   if (item_ && !item_->pinned() && sender == floating_close_button_) {
     item_->CloseFromCloseButton();
   }
 }
 
-void ArcCustomNotificationView::OnWindowBoundsChanged(aura::Window* window,
-                           const gfx::Rect& old_bounds,
-                           const gfx::Rect& new_bounds) {
+void ArcCustomNotificationView::OnWindowBoundsChanged(
+    aura::Window* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds) {
   UpdatePreferredSize();
 }
 
 void ArcCustomNotificationView::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
 }
 
 void ArcCustomNotificationView::OnItemDestroying() {
   item_->RemoveObserver(this);
   item_ = nullptr;
 
   // Reset |surface_| with |item_| since no one is observing the |surface_|
   // after |item_| is gone and this view should be removed soon.
-  surface_ = nullptr;
+  SetSurface(nullptr);
 }
 
 void ArcCustomNotificationView::OnItemPinnedChanged() {
   if (item_->pinned() && floating_close_button_widget_) {
     floating_close_button_widget_.reset();
   } else if (!item_->pinned() && !floating_close_button_widget_) {
     CreateFloatingCloseButton();
   }
 }
 
 void ArcCustomNotificationView::OnItemNotificationSurfaceRemoved() {
-  surface_ = nullptr;
+  SetSurface(nullptr);
 }
 
 }  // namespace arc