#include <animator.h>

Classes
class	Delegate

Public Member Functions
	Animator (Delegate &delegate, const TaskRunners &task_runners, std::unique_ptr< VsyncWaiter > waiter)

	~Animator ()

void	RequestFrame (bool regenerate_layer_trees=true)

void	OnAllViewsRendered ()
	Tells the Animator that all views that should render for this frame have been rendered. More...

void	Render (int64_t view_id, std::unique_ptr< flutter::LayerTree > layer_tree, float device_pixel_ratio)
	Tells the Animator that this frame needs to render another view. More...

const std::weak_ptr< VsyncWaiter >	GetVsyncWaiter () const

void	ScheduleSecondaryVsyncCallback (uintptr_t id, const fml::closure &callback)
	Schedule a secondary callback to be executed right after the main `VsyncWaiter::AsyncWaitForVsync` callback (which is added by `Animator::RequestFrame`). More...

void	EnqueueTraceFlowId (uint64_t trace_flow_id)

Friends
class	testing::ShellTest

Detailed Description

Executor of animations.

In conjunction with the |VsyncWaiter| it allows callers (typically Dart code) to schedule work that ends up generating a |LayerTree|.

Definition at line 30 of file animator.h.

Constructor & Destructor Documentation

◆ Animator()

flutter::Animator::Animator	(	Delegate &	delegate,
		const TaskRunners &	task_runners,
		std::unique_ptr< VsyncWaiter >	waiter
	)

Definition at line 25 of file animator.cc.

    : delegate_(delegate),
      task_runners_(task_runners),
      waiter_(std::move(waiter)),
#if SHELL_ENABLE_METAL
      layer_tree_pipeline_(std::make_shared<FramePipeline>(2)),
#else   // SHELL_ENABLE_METAL
      // TODO(dnfield): We should remove this logic and set the pipeline depth
      // back to 2 in this case. See
      // https://github.com/flutter/engine/pull/9132 for discussion.
      layer_tree_pipeline_(std::make_shared<FramePipeline>(
          task_runners.GetPlatformTaskRunner() ==
                  task_runners.GetRasterTaskRunner()
              ? 1
              : 2)),
#endif  // SHELL_ENABLE_METAL
      pending_frame_semaphore_(1),
      weak_factory_(this) {
}

◆ ~Animator()

flutter::Animator::~Animator ( )

default

Member Function Documentation

◆ EnqueueTraceFlowId()

void flutter::Animator::EnqueueTraceFlowId ( uint64_t trace_flow_id )

Definition at line 49 of file animator.cc.

                                                        {
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      [self = weak_factory_.GetWeakPtr(), trace_flow_id] {
        if (!self) {
          return;
        }
        self->trace_flow_ids_.push_back(trace_flow_id);
        self->ScheduleMaybeClearTraceFlowIds();
      });
}

◆ GetVsyncWaiter()

const std::weak_ptr< VsyncWaiter > flutter::Animator::GetVsyncWaiter ( ) const

Definition at line 213 of file animator.cc.

                                                              {
  std::weak_ptr<VsyncWaiter> weak = waiter_;
  return weak;
}

◆ OnAllViewsRendered()

void flutter::Animator::OnAllViewsRendered ( )

Tells the Animator that all views that should render for this frame have been rendered.

In regular frames, since all Render calls must take place during a vsync task, the Animator knows that all views have been rendered at the end of the vsync task, therefore calling this method is not needed.

However, the engine might decide to start it a bit earlier, for example, if the engine decides that no more views can be rendered, so that the rasterization can start a bit earlier.

This method is also useful in warm-up frames. In a warm up frame, Animator::Render is called out of vsync tasks, and Animator requires an explicit end-of-frame call to know when to send the layer trees to the pipeline.

For more about warm up frames, see PlatformDispatcher.scheduleWarmUpFrame.

Definition at line 291 of file animator.cc.

                                  {
  if (!layer_trees_tasks_.empty()) {
    EndFrame();
  }
}

◆ Render()

