ash / system / tray / tray_item_view.cc [blame]

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/system/tray/tray_item_view.h"

#include <optional>

#include "ash/constants/ash_features.h"
#include "ash/public/cpp/shelf_types.h"
#include "ash/shelf/shelf.h"
#include "ash/system/status_area_animation_controller.h"
#include "ash/system/tray/tray_constants.h"
#include "base/metrics/histogram_functions.h"
#include "ui/accessibility/ax_enums.mojom.h"
#include "ui/accessibility/ax_node_data.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/compositor_metrics_tracker.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animator.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/gfx/animation/slide_animation.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/controls/image_view.h"
#include "ui/views/controls/label.h"
#include "ui/views/layout/fill_layout.h"
#include "ui/views/widget/widget.h"

namespace ash {

namespace {

// Animating in will start (after resize stage) when animation value is greater
// than this value.
constexpr double kAnimatingInStartValue = 0.5;

// Animating out will end (before resize stage) when animation value is less
// than this value.
constexpr double kAnimatingOutEndValue = 0.5;

constexpr char kShowAnimationSmoothnessHistogramName[] =
    "Ash.StatusArea.TrayItemView.Show";

constexpr char kHideAnimationSmoothnessHistogramName[] =
    "Ash.StatusArea.TrayItemView.Hide";

void RecordAnimationSmoothness(const std::string& histogram_name,
                               int smoothness) {
  DCHECK(0 <= smoothness && smoothness <= 100);
  base::UmaHistogramPercentage(histogram_name, smoothness);
}

void SetupThroughputTrackerForAnimationSmoothness(
    views::Widget* widget,
    std::optional<ui::ThroughputTracker>& tracker,
    const char* histogram_name) {
  // Return if `tracker` is already running; `widget` may not exist in tests.
  if (tracker || !widget)
    return;

  tracker.emplace(
      widget->GetCompositor()->RequestNewCompositorMetricsTracker());
  tracker->Start(ash::metrics_util::ForSmoothnessV3(
      base::BindRepeating(&RecordAnimationSmoothness, histogram_name)));
}

}  // namespace

void IconizedLabel::SetCustomAccessibleName(const std::u16string& name) {
  custom_accessible_name_ = name;

  UpdateAccessibleRole();
  GetViewAccessibility().SetName(custom_accessible_name_);
}

void IconizedLabel::AdjustAccessibleName(std::u16string& new_name,
                                         ax::mojom::NameFrom& name_from) {
  if (!custom_accessible_name_.empty()) {
    new_name = custom_accessible_name_;
    name_from = ax::mojom::NameFrom::kAttribute;
  } else {
    views::Label::AdjustAccessibleName(new_name, name_from);
  }
}

void IconizedLabel::UpdateAccessibleRole() {
  if (!custom_accessible_name_.empty()) {
    GetViewAccessibility().SetRole(ax::mojom::Role::kStaticText);
  } else {
    GetViewAccessibility().SetRole(GetTextContext() ==
                                           views::style::CONTEXT_DIALOG_TITLE
                                       ? ax::mojom::Role::kTitleBar
                                       : ax::mojom::Role::kStaticText);
  }
}

BEGIN_METADATA(IconizedLabel)
END_METADATA

TrayItemView::TrayItemView(Shelf* shelf)
    : views::AnimationDelegateViews(this), shelf_(shelf) {
  DCHECK(shelf_);
  SetPaintToLayer();
  layer()->SetFillsBoundsOpaquely(false);
  SetLayoutManager(std::make_unique<views::FillLayout>());
}

TrayItemView::~TrayItemView() = default;

void TrayItemView::AddObserver(Observer* observer) {
  observers_.AddObserver(observer);
}

void TrayItemView::RemoveObserver(Observer* observer) {
  observers_.RemoveObserver(observer);
}

void TrayItemView::CreateLabel() {
  label_ = new IconizedLabel;
  AddChildView(label_.get());
  PreferredSizeChanged();
  for (auto& observer : observers_) {
    observer.OnTrayItemChildViewChanged();
  }
}

void TrayItemView::CreateImageView() {
  image_view_ = new views::ImageView;
  AddChildView(image_view_.get());
  PreferredSizeChanged();
  for (auto& observer : observers_) {
    observer.OnTrayItemChildViewChanged();
  }
}

void TrayItemView::DestroyLabel() {
  if (!label_)
    return;

  RemoveChildViewT(label_.get());
  label_ = nullptr;

  for (auto& observer : observers_) {
    observer.OnTrayItemChildViewChanged();
  }
}

void TrayItemView::DestroyImageView() {
  if (!image_view_)
    return;

  RemoveChildViewT(image_view_.get());
  image_view_ = nullptr;

  for (auto& observer : observers_) {
    observer.OnTrayItemChildViewChanged();
  }
}

void TrayItemView::UpdateLabelOrImageViewColor(bool active) {
  is_active_ = active;
}

base::ScopedClosureRunner TrayItemView::DisableAnimation() {
  if (layer()->GetAnimator()->is_animating()) {
    layer()->GetAnimator()->StopAnimating();
  }
  ++disable_animation_count_;
  return base::ScopedClosureRunner(base::BindOnce(
      [](const base::WeakPtr<TrayItemView>& ptr) {
        if (ptr) {
          --ptr->disable_animation_count_;
        }
      },
      weak_factory_.GetWeakPtr()));
}

void TrayItemView::SetAnimationIdleClosureForTest(base::OnceClosure closure) {
  animation_idle_closure_ = std::move(closure);
}

bool TrayItemView::IsAnimating() {
  return animation_ && animation_->is_animating();
}

void TrayItemView::SetVisible(bool visible) {
  // Do not invoke animation when the current visibility is already at the
  // target visibility.
  if (visible == target_visible_) {
    return;
  }
  target_visible_ = visible;
  for (auto& observer : observers_) {
    observer.OnTrayItemVisibilityAboutToChange(target_visible_);
  }
  views::View::SetVisible(visible);
  // During startup TrayItemViews are often SetVisible(false) before they are
  // attached to a widget. Don't bother constructing animations for them.
  if (!GetWidget()) {
    return;
  }
  PerformVisibilityAnimation(visible);
}

bool TrayItemView::IsHorizontalAlignment() const {
  return shelf_->IsHorizontalAlignment();
}

void TrayItemView::PerformVisibilityAnimation(bool visible) {
  // Set the view visible to show both show/hide animation.
  views::View::SetVisible(true);

  if (!animation_) {
    animation_ = std::make_unique<gfx::SlideAnimation>(this);
    animation_->SetTweenType(gfx::Tween::LINEAR);
    animation_->Reset(target_visible_ ? 0.0 : 1.0);
  }

  // Immediately progress to the end of the animation if animation is disabled.
  // NOTE: `ScreenRotationAnimator` can set animations to ZERO_DURATION.
  if (!ShouldVisibilityChangeBeAnimated() ||
      ui::ScopedAnimationDurationScaleMode::duration_multiplier() ==
          ui::ScopedAnimationDurationScaleMode::ZERO_DURATION) {
    // Tray items need to stay visible if the notification center tray's hide
    // animation is going to run, so don't hide the tray item here.
    // `StatusAreaAnimationController` will call `ImmediatelyUpdateVisibility()`
    // once the hide animation is over to ensure that all tray items are given a
    // chance to properly update their visibilities.
    if (!target_visible_ && shelf_->status_area_widget()
                                ->animation_controller()
                                ->is_hide_animation_scheduled()) {
      return;
    }
    animation_->SetSlideDuration(base::TimeDelta());
    target_visible_ ? animation_->Show() : animation_->Hide();
    return;
  }

  if (target_visible_) {
    SetupThroughputTrackerForAnimationSmoothness(
        GetWidget(), show_throughput_tracker_,
        kShowAnimationSmoothnessHistogramName);
    animation_->SetSlideDuration(base::Milliseconds(400));
    animation_->Show();
    AnimationProgressed(animation_.get());
  } else {
    SetupThroughputTrackerForAnimationSmoothness(
        GetWidget(), hide_throughput_tracker_,
        kHideAnimationSmoothnessHistogramName);
    animation_->SetSlideDuration(base::Milliseconds(100));
    animation_->Hide();
    AnimationProgressed(animation_.get());
  }
}

void TrayItemView::ImmediatelyUpdateVisibility() {
  // Reset the animation to the end state according to `target_visible_` so that
  // future visibility changes can animate properly.
  if (animation_) {
    animation_->Reset(target_visible_ ? 1.0 : 0.0);
  }
  layer()->SetTransform(gfx::Transform());
  layer()->SetOpacity(target_visible_ ? 1.0 : 0.0);
  views::View::SetVisible(target_visible_);
}

gfx::Size TrayItemView::CalculatePreferredSize(
    const views::SizeBounds& available_size) const {
  DCHECK_EQ(1u, children().size());
  gfx::Size size = views::View::CalculatePreferredSize(available_size);
  if (image_view_) {
    size = gfx::Size(kUnifiedTrayIconSize, kUnifiedTrayIconSize);
    // Some TrayItemViews have slightly larger icons (e.g. Ethernet with VPN
    // badge).
    size.SetToMax(image_view_->CalculatePreferredSize({}));
  }

  if (!animation_.get() || !animation_->is_animating() ||
      !InResizeAnimation(animation_->GetCurrentValue())) {
    return size;
  }

  double progress = gfx::Tween::CalculateValue(
      gfx::Tween::FAST_OUT_SLOW_IN,
      GetResizeProgressFromAnimationProgress(animation_->GetCurrentValue()));
  if (shelf_->IsHorizontalAlignment()) {
    size.set_width(std::max(1, static_cast<int>(size.width() * progress)));
  } else {
    size.set_height(std::max(1, static_cast<int>(size.height() * progress)));
  }
  return size;
}

void TrayItemView::ChildPreferredSizeChanged(views::View* child) {
  PreferredSizeChanged();
}

void TrayItemView::AnimationProgressed(const gfx::Animation* animation) {
  // Should not animate during resize stage.
  if (InResizeAnimation(animation->GetCurrentValue())) {
    // Ensure we are not visible during resize stage.
    if (layer()->opacity() > 0.0) {
      layer()->SetOpacity(0.0);
    }
    PreferredSizeChanged();
    return;
  }

  double scale_progress =
      GetItemScaleProgressFromAnimationProgress(animation->GetCurrentValue());
  layer()->SetOpacity(scale_progress);

  // Only scale when animating icon in.
  if (target_visible_ && use_scale_in_animation_) {
    scale_progress = gfx::Tween::CalculateValue(gfx::Tween::LINEAR_OUT_SLOW_IN,
                                                scale_progress);
    gfx::Transform transform;
    transform.Translate(
        gfx::Tween::DoubleValueBetween(scale_progress,
                                       static_cast<double>(width()) / 2, 0.),
        gfx::Tween::DoubleValueBetween(scale_progress,
                                       static_cast<double>(height()) / 2, 0.));
    transform.Scale(scale_progress, scale_progress);
    layer()->SetTransform(transform);
  }

  // Container size might not fully transition to full size (the resize progress
  // value converted from animation progress might not be 1 after resize
  // animation). This call makes sure that it is fully resized.
  PreferredSizeChanged();
}

void TrayItemView::AnimationEnded(const gfx::Animation* animation) {
  views::View::SetVisible(target_visible_);
  layer()->SetOpacity(target_visible_ ? 1.0 : 0.0);

  if (show_throughput_tracker_) {
    // Reset `show_throughput_tracker_` to reset animation metrics recording.
    show_throughput_tracker_->Stop();
    show_throughput_tracker_.reset();
  }

  if (hide_throughput_tracker_) {
    // Reset `hide_throughput_tracker_` to reset animation metrics recording.
    hide_throughput_tracker_->Stop();
    hide_throughput_tracker_.reset();
  }

  if (animation_idle_closure_) {
    std::move(animation_idle_closure_).Run();
  }
}

void TrayItemView::AnimationCanceled(const gfx::Animation* animation) {
  AnimationEnded(animation);
}

bool TrayItemView::InResizeAnimation(double animation_value) const {
  // Animation should be delayed for the first part of animating in and last
  // part of animating out, allowing item resize happen before item animating in
  // and after item animating out.
  return ((target_visible_ && animation_value <= kAnimatingInStartValue) ||
          (!target_visible_ && animation_value <= kAnimatingOutEndValue));
}

double TrayItemView::GetResizeProgressFromAnimationProgress(
    double animation_value) const {
  DCHECK(InResizeAnimation(animation_value));
  // When animating in, convert value from [0,kAnimatingInStartValue] to [0,1].
  if (target_visible_)
    return animation_value * (1 / kAnimatingInStartValue);

  // When animating out, convert value from [kAnimatingOutEndValue,0] to [1,0].
  return animation_value * (1 / kAnimatingOutEndValue);
}

double TrayItemView::GetItemScaleProgressFromAnimationProgress(
    double animation_value) const {
  DCHECK(!InResizeAnimation(animation_value));
  // When animating in, convert value from [kAnimatingInStartValue,1] to [0,1].
  if (target_visible_) {
    return (animation_value - kAnimatingInStartValue) *
           (1 / (1 - kAnimatingInStartValue));
  }

  // When animating out, convert value from [1,kAnimatingOutEndValue] to [1,0].
  return (animation_value - kAnimatingOutEndValue) *
         (1 / (1 - kAnimatingOutEndValue));
}

BEGIN_METADATA(TrayItemView)
END_METADATA

}  // namespace ash