// Copyright 2021 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/progress_indicator/progress_indicator.h"
#include "ash/constants/ash_features.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/system/progress_indicator/progress_icon_animation.h"
#include "ash/system/progress_indicator/progress_ring_animation.h"
#include "base/memory/raw_ptr.h"
#include "base/scoped_observation.h"
#include "base/task/sequenced_task_runner.h"
#include "chromeos/constants/chromeos_features.h"
#include "third_party/skia/include/core/SkPath.h"
#include "third_party/skia/include/core/SkPathMeasure.h"
#include "ui/chromeos/styles/cros_tokens_color_mappings.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/paint_recorder.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/gfx/scoped_canvas.h"
namespace ash {
namespace {
// Appearance.
constexpr float kInnerIconSizeScaleFactor = 14.f / 28.f;
constexpr float kOuterRingOpacity = 0.6f;
constexpr float kInnerRingStrokeWidthScaleFactor = 1.5f / 28.f;
constexpr float kOuterRingStrokeWidth = 2.f;
constexpr float kOuterRingStrokeWidthScaleFactor = 4.f / 28.f;
// Helpers ---------------------------------------------------------------------
// Returns the segment of the specified `path` between `start` and `end`.
// NOTE: It is required that: `0.f` <= `start` <= `end` <= `1.f`.
SkPath CreatePathSegment(const SkPath& path, float start, float end) {
DCHECK_LE(0.f, start);
DCHECK_LE(start, end);
DCHECK_LE(end, 1.f);
SkPathMeasure measure(path, /*force_closed=*/false);
start *= measure.getLength();
end *= measure.getLength();
SkPath path_segment;
measure.getSegment(start, end, &path_segment, /*start_with_move_to=*/true);
return path_segment;
}
// Returns a rounded rect path from the specified `rect` and `corner_radius`.
// NOTE: Unlike a typical rounded rect which starts from the *top-left* corner
// and proceeds clockwise, the rounded rect returned by this method starts at
// the *top-center*. This is a subtle but important detail as calling
// `CreatePathSegment()` with a path created from this method will treat
// *top-center* as the start point, as is needed when painting progress.
SkPath CreateRoundedRectPath(const gfx::RectF& rect, float corner_radius) {
// Top center.
SkPoint top_center(SkPoint::Make(rect.width() / 2.f, 0.f));
// Top right.
SkPoint top_right(SkPoint::Make(rect.width(), 0.f));
SkPoint top_right_end(top_right);
top_right_end.offset(0.f, corner_radius);
// Bottom right.
SkPoint bottom_right(SkPoint::Make(rect.width(), rect.height()));
SkPoint bottom_right_end(bottom_right);
bottom_right_end.offset(-corner_radius, 0.f);
// Bottom left.
SkPoint bottom_left(SkPoint::Make(0.f, rect.height()));
SkPoint bottom_left_end(bottom_left);
bottom_left_end.offset(0.f, -corner_radius);
// Top left.
SkPoint top_left(SkPoint::Make(0.f, 0.f));
SkPoint top_left_end(top_left);
top_left_end.offset(corner_radius, 0.f);
// Build path in the order specified above.
return SkPath()
.moveTo(top_center)
.arcTo(top_right, top_right_end, corner_radius)
.arcTo(bottom_right, bottom_right_end, corner_radius)
.arcTo(bottom_left, bottom_left_end, corner_radius)
.arcTo(top_left, top_left_end, corner_radius)
.close()
.offset(rect.x(), rect.y());
}
// Returns the size for the inner icon given `layer` dimensions.
// NOTE: this method should only be called when v2 animations are enabled.
float GetInnerIconSize(const ui::Layer* layer) {
const gfx::Size& size = layer->size();
return kInnerIconSizeScaleFactor * std::min(size.width(), size.height());
}
// Returns the stroke width for the inner icon given `layer` dimensions.
// NOTE: this method should only be called when v2 animations are enabled.
float GetInnerRingStrokeWidth(const ui::Layer* layer) {
const gfx::Size& size = layer->size();
return kInnerRingStrokeWidthScaleFactor *
std::min(size.width(), size.height());
}
// TODO(b/324644877): We want the progress ring still keep the same opacity
// after the `Pulse` animation. Please also provide an option for our this
// expectation after removing `kForcedShow`.
// Returns the opacity for the outer ring given the current `progress`.
float GetOuterRingOpacity(const std::optional<float>& progress) {
return (progress == ProgressIndicator::kProgressComplete ||
progress == ProgressIndicator::kForcedShow)
? 1.f
: kOuterRingOpacity;
}
// Returns the stroke width for the outer ring given `layer` dimensions and
// the current `progress`.
float GetOuterRingStrokeWidth(const ui::Layer* layer,
const std::optional<float>& progress) {
if (progress != ProgressIndicator::kProgressComplete) {
const gfx::Size& size = layer->size();
return kOuterRingStrokeWidthScaleFactor *
std::min(size.width(), size.height());
}
return kOuterRingStrokeWidth;
}
// DefaultProgressIndicatorAnimationRegistry -----------------------------------
// A default implementation of `ProgressIndicatorAnimationRegistry` which is
// associated with a single `ProgressIndicator` and manage progress animations
// as needed.
class DefaultProgressIndicatorAnimationRegistry
: public ProgressIndicatorAnimationRegistry {
public:
DefaultProgressIndicatorAnimationRegistry() = default;
DefaultProgressIndicatorAnimationRegistry(
const DefaultProgressIndicatorAnimationRegistry&) = delete;
DefaultProgressIndicatorAnimationRegistry& operator=(
const DefaultProgressIndicatorAnimationRegistry&) = delete;
~DefaultProgressIndicatorAnimationRegistry() = default;
// Sets the `progress_indicator` for which this registry manages animations.
// NOTE: This method may be called only once.
void SetProgressIndicator(ProgressIndicator* progress_indicator) {
DCHECK(progress_indicator);
DCHECK(!progress_indicator_);
progress_indicator_ = progress_indicator;
progress_changed_subscription_ =
progress_indicator_->AddProgressChangedCallback(base::BindRepeating(
&DefaultProgressIndicatorAnimationRegistry::OnProgressChanged,
weak_ptr_factory_.GetWeakPtr()));
}
private:
// Invoked on changes to `progress_indicator_` progress.
void OnProgressChanged() {
const std::optional<float>& progress = progress_indicator_->progress();
if (!progress.has_value()) {
// Progress is indeterminate.
EnsureProgressIconAnimation();
EnsureProgressRingAnimationOfType(
ProgressRingAnimation::Type::kIndeterminate);
} else if (progress != ProgressIndicator::kProgressComplete) {
// Progress is determinate.
EnsureProgressIconAnimation();
EraseProgressRingAnimation();
} else if (previous_progress_ != ProgressIndicator::kProgressComplete) {
// Progress is complete.
EraseProgressIconAnimation();
EnsureProgressRingAnimationOfType(ProgressRingAnimation::Type::kPulse);
}
previous_progress_ = progress;
}
// Invoked on update of the specified `animation`.
void OnProgressRingAnimationUpdated(ProgressRingAnimation* animation) {
if (animation->IsAnimating())
return;
// On completion, `animation` can be removed from the registry. This cannot
// be done directly from `animation`'s subscription callback, so post a task
// to delete `animation` as soon as possible.
base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE,
base::BindOnce(
[](const base::WeakPtr<DefaultProgressIndicatorAnimationRegistry>&
self,
MayBeDangling<ProgressRingAnimation> animation) {
if (!self) {
return;
}
auto key = self->progress_indicator_->animation_key();
if (self->GetProgressRingAnimationForKey(key) == animation) {
self->SetProgressRingAnimationForKey(key, nullptr);
}
},
weak_ptr_factory_.GetWeakPtr(), base::UnsafeDangling(animation)));
}
// Ensures that a progress icon animation exists and is started.
void EnsureProgressIconAnimation() {
auto key = progress_indicator_->animation_key();
if (!GetProgressIconAnimationForKey(key)) {
auto* icon_animation =
SetProgressIconAnimationForKey(key, ProgressIconAnimation::Create());
icon_animation->Start();
}
}
// Ensures that a progress ring animation of the specified `type` exists and
// is started.
void EnsureProgressRingAnimationOfType(ProgressRingAnimation::Type type) {
auto key = progress_indicator_->animation_key();
auto* ring_animation = GetProgressRingAnimationForKey(key);
if (ring_animation && ring_animation->type() == type)
return;
auto animation = ProgressRingAnimation::CreateOfType(type);
// NOTE: `animation` is owned by `this` so it is safe to use a raw pointer
// and subscription-less callback.
animation->AddUnsafeAnimationUpdatedCallback(
base::BindRepeating(&DefaultProgressIndicatorAnimationRegistry::
OnProgressRingAnimationUpdated,
base::Unretained(this), animation.get()));
SetProgressRingAnimationForKey(key, std::move(animation))->Start();
}
// Erases any existing progress icon animation.
void EraseProgressIconAnimation() {
SetProgressIconAnimationForKey(progress_indicator_->animation_key(),
nullptr);
}
// Erases any existing progress ring animation.
void EraseProgressRingAnimation() {
SetProgressRingAnimationForKey(progress_indicator_->animation_key(),
nullptr);
}
// The progress indicator for which to manage animations and a subscription
// to receive notification of progress change events.
raw_ptr<ProgressIndicator> progress_indicator_ = nullptr;
base::CallbackListSubscription progress_changed_subscription_;
// Instantiate `previous_progress_` to completion to avoid starting a pulse
// animation on first progress update.
std::optional<float> previous_progress_ =
ProgressIndicator::kProgressComplete;
base::WeakPtrFactory<DefaultProgressIndicatorAnimationRegistry>
weak_ptr_factory_{this};
};
// DefaultProgressIndicator ----------------------------------------------------
// A default implementation of `ProgressIndicator` which paints indication of
// progress returned by the specified `progress_callback_`. NOTE: This instance
// comes pre-wired with an animation `registry_` that will manage progress
// animations as needed.
class DefaultProgressIndicator : public ProgressIndicator {
public:
DefaultProgressIndicator(
std::unique_ptr<DefaultProgressIndicatorAnimationRegistry> registry,
base::RepeatingCallback<std::optional<float>()> progress_callback)
: ProgressIndicator(
registry.get(),
ProgressIndicatorAnimationRegistry::AsAnimationKey(this)),
registry_(std::move(registry)),
progress_callback_(std::move(progress_callback)) {
registry_->SetProgressIndicator(this);
}
DefaultProgressIndicator(const DefaultProgressIndicator&) = delete;
DefaultProgressIndicator& operator=(const DefaultProgressIndicator&) = delete;
~DefaultProgressIndicator() override = default;
private:
// ProgressIndicator:
std::optional<float> CalculateProgress() const override {
return progress_callback_.Run();
}
std::unique_ptr<DefaultProgressIndicatorAnimationRegistry> registry_;
base::RepeatingCallback<std::optional<float>()> progress_callback_;
};
} // namespace
// ProgressIndicator -----------------------------------------------------------
// static
constexpr char ProgressIndicator::kClassName[];
constexpr float ProgressIndicator::kProgressComplete;
ProgressIndicator::ProgressIndicator(
ProgressIndicatorAnimationRegistry* animation_registry,
ProgressIndicatorAnimationRegistry::AnimationKey animation_key)
: animation_registry_(animation_registry), animation_key_(animation_key) {
if (!animation_registry_)
return;
// Register to be notified of changes to the icon animation associated with
// this progress indicator's `animation_key_`. Note that it is safe to use a
// raw pointer here since `this` owns the subscription.
icon_animation_changed_subscription_ =
animation_registry_->AddProgressIconAnimationChangedCallbackForKey(
animation_key_,
base::BindRepeating(
&ProgressIndicator::OnProgressIconAnimationChanged,
base::Unretained(this)));
// If an `icon_animation` is already registered, perform additional
// initialization.
ProgressIconAnimation* icon_animation =
animation_registry_->GetProgressIconAnimationForKey(animation_key_);
if (icon_animation)
OnProgressIconAnimationChanged(icon_animation);
// Register to be notified of changes to the ring animation associated with
// this progress indicator's `animation_key_`. Note that it is safe to use a
// raw pointer here since `this` owns the subscription.
ring_animation_changed_subscription_ =
animation_registry_->AddProgressRingAnimationChangedCallbackForKey(
animation_key_,
base::BindRepeating(
&ProgressIndicator::OnProgressRingAnimationChanged,
base::Unretained(this)));
// If `ring_animation` is already registered, perform additional
// initialization.
ProgressRingAnimation* ring_animation =
animation_registry_->GetProgressRingAnimationForKey(animation_key_);
if (ring_animation)
OnProgressRingAnimationChanged(ring_animation);
}
ProgressIndicator::~ProgressIndicator() = default;
// static
std::unique_ptr<ProgressIndicator> ProgressIndicator::CreateDefaultInstance(
base::RepeatingCallback<std::optional<float>()> progress_callback) {
return std::make_unique<DefaultProgressIndicator>(
std::make_unique<DefaultProgressIndicatorAnimationRegistry>(),
std::move(progress_callback));
}
base::CallbackListSubscription ProgressIndicator::AddProgressChangedCallback(
base::RepeatingClosureList::CallbackType callback) {
return progress_changed_callback_list_.Add(std::move(callback));
}
ui::Layer* ProgressIndicator::CreateLayer(ColorResolver color_resolver) {
CHECK(!layer());
CHECK(color_resolver);
auto layer = std::make_unique<ui::Layer>(ui::LAYER_TEXTURED);
layer->set_delegate(this);
layer->SetFillsBoundsOpaquely(false);
layer->SetName(kClassName);
Reset(std::move(layer));
color_resolver_ = std::move(color_resolver);
return this->layer();
}
void ProgressIndicator::DestroyLayer() {
color_resolver_.Reset();
if (layer())
ReleaseLayer();
}
void ProgressIndicator::InvalidateLayer() {
if (layer())
layer()->SchedulePaint(gfx::Rect(layer()->size()));
}
void ProgressIndicator::SetColorId(const std::optional<ui::ColorId>& color_id) {
if (color_id_ == color_id) {
return;
}
color_id_ = color_id;
InvalidateLayer();
}
void ProgressIndicator::SetInnerIconVisible(bool visible) {
if (inner_icon_visible_ == visible)
return;
inner_icon_visible_ = visible;
// It's not necessary to invalidate the `layer()` if progress is complete
// since the inner icon is only painted while progress is incomplete.
if (progress_ != kProgressComplete)
InvalidateLayer();
}
void ProgressIndicator::SetInnerRingVisible(bool visible) {
if (inner_ring_visible_ == visible) {
return;
}
inner_ring_visible_ = visible;
// It's not necessary to invalidate the `layer()` if progress is complete
// since the inner ring is only painted while progress is incomplete.
if (progress_ != kProgressComplete) {
InvalidateLayer();
}
}
void ProgressIndicator::SetOuterRingTrackVisible(bool visible) {
if (outer_ring_track_visible_ == visible) {
return;
}
outer_ring_track_visible_ = visible;
// It's not necessary to invalidate the `layer()` if progress is complete
// since the progress ring track is only painted while progress is incomplete.
if (progress_ != kProgressComplete) {
InvalidateLayer();
}
}
void ProgressIndicator::SetOuterRingStrokeWidth(float width) {
if (outer_ring_stroke_width_ == width) {
return;
}
outer_ring_stroke_width_ = width;
// It's not necessary to invalidate the `layer()` if progress is complete
// since the outer ring is only painted while progress is incomplete.
if (progress_ != kProgressComplete) {
InvalidateLayer();
}
}
void ProgressIndicator::OnDeviceScaleFactorChanged(float old_scale,
float new_scale) {
InvalidateLayer();
}
void ProgressIndicator::OnPaintLayer(const ui::PaintContext& context) {
// Look up the associated `ring_animation` (if one exists).
ProgressRingAnimation* ring_animation =
animation_registry_
? animation_registry_->GetProgressRingAnimationForKey(animation_key_)
: nullptr;
// Unless `this` is animating, nothing will paint if `progress_` is complete.
if (progress_ == kProgressComplete && !ring_animation)
return;
float start, end, outer_ring_opacity;
if (ring_animation) {
start = ring_animation->start_position();
end = ring_animation->end_position();
outer_ring_opacity = ring_animation->outer_ring_opacity();
} else {
start = 0.f;
end = progress_.value();
outer_ring_opacity = 1.f;
}
DCHECK_GE(start, 0.f);
DCHECK_LE(start, 1.f);
DCHECK_GE(end, 0.f);
DCHECK_LE(end, 1.f);
DCHECK_GE(outer_ring_opacity, 0.f);
DCHECK_LE(outer_ring_opacity, 1.f);
ui::PaintRecorder recorder(context, layer()->size());
gfx::Canvas* canvas = recorder.canvas();
// The `canvas` should be flipped for RTL.
gfx::ScopedCanvas scoped_canvas(recorder.canvas());
scoped_canvas.FlipIfRTL(layer()->size().width());
// Look up the associated `icon_animation` (if one exists).
ProgressIconAnimation* icon_animation =
animation_registry_
? animation_registry_->GetProgressIconAnimationForKey(animation_key_)
: nullptr;
if (icon_animation) {
const float opacity = icon_animation->opacity();
DCHECK_GE(opacity, 0.f);
DCHECK_LE(opacity, 1.f);
canvas->SaveLayerAlpha(SK_AlphaOPAQUE * opacity);
}
float outer_ring_stroke_width = outer_ring_stroke_width_.value_or(
GetOuterRingStrokeWidth(layer(), progress_));
gfx::RectF bounds(gfx::SizeF(layer()->size()));
bounds.Inset(gfx::InsetsF(outer_ring_stroke_width / 2.f));
SkPath path(CreateRoundedRectPath(
bounds, /*radius=*/std::min(bounds.width(), bounds.height()) / 2.f));
cc::PaintFlags flags;
flags.setAntiAlias(true);
flags.setStrokeCap(cc::PaintFlags::Cap::kRound_Cap);
flags.setStrokeWidth(outer_ring_stroke_width);
flags.setStyle(cc::PaintFlags::Style::kStroke_Style);
const SkColor color =
color_resolver_.Run(color_id_.value_or(cros_tokens::kCrosSysPrimary));
flags.setColor(SkColorSetA(
color,
SK_AlphaOPAQUE * GetOuterRingOpacity(progress_) * outer_ring_opacity));
// Outer ring track.
if (outer_ring_track_visible_) {
canvas->DrawPath(path, flags);
}
// Outer ring.
if (start == end) {
// If `start` == `end`, prevent the canvas from drawing the caps.
} else if (start < end) {
// If `start` <= `end`, only a single path segment is necessary.
canvas->DrawPath(CreatePathSegment(path, start, end), flags);
} else {
// If `start` > `end`, join two path segments as a single path and use that
// to draw the progress ring. This works around limitations of
// `SkPathMeasure` which require that `start` be <= `end`.
SkPath joined_path(CreatePathSegment(path, start, 1.0f));
joined_path.addPath(CreatePathSegment(path, 0.f, end));
canvas->DrawPath(joined_path, flags);
}
// The inner ring and inner icon should be absent once progress completes.
// This would occur if the progress ring is animating post completion.
if (progress_ == kProgressComplete)
return;
float inner_ring_stroke_width = GetInnerRingStrokeWidth(layer());
if (icon_animation) {
inner_ring_stroke_width *=
icon_animation->inner_ring_stroke_width_scale_factor();
}
const bool inner_ring_visible =
inner_ring_visible_ &&
!cc::MathUtil::IsWithinEpsilon(inner_ring_stroke_width, 0.f);
// Inner ring.
if (inner_ring_visible) {
bounds.Inset(gfx::InsetsF(
(outer_ring_stroke_width + inner_ring_stroke_width) / 2.f));
path = CreateRoundedRectPath(
bounds, /*radius=*/std::min(bounds.width(), bounds.height()) / 2.f);
flags.setColor(color);
flags.setStrokeWidth(inner_ring_stroke_width);
canvas->DrawPath(path, flags);
}
// Inner icon.
if (inner_icon_visible_) {
float inner_icon_size = GetInnerIconSize(layer());
gfx::RectF inner_icon_bounds(gfx::SizeF(layer()->size()));
inner_icon_bounds.ClampToCenteredSize(
gfx::SizeF(inner_icon_size, inner_icon_size));
if (icon_animation) {
inner_icon_bounds.Offset(
/*horizontal=*/0.f,
/*vertical=*/icon_animation->inner_icon_translate_y_scale_factor() *
inner_icon_size);
}
gfx::Transform transform;
transform.Translate(inner_icon_bounds.x(), inner_icon_bounds.y());
canvas->Transform(transform);
gfx::PaintVectorIcon(canvas, kHoldingSpaceDownloadIcon, inner_icon_size,
color);
}
}
void ProgressIndicator::UpdateVisualState() {
const auto previous_progress = progress_;
// Cache `progress_`.
progress_ = CalculateProgress();
if (progress_.has_value()) {
DCHECK_GE(progress_.value(), 0.f);
DCHECK_LE(progress_.value(), 1.f);
}
// Notify `progress_` changes.
if (progress_ != previous_progress)
progress_changed_callback_list_.Notify();
}
void ProgressIndicator::OnProgressIconAnimationChanged(
ProgressIconAnimation* animation) {
// Trigger repaint of this progress indicator on `animation` updates. Note
// that it is safe to use a raw pointer here since `this` owns the
// subscription.
if (animation) {
icon_animation_updated_subscription_ =
animation->AddAnimationUpdatedCallback(base::BindRepeating(
&ProgressIndicator::InvalidateLayer, base::Unretained(this)));
}
InvalidateLayer();
}
void ProgressIndicator::OnProgressRingAnimationChanged(
ProgressRingAnimation* animation) {
// Trigger repaint of this progress indicator on `animation` updates. Note
// that it is safe to use a raw pointer here since `this` owns the
// subscription.
if (animation) {
ring_animation_updated_subscription_ =
animation->AddAnimationUpdatedCallback(base::BindRepeating(
&ProgressIndicator::InvalidateLayer, base::Unretained(this)));
}
InvalidateLayer();
}
} // namespace ash
Codebase Browser
chromium