blob: 5db3b314cb8b769ac354916eec75f1861e866eed [file] [log] [blame]
// Copyright 2015 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.
#ifndef UI_COMPOSITOR_CALLBACK_LAYER_ANIMATION_OBSERVER_H_
#define UI_COMPOSITOR_CALLBACK_LAYER_ANIMATION_OBSERVER_H_
#include "base/callback.h"
#include "base/macros.h"
#include "ui/compositor/compositor_export.h"
#include "ui/compositor/layer_animation_observer.h"
namespace ui {
class LayerAnimationSequence;
// A LayerAnimationObserver that invokes a Callback when all observed
// LayerAnimationSequence's have started and finished.
//
// Example usage:
// class Foobar {
// // The Callback that will be invoked when all the animation sequences have
// // started.
// void AnimationStartedCallback(
// const CallbackLayerAnimationObserver& observer) {
// // Do stuff.
// }
//
// // The Callback that will be invoked when all the animation sequences have
// // finished.
// bool AnimationEndedCallback(
// const CallbackLayerAnimationObserver& observer) {
// // Do stuff.
// return true; // Returns true so that |observer| destroys itself.
// }
//
// // Example method that uses the CallbackLayerAnimationObserver.
// void Animate() {
// ui::LayerAnimator* animator_1 = layer_1->GetAnimator();
// ui::LayerAnimator* animator_2 = layer_2->GetAnimator();
// CallbackLayerAnimationObserver* observer =
// new CallbackLayerAnimationObserver(
// base::Bind(&Foobar::AnimationStartedCallback),
// base::Unretained(this));
// base::Bind(&Foobar::AnimationEndedCallback),
// base::Unretained(this));
// animator_1->AddObserver(observer);
// animator_2->AddObserver(observer);
//
// // Set up animation sequences on |animator_1| and |animator_2|.
//
// // The callback won't be invoked until SetActive() is called.
// observer->SetActive();
// }
// }
//
// TODO(bruthig): Unify the CallbackLayerAnimationObserver with the
// ImplicitAnimationObserver. (See www.crbug.com/542825).
class COMPOSITOR_EXPORT CallbackLayerAnimationObserver
: public ui::LayerAnimationObserver {
public:
// The Callback type that will be invoked when all animation sequences have
// been started.
typedef base::Callback<void(const CallbackLayerAnimationObserver&)>
AnimationStartedCallback;
// The Callback type that will be invoked when all animation sequences have
// finished. |this| will be destroyed after invoking the Callback if it
// returns true.
typedef base::Callback<bool(const CallbackLayerAnimationObserver&)>
AnimationEndedCallback;
// A dummy no-op AnimationStartedCallback.
static void DummyAnimationStartedCallback(
const CallbackLayerAnimationObserver&);
// A dummy no-op AnimationEndedCallback that will return
// |should_delete_observer|.
//
// Example usage:
//
// ui::CallbackLayerAnimationObserver* animation_observer =
// new ui::CallbackLayerAnimationObserver(
// base::Bind(&ui::CallbackLayerAnimationObserver::
// DummyAnimationStartedCallback),
// base::Bind(&ui::CallbackLayerAnimationObserver::
// DummyAnimationEndedCallback, false));
static bool DummyAnimationEndedCallback(
bool should_delete_observer,
const CallbackLayerAnimationObserver&);
// Create an instance that will invoke the |animation_started_callback| when
// the animation has started and the |animation_ended_callback| when the
// animation has ended.
CallbackLayerAnimationObserver(
AnimationStartedCallback animation_started_callback,
AnimationEndedCallback animation_ended_callback);
// Create an instance that will invoke the |animation_started_callback| when
// the animation has started and will delete |this| when the animations have
// ended if |should_delete_observer| is true.
CallbackLayerAnimationObserver(
AnimationStartedCallback animation_started_callback,
bool should_delete_observer);
// Create an instance that will invoke the |animation_ended_callback| when the
// animations have ended.
explicit CallbackLayerAnimationObserver(
AnimationEndedCallback animation_ended_callback);
~CallbackLayerAnimationObserver() override;
bool active() const { return active_; }
// The callbacks will not be invoked until SetActive() has been called. This
// allows each sequence to be attached before checking if the sequences have
// finished.
void SetActive();
int aborted_count() const { return aborted_count_; }
int successful_count() const { return successful_count_; }
// ui::LayerAnimationObserver:
void OnLayerAnimationStarted(ui::LayerAnimationSequence* sequence) override;
void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override;
void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override;
void OnLayerAnimationScheduled(ui::LayerAnimationSequence* sequence) override;
protected:
// ui::LayerAnimationObserver:
bool RequiresNotificationWhenAnimatorDestroyed() const override;
void OnAttachedToSequence(ui::LayerAnimationSequence* sequence) override;
void OnDetachedFromSequence(ui::LayerAnimationSequence* sequence) override;
private:
int GetNumSequencesCompleted();
// Checks if all attached sequences have been started and invokes
// |animation_started_callback_| if |active_| is true.
void CheckAllSequencesStarted();
// Checks if all attached sequences have completed and invokes
// |animation_ended_callback_| if |active_| is true.
void CheckAllSequencesCompleted();
// Allows the callbacks to be invoked when true.
bool active_ = false;
// The total number of animation sequences that have been attached.
int attached_sequence_count_ = 0;
// The total number of animation sequences that have been detached.
int detached_sequence_count_ = 0;
// The number of animation sequences that have been started.
int started_count_ = 0;
// The number of animation sequences that were aborted.
int aborted_count_ = 0;
// The number of animation sequences that completed successfully.
int successful_count_ = 0;
// The callback to invoke once all the animation sequences have been started.
AnimationStartedCallback animation_started_callback_;
// The callback to invoke once all the animation sequences have finished.
AnimationEndedCallback animation_ended_callback_;
// Set to true in the destructor (if non-NULL). Used to detect deletion while
// calling out.
bool* destroyed_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(CallbackLayerAnimationObserver);
};
} // namespace ui
#endif // UI_COMPOSITOR_CALLBACK_LAYER_ANIMATION_OBSERVER_H_