Animates touch points on screen tap during touch calibration

chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_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 "chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_view.h"
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/shell.h"
 #include "ui/aura/window.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/linear_animation.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/strings/grit/ui_strings.h"
+#include "ui/views/background.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/widget/widget.h"
 
 namespace chromeos {
 
 namespace {
 
 constexpr char kWidgetName[] = "TouchCalibratorOverlay";
 
 constexpr int kAnimationFrameRate = 100;
 constexpr int kFadeDurationInMs = 150;
+constexpr int kPointMoveDurationInMs = 600;
+constexpr int kPointMoveDurationLongInMs = 700;
 
 const SkColor kExitLabelColor = SkColorSetARGBInline(255, 96, 96, 96);
 const SkColor kExitLabelShadowColor = SkColorSetARGBInline(255, 11, 11, 11);
 constexpr int kExitLabelWidth = 300;
 constexpr int kExitLabelHeight = 20;
 
+const SkColor kTapHereLabelColor = SK_ColorWHITE;
+
 constexpr int kHintBoxWidth = 298;
 constexpr int kHintBoxHeight = 180;
 constexpr int kHintBoxLabelTextSize = 5;
 constexpr int kHintBoxSublabelTextSize = 3;
 
-constexpr int kThrobberCircleViewWidth = 128;
+constexpr int kThrobberCircleViewWidth = 64;
 constexpr float kThrobberCircleRadiusFactor = 3.f / 8.f;
 
 constexpr int kTouchPointViewOffset = 100;
 
 constexpr int kTapLabelHeight = 48;
+constexpr int kTapLabelWidth = 80;
 
 const SkColor kHintLabelTextColor = SK_ColorBLACK;
 const SkColor kHintSublabelTextColor = SkColorSetARGBInline(255, 161, 161, 161);
 
 const SkColor kInnerCircleColor = SK_ColorWHITE;
 const SkColor kOuterCircleColor = SkColorSetA(kInnerCircleColor, 128);
 
 constexpr int kCircleAnimationDurationMs = 900;
 
-constexpr int kHintRectBorderRadius = 8;
+constexpr int kHintRectBorderRadius = 4;
 
 constexpr float kBackgroundFinalOpacity = 0.75f;
 
 // Returns the initialization params for the widget that contains the touch
 // calibrator view.
 views::Widget::InitParams GetWidgetParams(aura::Window* root_window) {
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
   params.name = kWidgetName;
   params.keep_on_top = true;
   params.accept_events = true;
   params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent = ash::Shell::GetContainer(
       root_window, ash::kShellWindowId_OverlayContainer);
   return params;
 }
 
 // Returns the size of bounding box required for |text| of given |font_list|.
 gfx::Size GetSizeForString(const base::string16& text,
                            const gfx::FontList& font_list) {
   int height = 0, width = 0;
   gfx::Canvas::SizeStringInt(text, font_list, &width, &height, 0, 0);
   return gfx::Size(width, height);
 }
 
+void AnimateLayerToPosition(views::View* view,
+                            int duration,
+                            gfx::Point end_position) {
+  ui::ScopedLayerAnimationSettings slide_settings(view->layer()->GetAnimator());
+  slide_settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  slide_settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(duration));
+  view->SetBoundsRect(gfx::Rect(end_position, view->size()));
+}
+
 }  // namespace
 
 // Creates a throbbing animated view with two concentric circles. The radius of
 // the inner circle is fixed while that of the outer circle oscillates between a
 // min and max radius. The animation takes |animation_duration| milliseconds
 // to complete. The center of these circles are at the center of the view
 // element.
 class CircularThrobberView : public views::View, public gfx::AnimationDelegate {
  public:
   CircularThrobberView(int width,
@@ skipping 193 matching lines @@
   canvas->DrawStringRectWithFlags(sublabel_text_, sublabel_font_list_,
                                   sublabel_color_, sublabel_text_bounds_,
                                   gfx::Canvas::NO_ELLIPSIS);
 }
 
 TouchCalibratorView::TouchCalibratorView(const display::Display& target_display,
                                          bool is_primary_view)
     : display_(target_display),
       is_primary_view_(is_primary_view),
       exit_label_(nullptr),
+      tap_label_(nullptr),
       throbber_circle_(nullptr),
       hint_box_view_(nullptr),
       touch_point_view_(nullptr) {
   aura::Window* root = ash::Shell::GetInstance()
                            ->window_tree_host_manager()
                            ->GetRootWindowForDisplayId(display_.id());
   widget_.reset(new views::Widget);
   widget_->Init(GetWidgetParams(root));
   widget_->SetContentsView(this);
   widget_->SetBounds(display_.bounds());
@@ skipping 38 matching lines @@
   AddChildView(exit_label_);
 
   // If this is not the screen that is being calibrated, then this is all we
   // need to display.
   if (!is_primary_view_)
     return;
 
   // Initialize the touch point view that contains the animated circle that the
   // user needs to tap.
   const int kTouchPointViewHeight = kThrobberCircleViewWidth + kTapLabelHeight;
+  const int kThrobberCircleViewHorizontalOffset =
+      (kTapLabelWidth - kThrobberCircleViewWidth) / 2;
 
   throbber_circle_ =
       new CircularThrobberView(kThrobberCircleViewWidth, kInnerCircleColor,
                                kOuterCircleColor, kCircleAnimationDurationMs);
-  throbber_circle_->SetPosition(gfx::Point(0, 0));
+  throbber_circle_->SetPosition(
+      gfx::Point(kThrobberCircleViewHorizontalOffset, 0));
+
+  // Initialize the tap label.
+  tap_label_ = new views::Label(
+      rb.GetLocalizedString(IDS_DISPLAY_TOUCH_CALIBRATION_TAP_HERE_LABEL),
+      rb.GetFontListWithDelta(6, gfx::Font::FontStyle::NORMAL,
+                              gfx::Font::Weight::NORMAL));
+  tap_label_->SetBounds(0, kThrobberCircleViewWidth, kTapLabelWidth,
+                        kTapLabelHeight);
+  tap_label_->SetEnabledColor(kTapHereLabelColor);
+  tap_label_->SetDisabledColor(kTapHereLabelColor);
+  tap_label_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
+  tap_label_->SetAutoColorReadabilityEnabled(false);
+  tap_label_->SetSubpixelRenderingEnabled(false);
+  tap_label_->SetVisible(false);
 
   touch_point_view_ = new views::View;
   touch_point_view_->SetBounds(kTouchPointViewOffset, kTouchPointViewOffset,
-                               kThrobberCircleViewWidth, kTouchPointViewHeight);
+                               kTapLabelWidth, kTouchPointViewHeight);
   touch_point_view_->SetVisible(false);
+  touch_point_view_->SetPaintToLayer(true);
+  touch_point_view_->layer()->SetFillsBoundsOpaquely(false);
+  touch_point_view_->layer()->GetAnimator()->AddObserver(this);
+  touch_point_view_->set_background(
+      views::Background::CreateSolidBackground(SK_ColorTRANSPARENT));
 
   touch_point_view_->AddChildView(throbber_circle_);
+  touch_point_view_->AddChildView(tap_label_);
 
   AddChildView(touch_point_view_);
 
   // Initialize the Hint Box view.
   base::string16 hint_label_text =
       rb.GetLocalizedString(IDS_DISPLAY_TOUCH_CALIBRATION_HINT_LABEL_TEXT);
   base::string16 hint_sublabel_text =
       rb.GetLocalizedString(IDS_DISPLAY_TOUCH_CALIBRATION_HINT_SUBLABEL_TEXT);
 
   int tpv_width = touch_point_view_->width();
@@ skipping 30 matching lines @@
   } else {
     opacity = state_ == BACKGROUND_FADING_OUT ? 0.f : kBackgroundFinalOpacity;
   }
 
   paint_.setColor(SkColorSetA(SK_ColorBLACK,
                               std::numeric_limits<uint8_t>::max() * opacity));
   canvas->DrawRect(background_rect_, paint_);
 }
 
 void TouchCalibratorView::AnimationProgressed(const gfx::Animation* animation) {
-  SchedulePaint();
+  if (!is_primary_view_) {
+    SchedulePaint();
+    return;
+  }
 }
 
 void TouchCalibratorView::AnimationCanceled(const gfx::Animation* animation) {
   AnimationEnded(animation);
 }
 
 void TouchCalibratorView::AnimationEnded(const gfx::Animation* animation) {
   switch (state_) {
     case BACKGROUND_FADING_IN:
       exit_label_->SetVisible(true);
       state_ = is_primary_view_ ? DISPLAY_POINT_1 : CALIBRATION_COMPLETE;
       if (is_primary_view_) {
         touch_point_view_->SetVisible(true);
         hint_box_view_->SetVisible(true);
       }
       break;
     default:
       break;
   }
 }
 