void flutter::Animator::Render	(	int64_t	view_id,
		std::unique_ptr< flutter::LayerTree >	layer_tree,
		float	device_pixel_ratio
	)

Tells the Animator that this frame needs to render another view.

      This method must be called during a vsync callback, or
      technically, between Animator::BeginFrame and Animator::EndFrame
      (both private methods). Otherwise, this call will be ignored.

Definition at line 188 of file animator.cc.

                                                {
  has_rendered_ = true;
 
  if (!frame_timings_recorder_) {
    // Framework can directly call render with a built scene. A major reason is
    // to render warm up frames.
    frame_timings_recorder_ = std::make_unique<FrameTimingsRecorder>();
    const fml::TimePoint placeholder_time = fml::TimePoint::Now();
    frame_timings_recorder_->RecordVsync(placeholder_time, placeholder_time);
    frame_timings_recorder_->RecordBuildStart(placeholder_time);
  }
 
  TRACE_EVENT_WITH_FRAME_NUMBER(frame_timings_recorder_, "flutter",
                                "Animator::Render", /*flow_id_count=*/0,
                                /*flow_ids=*/nullptr);
 
  // Only inserts if the view ID has not been rendered before, ignoring
  // duplicate Render calls.
  layer_trees_tasks_.try_emplace(
      view_id, std::make_unique<LayerTreeTask>(view_id, std::move(layer_tree),
                                               device_pixel_ratio));
}

◆ RequestFrame()

void flutter::Animator::RequestFrame ( bool regenerate_layer_trees = true )

Definition at line 239 of file animator.cc.

                                                       {
  if (regenerate_layer_trees && !regenerate_layer_trees_) {
    // This event will be closed by BeginFrame. BeginFrame will only be called
    // if regenerating the layer trees. If a frame has been requested to update
    // an external texture, this will be false and no BeginFrame call will
    // happen.
    TRACE_EVENT_ASYNC_BEGIN0("flutter", "Frame Request Pending",
                             frame_request_number_);
    regenerate_layer_trees_ = true;
  }
 
  if (!pending_frame_semaphore_.TryWait()) {
    // Multiple calls to Animator::RequestFrame will still result in a
    // single request to the VsyncWaiter.
    return;
  }
 
  // The AwaitVSync is going to call us back at the next VSync. However, we want
  // to be reasonably certain that the UI thread is not in the middle of a
  // particularly expensive callout. We post the AwaitVSync to run right after
  // an idle. This does NOT provide a guarantee that the UI thread has not
  // started an expensive operation right after posting this message however.
  // To support that, we need edge triggered wakes on VSync.
 
  task_runners_.GetUITaskRunner()->PostTask(
      [self = weak_factory_.GetWeakPtr()]() {
        if (!self) {
          return;
        }
        self->AwaitVSync();
      });
  frame_scheduled_ = true;
}

◆ ScheduleSecondaryVsyncCallback()

void flutter::Animator::ScheduleSecondaryVsyncCallback	(	uintptr_t	id,
		const fml::closure &	callback
	)

Schedule a secondary callback to be executed right after the main VsyncWaiter::AsyncWaitForVsync callback (which is added by Animator::RequestFrame).

Like the callback in AsyncWaitForVsync, this callback is only scheduled to be called once, and it's supposed to be called in the UI thread. If there is no AsyncWaitForVsync callback (Animator::RequestFrame is not called), this secondary callback will still be executed at vsync.

This callback is used to provide the vsync signal needed by SmoothPointerDataDispatcher, and for our own flow events.

See also: PointerDataDispatcher::ScheduleSecondaryVsyncCallback.

Definition at line 297 of file animator.cc.

                                                                          {
  waiter_->ScheduleSecondaryCallback(id, callback);
}

Friends And Related Function Documentation

◆ testing::ShellTest

friend class testing::ShellTest

friend

Definition at line 153 of file animator.h.

The documentation for this class was generated from the following files:

shell/common/animator.h
shell/common/animator.cc

Classes

Public Member Functions

Friends