+void TouchCalibratorView::OnLayerAnimationStarted(
+    ui::LayerAnimationSequence* sequence) {}
+
+void TouchCalibratorView::OnLayerAnimationEnded(
+    ui::LayerAnimationSequence* sequence) {
+  switch (state_) {
+    case ANIMATING_1_TO_2:
+      state_ = DISPLAY_POINT_2;
+      tap_label_->SetVisible(true);
+      break;
+    case ANIMATING_2_TO_3:
+      state_ = DISPLAY_POINT_3;
+      break;
+    case ANIMATING_3_TO_4:
+      state_ = DISPLAY_POINT_4;
+      break;
+    default:
+      break;
+  }
+}
+
+void TouchCalibratorView::OnLayerAnimationAborted(
+    ui::LayerAnimationSequence* sequence) {
+  OnLayerAnimationEnded(sequence);
+}
+
+void TouchCalibratorView::OnLayerAnimationScheduled(
+    ui::LayerAnimationSequence* sequence) {}
+
 void TouchCalibratorView::AdvanceToNextState() {
   // Stop any previous animations and skip them to the end.
-  animator_->End();
+  SkipCurrentAnimation();
 
   switch (state_) {
     case UNKNOWN:
     case BACKGROUND_FADING_IN:
       state_ = BACKGROUND_FADING_IN;
       start_opacity_value_ = 0.f;
       end_opacity_value_ = kBackgroundFinalOpacity;
 
       paint_.setStyle(SkPaint::kFill_Style);
+      animator_->SetDuration(kFadeDurationInMs);
+      animator_->Start();
+      return;
+    case DISPLAY_POINT_1:
+      state_ = ANIMATING_1_TO_2;
 
-      animator_->SetDuration(kFadeDurationInMs);
-      break;
+      // The touch point has to be animated from the top left corner of the
+      // screen to the top right corner.
+      AnimateLayerToPosition(
+          touch_point_view_, kPointMoveDurationInMs,
+          gfx::Point(display_.bounds().width() - kTouchPointViewOffset -
+                         touch_point_view_->width(),
+                     touch_point_view_->y()));
+      hint_box_view_->SetVisible(false);
+      return;
+    case DISPLAY_POINT_2:
+      state_ = ANIMATING_2_TO_3;
+
+      // The touch point has to be animated from the top right corner of the
+      // screen to the bottom left corner.
+      AnimateLayerToPosition(
+          touch_point_view_, kPointMoveDurationLongInMs,
+          gfx::Point(kTouchPointViewOffset, display_.bounds().height() -
+                                                kTouchPointViewOffset -
+                                                touch_point_view_->height()));
+      return;
+    case DISPLAY_POINT_3:
+      state_ = ANIMATING_3_TO_4;
+
+      // The touch point has to be animated from the bottom left corner of the
+      // screen to the bottom right corner.
+      AnimateLayerToPosition(
+          touch_point_view_, kPointMoveDurationInMs,
+          gfx::Point(display_.bounds().width() - kTouchPointViewOffset -
+                         touch_point_view_->width(),
+                     touch_point_view_->y()));
+      return;
     default:
-      break;
+      return;
   }
-  animator_->Start();
 }
 
 bool TouchCalibratorView::GetDisplayPointLocation(gfx::Point* location) {
+  DCHECK(location);
   if (!is_primary_view_)
     return false;
-  return false;
+
+  if (state_ != DISPLAY_POINT_1 && state_ != DISPLAY_POINT_2 &&
+      state_ != DISPLAY_POINT_3 && state_ != DISPLAY_POINT_4) {
+    return false;
+  }
+
+  if (!touch_point_view_ || !throbber_circle_)
+    return false;
+  // TODO(malaykeshav): Can use views::ConvertPointToScreen()
+  location->SetPoint(touch_point_view_->x() + touch_point_view_->width() / 2.f,
+                     touch_point_view_->y() + touch_point_view_->width() / 2.f);
+  return true;
 }
 
 void TouchCalibratorView::SkipToFinalState() {}
 
-void TouchCalibratorView::SkipCurrentAnimationForTest() {
+void TouchCalibratorView::SkipCurrentAnimation() {
   if (animator_->is_animating())
     animator_->End();
+  if (touch_point_view_ &&
+      touch_point_view_->layer()->GetAnimator()->is_animating()) {
+    touch_point_view_->layer()->GetAnimator()->StopAnimating();
+  }
 }
 
 }  // namespace chromeos