#include <shell.h>

Inheritance diagram for flutter::Shell:

Public Types
template<class T >
using	CreateCallback = std::function< std::unique_ptr< T >(Shell &)>

typedef std::function< std::unique_ptr< Engine >(Engine::Delegate &delegate, const PointerDataDispatcherMaker &dispatcher_maker, DartVM &vm, fml::RefPtr< const DartSnapshot > isolate_snapshot, TaskRunners task_runners, const PlatformData &platform_data, Settings settings, std::unique_ptr< Animator > animator, fml::WeakPtr< IOManager > io_manager, fml::RefPtr< SkiaUnrefQueue > unref_queue, fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > snapshot_delegate, std::shared_ptr< VolatilePathTracker > volatile_path_tracker, const std::shared_ptr< fml::SyncSwitch > &gpu_disabled_switch, impeller::RuntimeStageBackend runtime_stage_type)>	EngineCreateCallback

Public Types inherited from flutter::PlatformView::Delegate
using	AddViewCallback = PlatformView::AddViewCallback

using	RemoveViewCallback = PlatformView::RemoveViewCallback

using	KeyDataResponse = std::function< void(bool)>

Public Types inherited from flutter::ServiceProtocol::Handler
using	ServiceProtocolMap = std::map< std::string_view, std::string_view >

Public Member Functions
	~Shell ()
	Destroys the shell. This is a synchronous operation and synchronous barrier blocks are introduced on the various threads to ensure shutdown of all shell sub-components before this method returns.

std::unique_ptr< Shell >	Spawn (RunConfiguration run_configuration, const std::string &initial_route, const CreateCallback< PlatformView > &on_create_platform_view, const CreateCallback< Rasterizer > &on_create_rasterizer) const
	Creates one Shell from another Shell where the created Shell takes the opportunity to share any internal components it can. This results is a Shell that has a smaller startup time cost and a smaller memory footprint than an Shell created with the Create function.

void	RunEngine (RunConfiguration run_configuration)
	Starts an isolate for the given RunConfiguration.

void	RunEngine (RunConfiguration run_configuration, const std::function< void(Engine::RunStatus)> &result_callback)
	Starts an isolate for the given RunConfiguration. The result_callback will be called with the status of the operation.

const Settings &	GetSettings () const override

const TaskRunners &	GetTaskRunners () const override
	If callers wish to interact directly with any shell subcomponents, they must (on the platform thread) obtain a task runner that the component is designed to run on and a weak pointer to that component. They may then post a task to that task runner, do the validity check on that task runner before performing any operation on that component. This accessor allows callers to access the task runners for this shell.

const fml::RefPtr< fml::RasterThreadMerger >	GetParentRasterThreadMerger () const override
	Getting the raster thread merger from parent shell, it can be a null RefPtr when it's a root Shell or the embedder_->SupportsDynamicThreadMerging() returns false.

fml::TaskRunnerAffineWeakPtr< Rasterizer >	GetRasterizer () const
	Rasterizers may only be accessed on the raster task runner.

fml::WeakPtr< Engine >	GetEngine ()
	Engines may only be accessed on the UI thread. This method is deprecated, and implementers should instead use other API available on the Shell or the PlatformView.

fml::WeakPtr< PlatformView >	GetPlatformView ()
	Platform views may only be accessed on the platform task runner.

fml::WeakPtr< ShellIOManager >	GetIOManager ()
	The IO Manager may only be accessed on the IO task runner.

void	NotifyLowMemoryWarning () const
	Used by embedders to notify that there is a low memory warning. The shell will attempt to purge caches. Current, only the rasterizer cache is purged.

bool	IsSetup () const
	Used by embedders to check if all shell subcomponents are initialized. It is the embedder's responsibility to make this call before accessing any other shell method. A shell that is not set up must be discarded and another one created with updated settings.

Rasterizer::Screenshot	Screenshot (Rasterizer::ScreenshotType type, bool base64_encode)
	Captures a screenshot and optionally Base64 encodes the data of the last layer tree rendered by the rasterizer in this shell.

fml::Status	WaitForFirstFrame (fml::TimeDelta timeout)
	Pauses the calling thread until the first frame is presented.

bool	ReloadSystemFonts ()
	Used by embedders to reload the system fonts in FontCollection. It also clears the cached font families and send system channel message to framework to rebuild affected widgets.

std::optional< DartErrorCode >	GetUIIsolateLastError () const
	Used by embedders to get the last error from the Dart UI Isolate, if one exists.

bool	EngineHasLivePorts () const
	Used by embedders to check if the Engine is running and has any live ports remaining. For example, the Flutter tester uses this method to check whether it should continue to wait for a running test or not.

std::shared_ptr< const fml::SyncSwitch >	GetIsGpuDisabledSyncSwitch () const override
	Accessor for the disable GPU SyncSwitch.

void	SetGpuAvailability (GpuAvailability availability)
	Marks the GPU as available or unavailable.

DartVM *	GetDartVM ()
	Get a pointer to the Dart VM used by this running shell instance.

void	OnDisplayUpdates (std::vector< std::unique_ptr< Display > > displays)
	Notifies the display manager of the updates.

double	GetMainDisplayRefreshRate ()
	Queries the `DisplayManager` for the main display refresh rate.

void	RegisterImageDecoder (ImageGeneratorFactory factory, int32_t priority)
	Install a new factory that can match against and decode image data.

const std::shared_ptr< PlatformMessageHandler > &	GetPlatformMessageHandler () const override
	Returns the delegate object that handles PlatformMessage's from Flutter to the host platform (and its responses).

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

const std::shared_ptr< fml::ConcurrentTaskRunner >	GetConcurrentWorkerTaskRunner () const

Public Member Functions inherited from flutter::PlatformView::Delegate
virtual void	OnPlatformViewRegisterTexture (std::shared_ptr< Texture > texture)=0
	Notifies the delegate that the embedder has specified a texture that it want the rasterizer to composite within the Flutter layer tree. All textures must have a unique identifier. When the rasterizer encounters an external texture within its hierarchy, it gives the embedder a chance to update that texture on the raster thread before it composites the same on-screen.

Static Public Member Functions
static std::unique_ptr< Shell >	Create (const PlatformData &platform_data, const TaskRunners &task_runners, Settings settings, const CreateCallback< PlatformView > &on_create_platform_view, const CreateCallback< Rasterizer > &on_create_rasterizer, bool is_gpu_disabled=false)
	Creates a shell instance using the provided settings. The callbacks to create the various shell subcomponents will be called on the appropriate threads before this method returns. If this is the first instance of a shell in the process, this call also bootstraps the Dart VM.

static std::pair< DartVMRef, fml::RefPtr< const DartSnapshot > >	InferVmInitDataFromSettings (Settings &settings)

Private Member Functions
void	OnPlatformViewCreated (std::unique_ptr< Surface > surface) override
	Notifies the delegate that the platform view was created with the given render surface. This surface is platform (iOS, Android) and client-rendering API (OpenGL, Software, Metal, Vulkan) specific. This is usually a sign to the rasterizer to set up and begin rendering to that surface.

void	OnPlatformViewDestroyed () override
	Notifies the delegate that the platform view was destroyed. This is usually a sign to the rasterizer to suspend rendering a previously configured surface and collect any intermediate resources.

void	OnPlatformViewScheduleFrame () override
	Notifies the delegate that the platform needs to schedule a frame to regenerate the layer tree and redraw the surface.

void	OnPlatformViewAddView (int64_t view_id, const ViewportMetrics &viewport_metrics, AddViewCallback callback) override
	Allocate resources for a new non-implicit view and inform Dart about the view, and on success, schedules a new frame.

void	OnPlatformViewRemoveView (int64_t view_id, RemoveViewCallback callback) override
	Deallocate resources for a removed view and inform Dart about the removal.

void	OnPlatformViewSetViewportMetrics (int64_t view_id, const ViewportMetrics &metrics) override
	Notifies the delegate the viewport metrics of a view have been updated. The rasterizer will need to be reconfigured to render the frame in the updated viewport metrics.

void	OnPlatformViewDispatchPlatformMessage (std::unique_ptr< PlatformMessage > message) override
	Notifies the delegate that the platform has dispatched a platform message from the embedder to the Flutter application. This message must be forwarded to the running isolate hosted by the engine on the UI thread.

void	OnPlatformViewDispatchPointerDataPacket (std::unique_ptr< PointerDataPacket > packet) override
	Notifies the delegate that the platform view has encountered a pointer event. This pointer event needs to be forwarded to the running root isolate hosted by the engine on the UI thread.

void	OnPlatformViewDispatchSemanticsAction (int32_t node_id, SemanticsAction action, fml::MallocMapping args) override
	Notifies the delegate that the platform view has encountered an accessibility related action on the specified node. This event must be forwarded to the running root isolate hosted by the engine on the UI thread.

void	OnPlatformViewSetSemanticsEnabled (bool enabled) override
	Notifies the delegate that the embedder has expressed an opinion about whether the accessibility tree needs to be enabled or disabled. This information needs to be forwarded to the root isolate running on the UI thread.

void	OnPlatformViewSetAccessibilityFeatures (int32_t flags) override
	Notifies the delegate that the embedder has expressed an opinion about the features to enable in the accessibility tree.

void	OnPlatformViewRegisterTexture (std::shared_ptr< flutter::Texture > texture) override

void	OnPlatformViewUnregisterTexture (int64_t texture_id) override
	Notifies the delegate that the embedder will no longer attempt to composite the specified texture within the layer tree. This allows the rasterizer to collect associated resources.

void	OnPlatformViewMarkTextureFrameAvailable (int64_t texture_id) override
	Notifies the delegate that the embedder has updated the contents of the texture with the specified identifier. Typically, Flutter will only render a frame if there is an updated layer tree. However, in cases where the layer tree is static but one of the externally composited textures has been updated by the embedder, the embedder needs to notify the rasterizer to render a new frame. In such cases, the existing layer tree may be reused with the frame composited with all updated external textures.

void	OnPlatformViewSetNextFrameCallback (const fml::closure &closure) override
	Notifies the delegate that the specified callback needs to be invoked after the rasterizer is done rendering the next frame. This callback will be called on the render thread and it is caller responsibility to perform any re-threading as necessary. Due to the asynchronous nature of rendering in Flutter, embedders usually add a placeholder over the contents in which Flutter is going to render when Flutter is first initialized. This callback may be used as a signal to remove that placeholder.

const Settings &	OnPlatformViewGetSettings () const override
	Called by the platform view on the platform thread to get the settings object associated with the platform view instance.

void	LoadDartDeferredLibrary (intptr_t loading_unit_id, std::unique_ptr< const fml::Mapping > snapshot_data, std::unique_ptr< const fml::Mapping > snapshot_instructions) override
	Loads the dart shared library into the dart VM. When the dart library is loaded successfully, the dart future returned by the originating loadLibrary() call completes.

void	LoadDartDeferredLibraryError (intptr_t loading_unit_id, const std::string error_message, bool transient) override
	Indicates to the dart VM that the request to load a deferred library with the specified loading unit id has failed.

void	UpdateAssetResolverByType (std::unique_ptr< AssetResolver > updated_asset_resolver, AssetResolver::AssetResolverType type) override
	Replaces the asset resolver handled by the engine's AssetManager of the specified `type` with `updated_asset_resolver`. The matching AssetResolver is removed and replaced with `updated_asset_resolvers`.

void	OnAnimatorBeginFrame (fml::TimePoint frame_target_time, uint64_t frame_number) override

void	OnAnimatorNotifyIdle (fml::TimeDelta deadline) override

void	OnAnimatorUpdateLatestFrameTargetTime (fml::TimePoint frame_target_time) override

void	OnAnimatorDraw (std::shared_ptr< FramePipeline > pipeline) override

void	OnAnimatorDrawLastLayerTrees (std::unique_ptr< FrameTimingsRecorder > frame_timings_recorder) override

void	OnEngineUpdateSemantics (SemanticsNodeUpdates update, CustomAccessibilityActionUpdates actions) override
	When the accessibility tree has been updated by the Flutter application, this new information needs to be conveyed to the underlying platform. The engine delegates this task to the shell via this call. The engine cannot access the underlying platform directly because of threading considerations. Most platform specific APIs to convey accessibility information are only safe to access on the platform task runner while the engine is running on the UI task runner.

void	OnEngineHandlePlatformMessage (std::unique_ptr< PlatformMessage > message) override
	When the Flutter application has a message to send to the underlying platform, the message needs to be forwarded to the platform on the appropriate thread (via the platform task runner). The engine delegates this task to the shell via this method.

void	OnPreEngineRestart () override
	Notifies the delegate that the root isolate of the application is about to be discarded and a new isolate with the same runtime started in its place. This should only happen in the Flutter "debug" runtime mode in the cold-restart scenario. The embedder may need to reset native resource in response to the restart.

void	OnRootIsolateCreated () override
	Notifies the shell that the root isolate is created. Currently, this information is to add to the service protocol list of available root isolates running in the VM and their names so that the appropriate isolate can be selected in the tools for debugging and instrumentation.

void	UpdateIsolateDescription (const std::string isolate_name, int64_t isolate_port) override
	Notifies the shell of the name of the root isolate and its port when that isolate is launched, restarted (in the cold-restart scenario) or the application itself updates the name of the root isolate (via `PlatformDispatcher.setIsolateDebugName` in `platform_dispatcher.dart`). The name of the isolate is meaningless to the engine but is used in instrumentation and tooling. Currently, this information is to update the service protocol list of available root isolates running in the VM and their names so that the appropriate isolate can be selected in the tools for debugging and instrumentation.

void	SetNeedsReportTimings (bool value) override
	Notifies the shell that the application has an opinion about whether its frame timings need to be reported backed to it. Due to the asynchronous nature of rendering in Flutter, it is not possible for the application to determine the total time it took to render a specific frame. While the layer-tree is constructed on the UI thread, it needs to be rendering on the raster thread. Dart code cannot execute on this thread. So any instrumentation about the frame times gathered on this thread needs to be aggregated and sent back to the UI thread for processing in Dart.

std::unique_ptr< std::vector< std::string > >	ComputePlatformResolvedLocale (const std::vector< std::string > &supported_locale_data) override
	Directly invokes platform-specific APIs to compute the locale the platform would have natively resolved to.

void	RequestDartDeferredLibrary (intptr_t loading_unit_id) override
	Invoked when the Dart VM requests that a deferred library be loaded. Notifies the engine that the deferred library identified by the specified loading unit id should be downloaded and loaded into the Dart VM via `LoadDartDeferredLibrary`

fml::TimePoint	GetCurrentTimePoint () override
	Returns the current fml::TimePoint. This method is primarily provided to allow tests to control Any methods that rely on advancing the clock.

void	OnEngineChannelUpdate (std::string name, bool listening) override
	Invoked when a listener is registered on a platform channel.

double	GetScaledFontSize (double unscaled_font_size, int configuration_id) const override
	Synchronously invokes platform-specific APIs to apply the system text scaling on the given unscaled font size.

void	OnFrameRasterized (const FrameTiming &) override
	Notifies the delegate that a frame has been rendered. The rasterizer collects profiling information for each part of the frame workload. This profiling information is made available to the delegate for forwarding to subsystems interested in collecting such profiles. Currently, the shell (the delegate) forwards this to the engine where Dart code can react to this information.

fml::Milliseconds	GetFrameBudget () override

fml::TimePoint	GetLatestFrameTargetTime () const override

bool	ShouldDiscardLayerTree (int64_t view_id, const flutter::LayerTree &tree) override

fml::RefPtr< fml::TaskRunner >	GetServiceProtocolHandlerTaskRunner (std::string_view method) const override

bool	HandleServiceProtocolMessage (std::string_view method, const ServiceProtocolMap &params, rapidjson::Document *response) override

ServiceProtocol::Handler::Description	GetServiceProtocolDescription () const override

size_t	GetResourceCacheLimit () override

Friends
class	testing::ShellTest

Additional Inherited Members
Protected Member Functions inherited from flutter::ResourceCacheLimitItem
virtual	~ResourceCacheLimitItem ()=default

Detailed Description

Perhaps the single most important class in the Flutter engine repository. When embedders create a Flutter application, they are referring to the creation of an instance of a shell. Creation and destruction of the shell is synchronous and the embedder only holds a unique pointer to the shell. The shell does not create the threads its primary components run on. Instead, it is the embedder's responsibility to create threads and give the shell task runners for those threads. Due to deterministic destruction of the shell, the embedder can terminate all threads immediately after collecting the shell. The shell must be created and destroyed on the same thread, but, different shells (i.e. a separate instances of a Flutter application) may be run on different threads simultaneously. The task runners themselves do not have to be unique. If all task runner references given to the shell during shell creation point to the same task runner, the Flutter application is effectively single threaded.

The shell is the central nervous system of the Flutter application. None of the shell components are thread safe and must be created, accessed and destroyed on the same thread. To interact with one another, the various components delegate to the shell for communication. Instead of using back pointers to the shell, a delegation pattern is used by all components that want to communicate with one another. Because of this, the shell implements the delegate interface for all these components.

All shell methods accessed by the embedder may only be called on the platform task runner. In case the embedder wants to directly access a shell subcomponent, it is the embedder's responsibility to acquire a weak pointer to that component and post a task to the task runner used by the component to access its methods. The shell must also be destroyed on the platform task runner.

There is no explicit API to bootstrap and shutdown the Dart VM. The first instance of the shell in the process bootstraps the Dart VM and the destruction of the last shell instance destroys the same. Since different shells may be created and destroyed on different threads. VM bootstrap may happen on one thread but its collection on another. This behavior is thread safe.

Definition at line 111 of file shell.h.

Member Typedef Documentation

◆ CreateCallback

template<class T >

using flutter::Shell::CreateCallback = std::function<std::unique_ptr<T>(Shell&)>

Definition at line 119 of file shell.h.

◆ EngineCreateCallback

typedef std::function<std::unique_ptr<Engine>( Engine::Delegate& delegate, const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm, fml::RefPtr<const DartSnapshot> isolate_snapshot, TaskRunners task_runners, const PlatformData& platform_data, Settings settings, std::unique_ptr<Animator> animator, fml::WeakPtr<IOManager> io_manager, fml::RefPtr<SkiaUnrefQueue> unref_queue, fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate, std::shared_ptr<VolatilePathTracker> volatile_path_tracker, const std::shared_ptr<fml::SyncSwitch>& gpu_disabled_switch, impeller::RuntimeStageBackend runtime_stage_type)> flutter::Shell::EngineCreateCallback

Definition at line 135 of file shell.h.

Constructor & Destructor Documentation

◆ ~Shell()

flutter::Shell::~Shell ( )

Destroys the shell. This is a synchronous operation and synchronous barrier blocks are introduced on the various threads to ensure shutdown of all shell sub-components before this method returns.

Definition at line 527 of file shell.cc.

              {
  PersistentCache::GetCacheForProcess()->RemoveWorkerTaskRunner(
      task_runners_.GetIOTaskRunner());
 
  vm_->GetServiceProtocol()->RemoveHandler(this);
 
  fml::AutoResetWaitableEvent platiso_latch, ui_latch, gpu_latch,
      platform_latch, io_latch;
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      fml::MakeCopyable([this, &platiso_latch]() mutable {
        engine_->ShutdownPlatformIsolates();
        platiso_latch.Signal();
      }));
  platiso_latch.Wait();
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      fml::MakeCopyable([this, &ui_latch]() mutable {
        engine_.reset();
        ui_latch.Signal();
      }));
  ui_latch.Wait();
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetRasterTaskRunner(),
      fml::MakeCopyable(
          [this, rasterizer = std::move(rasterizer_), &gpu_latch]() mutable {
            rasterizer.reset();
            this->weak_factory_gpu_.reset();
            gpu_latch.Signal();
          }));
  gpu_latch.Wait();
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetIOTaskRunner(),
      fml::MakeCopyable([io_manager = std::move(io_manager_),
                         platform_view = platform_view_.get(),
                         &io_latch]() mutable {
        io_manager.reset();
        if (platform_view) {
          platform_view->ReleaseResourceContext();
        }
        io_latch.Signal();
      }));
 
  io_latch.Wait();
 
  // The platform view must go last because it may be holding onto platform side
  // counterparts to resources owned by subsystems running on other threads. For
  // example, the NSOpenGLContext on the Mac.
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      fml::MakeCopyable([platform_view = std::move(platform_view_),
                         &platform_latch]() mutable {
        platform_view.reset();
        platform_latch.Signal();
      }));
  platform_latch.Wait();
}

Member Function Documentation

◆ ComputePlatformResolvedLocale()

std::unique_ptr< std::vector< std::string > > flutter::Shell::ComputePlatformResolvedLocale ( const std::vector< std::string > & supported_locale_data )

overrideprivatevirtual

Directly invokes platform-specific APIs to compute the locale the platform would have natively resolved to.

Parameters

[in] supported_locale_data The vector of strings that represents the locales supported by the app. Each locale consists of three strings: languageCode, countryCode, and scriptCode in that order.

Returns: A vector of 3 strings languageCode, countryCode, and scriptCode that represents the locale selected by the platform. Empty strings mean the value was unassigned. Empty vector represents a null locale.

Implements flutter::Engine::Delegate.

Definition at line 1475 of file shell.cc.

                                                       {
  return platform_view_->ComputePlatformResolvedLocales(supported_locale_data);
}

◆ Create()

std::unique_ptr< Shell > flutter::Shell::Create	(	const PlatformData &	platform_data,
		const TaskRunners &	task_runners,
		Settings	settings,
		const CreateCallback< PlatformView > &	on_create_platform_view,
		const CreateCallback< Rasterizer > &	on_create_rasterizer,
		bool	is_gpu_disabled = `false`
	)

static

Creates a shell instance using the provided settings. The callbacks to create the various shell subcomponents will be called on the appropriate threads before this method returns. If this is the first instance of a shell in the process, this call also bootstraps the Dart VM.

Note: The root isolate which will run this Shell's Dart code takes its instructions from the passed in settings. This allows embedders to host multiple Shells with different Dart code.

Parameters

[in]	task_runners	The task runners
[in]	settings	The settings
[in]	on_create_platform_view	The callback that must return a platform view. This will be called on the platform task runner before this method returns.
[in]	on_create_rasterizer	That callback that must provide a valid rasterizer. This will be called on the render task runner before this method returns.
[in]	is_gpu_disabled	The default value for the switch that turns off the GPU.

Returns: A full initialized shell if the settings and callbacks are valid. The root isolate has been created but not yet launched. It may be launched by obtaining the engine weak pointer and posting a task onto the UI task runner with a valid run configuration to run the isolate. The embedder must always check the validity of the shell (using the IsSetup call) immediately after getting a pointer to it.

Definition at line 167 of file shell.cc.

                          {
  // This must come first as it initializes tracing.
  PerformInitializationTasks(settings);
 
  TRACE_EVENT0("flutter", "Shell::Create");
 
  auto [vm, isolate_snapshot] = InferVmInitDataFromSettings(settings);
  auto resource_cache_limit_calculator =
      std::make_shared<ResourceCacheLimitCalculator>(
          settings.resource_cache_max_bytes_threshold);
 
  return CreateWithSnapshot(platform_data,                     //
                            task_runners,                      //
                            /*parent_thread_merger=*/nullptr,  //
                            /*parent_io_manager=*/nullptr,     //
                            resource_cache_limit_calculator,   //
                            settings,                          //
                            std::move(vm),                     //
                            std::move(isolate_snapshot),       //
                            on_create_platform_view,           //
                            on_create_rasterizer,              //
                            CreateEngine, is_gpu_disabled);
}

◆ EngineHasLivePorts()

bool flutter::Shell::EngineHasLivePorts ( ) const

Used by embedders to check if the Engine is running and has any live ports remaining. For example, the Flutter tester uses this method to check whether it should continue to wait for a running test or not.

Returns: Returns if the shell has an engine and the engine has any live Dart ports.

Definition at line 713 of file shell.cc.

                                     {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (!weak_engine_) {
    return false;
  }
 
  return weak_engine_->UIIsolateHasLivePorts();
}

◆ GetConcurrentWorkerTaskRunner()

const std::shared_ptr< fml::ConcurrentTaskRunner > flutter::Shell::GetConcurrentWorkerTaskRunner ( ) const

Definition at line 2316 of file shell.cc.

                                           {
  FML_DCHECK(vm_);
  if (!vm_) {
    return nullptr;
  }
  return vm_->GetConcurrentWorkerTaskRunner();
}

◆ GetCurrentTimePoint()

fml::TimePoint flutter::Shell::GetCurrentTimePoint ( )

overrideprivatevirtual

Returns the current fml::TimePoint. This method is primarily provided to allow tests to control Any methods that rely on advancing the clock.

Implements flutter::Engine::Delegate.

Definition at line 2299 of file shell.cc.

                                        {
  return fml::TimePoint::Now();
}

◆ GetDartVM()

DartVM * flutter::Shell::GetDartVM ( )

Get a pointer to the Dart VM used by this running shell instance.

Returns: The Dart VM pointer.

Definition at line 828 of file shell.cc.

                         {
  return &vm_;
}

◆ GetEngine()

fml::WeakPtr< Engine > flutter::Shell::GetEngine ( )

Engines may only be accessed on the UI thread. This method is deprecated, and implementers should instead use other API available on the Shell or the PlatformView.

Returns: A weak pointer to the engine.

Definition at line 813 of file shell.cc.

                                    {
  FML_DCHECK(is_set_up_);
  return weak_engine_;
}

◆ GetFrameBudget()

fml::Milliseconds flutter::Shell::GetFrameBudget ( )

overrideprivatevirtual

Time limit for a smooth frame.

See: DisplayManager::GetMainDisplayRefreshRate.

Implements flutter::Rasterizer::Delegate.

Definition at line 1628 of file shell.cc.

                                      {
  double display_refresh_rate = display_manager_->GetMainDisplayRefreshRate();
  if (display_refresh_rate > 0) {
    return fml::RefreshRateToFrameBudget(display_refresh_rate);
  } else {
    return fml::kDefaultFrameBudget;
  }
}

◆ GetIOManager()

fml::WeakPtr< ShellIOManager > flutter::Shell::GetIOManager ( )

The IO Manager may only be accessed on the IO task runner.

Returns: A weak pointer to the IO manager.

Definition at line 823 of file shell.cc.

                                               {
  FML_DCHECK(is_set_up_);
  return io_manager_->GetWeakPtr();
}

◆ GetIsGpuDisabledSyncSwitch()

std::shared_ptr< const fml::SyncSwitch > flutter::Shell::GetIsGpuDisabledSyncSwitch ( ) const

overridevirtual

Accessor for the disable GPU SyncSwitch.

Implements flutter::Rasterizer::Delegate.

Definition at line 2249 of file shell.cc.

          {
  return is_gpu_disabled_sync_switch_;
}

◆ GetLatestFrameTargetTime()

fml::TimePoint flutter::Shell::GetLatestFrameTargetTime ( ) const

overrideprivatevirtual

Target time for the latest frame. See also Shell::OnAnimatorBeginFrame for when this time gets updated.

Implements flutter::Rasterizer::Delegate.

Definition at line 1637 of file shell.cc.

                                                   {
  std::scoped_lock time_recorder_lock(time_recorder_mutex_);
  FML_CHECK(latest_frame_target_time_.has_value())
      << "GetLatestFrameTargetTime called before OnAnimatorBeginFrame";
  // Covered by FML_CHECK().
  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
  return latest_frame_target_time_.value();
}

◆ GetMainDisplayRefreshRate()

double flutter::Shell::GetMainDisplayRefreshRate ( )

Queries the DisplayManager for the main display refresh rate.

Definition at line 1862 of file shell.cc.

                                        {
  return display_manager_->GetMainDisplayRefreshRate();
}

◆ GetParentRasterThreadMerger()

const fml::RefPtr< fml::RasterThreadMerger > flutter::Shell::GetParentRasterThreadMerger ( ) const

overridevirtual

Getting the raster thread merger from parent shell, it can be a null RefPtr when it's a root Shell or the embedder_->SupportsDynamicThreadMerging() returns false.

Returns: The raster thread merger used by the parent shell.

Implements flutter::Rasterizer::Delegate.

Definition at line 803 of file shell.cc.

          {
  return parent_raster_thread_merger_;
}

◆ GetPlatformMessageHandler()

const std::shared_ptr< PlatformMessageHandler > & flutter::Shell::GetPlatformMessageHandler ( ) const

overridevirtual

Returns the delegate object that handles PlatformMessage's from Flutter to the host platform (and its responses).

Implements flutter::Engine::Delegate.

Definition at line 2304 of file shell.cc.

                                       {
  return platform_message_handler_;
}

◆ GetPlatformView()

fml::WeakPtr< PlatformView > flutter::Shell::GetPlatformView ( )

Platform views may only be accessed on the platform task runner.

Returns: A weak pointer to the platform view.

Definition at line 818 of file shell.cc.

                                                {
  FML_DCHECK(is_set_up_);
  return weak_platform_view_;
}

◆ GetRasterizer()

fml::TaskRunnerAffineWeakPtr< Rasterizer > flutter::Shell::GetRasterizer ( ) const

Rasterizers may only be accessed on the raster task runner.

Returns: A weak pointer to the rasterizer.

Definition at line 808 of file shell.cc.

                                                                  {
  FML_DCHECK(is_set_up_);
  return weak_rasterizer_;
}

◆ GetResourceCacheLimit()

size_t flutter::Shell::GetResourceCacheLimit ( )

inlineoverrideprivatevirtual

Implements flutter::ResourceCacheLimitItem.

Definition at line 778 of file shell.h.

778{ return resource_cache_limit_; };

◆ GetScaledFontSize()

double flutter::Shell::GetScaledFontSize	(	double	unscaled_font_size,
		int	configuration_id
	)		const

overrideprivatevirtual

Synchronously invokes platform-specific APIs to apply the system text scaling on the given unscaled font size.

Platforms that support this feature (currently it's only implemented for Android SDK level 34+) will send a valid configuration_id to potential callers, before this method can be called.

Parameters

[in]	unscaled_font_size	The unscaled font size specified by the app developer. The value is in logical pixels, and is guaranteed to be finite and non-negative.
[in]	configuration_id	The unique id of the configuration to use for computing the scaled font size.

Returns: The scaled font size in logical pixels, or -1 when the given configuration_id did not match a valid configuration.

Implements flutter::Engine::Delegate.

Definition at line 1534 of file shell.cc.

                                                            {
  return platform_view_->GetScaledFontSize(unscaled_font_size,
                                           configuration_id);
}

◆ GetServiceProtocolDescription()

ServiceProtocol::Handler::Description flutter::Shell::GetServiceProtocolDescription ( ) const

overrideprivatevirtual

Implements flutter::ServiceProtocol::Handler.

Definition at line 1679 of file shell.cc.

          {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (!weak_engine_) {
    return ServiceProtocol::Handler::Description();
  }
 
  return {
      weak_engine_->GetUIIsolateMainPort(),
      weak_engine_->GetUIIsolateName(),
  };
}

◆ GetServiceProtocolHandlerTaskRunner()

fml::RefPtr< fml::TaskRunner > flutter::Shell::GetServiceProtocolHandlerTaskRunner ( std::string_view method ) const

overrideprivatevirtual

Implements flutter::ServiceProtocol::Handler.

Definition at line 1656 of file shell.cc.

                                 {
  FML_DCHECK(is_set_up_);
  auto found = service_protocol_handlers_.find(method);
  if (found != service_protocol_handlers_.end()) {
    return found->second.first;
  }
  return task_runners_.GetUITaskRunner();
}

◆ GetSettings()

const Settings & flutter::Shell::GetSettings ( ) const

overridevirtual

Returns: The settings used to launch this shell.

Implements flutter::Rasterizer::Delegate.

Definition at line 795 of file shell.cc.

                                         {
  return settings_;
}

◆ GetTaskRunners()

const TaskRunners & flutter::Shell::GetTaskRunners ( ) const

overridevirtual

If callers wish to interact directly with any shell subcomponents, they must (on the platform thread) obtain a task runner that the component is designed to run on and a weak pointer to that component. They may then post a task to that task runner, do the validity check on that task runner before performing any operation on that component. This accessor allows callers to access the task runners for this shell.

Returns: The task runners current in use by the shell.

Implements flutter::Rasterizer::Delegate.

Definition at line 799 of file shell.cc.

                                               {
  return task_runners_;
}

◆ GetUIIsolateLastError()

std::optional< DartErrorCode > flutter::Shell::GetUIIsolateLastError ( ) const

Used by embedders to get the last error from the Dart UI Isolate, if one exists.

Returns: Returns the last error code from the UI Isolate.

Definition at line 693 of file shell.cc.

                                                              {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (!weak_engine_) {
    return std::nullopt;
  }
  switch (weak_engine_->GetUIIsolateLastError()) {
    case tonic::kCompilationErrorType:
      return DartErrorCode::CompilationError;
    case tonic::kApiErrorType:
      return DartErrorCode::ApiError;
    case tonic::kUnknownErrorType:
      return DartErrorCode::UnknownError;
    case tonic::kNoError:
      return DartErrorCode::NoError;
  }
  return DartErrorCode::UnknownError;
}

◆ GetVsyncWaiter()

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

Definition at line 2308 of file shell.cc.

                                                           {
  if (!engine_) {
    return {};
  }
  return engine_->GetVsyncWaiter();
}

◆ HandleServiceProtocolMessage()

bool flutter::Shell::HandleServiceProtocolMessage	(	std::string_view	method,
		const ServiceProtocolMap &	params,
		rapidjson::Document *	response
	)

overrideprivatevirtual

Implements flutter::ServiceProtocol::Handler.

Definition at line 1667 of file shell.cc.

                                 {
  auto found = service_protocol_handlers_.find(method);
  if (found != service_protocol_handlers_.end()) {
    return found->second.second(params, response);
  }
  return false;
}

◆ InferVmInitDataFromSettings()

std::pair< DartVMRef, fml::RefPtr< const DartSnapshot > > flutter::Shell::InferVmInitDataFromSettings ( Settings & settings )

static

Definition at line 151 of file shell.cc.

                                                     {
  // Always use the `vm_snapshot` and `isolate_snapshot` provided by the
  // settings to launch the VM.  If the VM is already running, the snapshot
  // arguments are ignored.
  auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
  auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
  auto vm = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);
 
  // If the settings did not specify an `isolate_snapshot`, fall back to the
  // one the VM was launched with.
  if (!isolate_snapshot) {
    isolate_snapshot = vm->GetVMData()->GetIsolateSnapshot();
  }
  return {std::move(vm), isolate_snapshot};
}

◆ IsSetup()

bool flutter::Shell::IsSetup ( ) const

Used by embedders to check if all shell subcomponents are initialized. It is the embedder's responsibility to make this call before accessing any other shell method. A shell that is not set up must be discarded and another one created with updated settings.

Returns: Returns if the shell has been set up. Once set up, this does not change for the life-cycle of the shell.

Definition at line 724 of file shell.cc.

                          {
  return is_set_up_;
}

◆ LoadDartDeferredLibrary()

void flutter::Shell::LoadDartDeferredLibrary	(	intptr_t	loading_unit_id,
		std::unique_ptr< const fml::Mapping >	snapshot_data,
		std::unique_ptr< const fml::Mapping >	snapshot_instructions
	)

overrideprivatevirtual

Loads the dart shared library into the dart VM. When the dart library is loaded successfully, the dart future returned by the originating loadLibrary() call completes.

The Dart compiler may generate separate shared libraries files called 'loading units' when libraries are imported as deferred. Each of these shared libraries are identified by a unique loading unit id. Callers should open and resolve a SymbolMapping from the shared library. The Mappings should be moved into this method, as ownership will be assumed by the dart root isolate after successful loading and released after shutdown of the root isolate. The loading unit may not be used after isolate shutdown. If loading fails, the mappings will be released.

This method is paired with a RequestDartDeferredLibrary invocation that provides the embedder with the loading unit id of the deferred library to load.

Parameters

[in]	loading_unit_id	The unique id of the deferred library's loading unit.
[in]	snapshot_data	Dart snapshot data of the loading unit's shared library.
[in]	snapshot_data	Dart snapshot instructions of the loading unit's shared library.

Implements flutter::PlatformView::Delegate.

Definition at line 1480 of file shell.cc.

                                                           {
  task_runners_.GetUITaskRunner()->PostTask(fml::MakeCopyable(
      [engine = engine_->GetWeakPtr(), loading_unit_id,
       data = std::move(snapshot_data),
       instructions = std::move(snapshot_instructions)]() mutable {
        if (engine) {
          engine->LoadDartDeferredLibrary(loading_unit_id, std::move(data),
                                          std::move(instructions));
        }
      }));
}

◆ LoadDartDeferredLibraryError()

void flutter::Shell::LoadDartDeferredLibraryError	(	intptr_t	loading_unit_id,
		const std::string	error_message,
		bool	transient
	)

overrideprivatevirtual

Indicates to the dart VM that the request to load a deferred library with the specified loading unit id has failed.

The dart future returned by the initiating loadLibrary() call will complete with an error.

Parameters

[in]	loading_unit_id	The unique id of the deferred library's loading unit, as passed in by RequestDartDeferredLibrary.
[in]	error_message	The error message that will appear in the dart Future.
[in]	transient	A transient error is a failure due to temporary conditions such as no network. Transient errors allow the dart VM to re-request the same deferred library and loading_unit_id again. Non-transient errors are permanent and attempts to re-request the library will instantly complete with an error.

Implements flutter::PlatformView::Delegate.

Definition at line 1495 of file shell.cc.

                                                         {
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      [engine = weak_engine_, loading_unit_id, error_message, transient] {
        if (engine) {
          engine->LoadDartDeferredLibraryError(loading_unit_id, error_message,
                                               transient);
        }
      });
}

◆ NotifyLowMemoryWarning()

void flutter::Shell::NotifyLowMemoryWarning ( ) const

Used by embedders to notify that there is a low memory warning. The shell will attempt to purge caches. Current, only the rasterizer cache is purged.

Definition at line 633 of file shell.cc.

                                         {
  auto trace_id = fml::tracing::TraceNonce();
  TRACE_EVENT_ASYNC_BEGIN0("flutter", "Shell::NotifyLowMemoryWarning",
                           trace_id);
  // This does not require a current isolate but does require a running VM.
  // Since a valid shell will not be returned to the embedder without a valid
  // DartVMRef, we can be certain that this is a safe spot to assume a VM is
  // running.
  ::Dart_NotifyLowMemory();
 
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), trace_id = trace_id]() {
        if (rasterizer) {
          rasterizer->NotifyLowMemoryWarning();
        }
        TRACE_EVENT_ASYNC_END0("flutter", "Shell::NotifyLowMemoryWarning",
                               trace_id);
      });
  // The IO Manager uses resource cache limits of 0, so it is not necessary
  // to purge them.
}

◆ OnAnimatorBeginFrame()

void flutter::Shell::OnAnimatorBeginFrame	(	fml::TimePoint	frame_target_time,
		uint64_t	frame_number
	)

overrideprivatevirtual

Implements flutter::Animator::Delegate.

Definition at line 1225 of file shell.cc.

                                                        {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  // record the target time for use by rasterizer.
  {
    std::scoped_lock time_recorder_lock(time_recorder_mutex_);
    latest_frame_target_time_.emplace(frame_target_time);
  }
  if (engine_) {
    engine_->BeginFrame(frame_target_time, frame_number);
  }
}

◆ OnAnimatorDraw()

void flutter::Shell::OnAnimatorDraw ( std::shared_ptr< FramePipeline > pipeline )

overrideprivatevirtual

Implements flutter::Animator::Delegate.

Definition at line 1267 of file shell.cc.

                                                                {
  FML_DCHECK(is_set_up_);
 
  task_runners_.GetRasterTaskRunner()->PostTask(fml::MakeCopyable(
      [&waiting_for_first_frame = waiting_for_first_frame_,
       &waiting_for_first_frame_condition = waiting_for_first_frame_condition_,
       rasterizer = rasterizer_->GetWeakPtr(),
       weak_pipeline = std::weak_ptr<FramePipeline>(pipeline)]() mutable {
        if (rasterizer) {
          std::shared_ptr<FramePipeline> pipeline = weak_pipeline.lock();
          if (pipeline) {
            rasterizer->Draw(pipeline);
          }
 
          if (waiting_for_first_frame.load()) {
            waiting_for_first_frame.store(false);
            waiting_for_first_frame_condition.notify_all();
          }
        }
      }));
}

◆ OnAnimatorDrawLastLayerTrees()

void flutter::Shell::OnAnimatorDrawLastLayerTrees ( std::unique_ptr< FrameTimingsRecorder > frame_timings_recorder )

overrideprivatevirtual

Implements flutter::Animator::Delegate.

Definition at line 1290 of file shell.cc.

                                                                {
  FML_DCHECK(is_set_up_);
 
  auto task = fml::MakeCopyable(
      [rasterizer = rasterizer_->GetWeakPtr(),
       frame_timings_recorder = std::move(frame_timings_recorder)]() mutable {
        if (rasterizer) {
          rasterizer->DrawLastLayerTrees(std::move(frame_timings_recorder));
        }
      });
 
  task_runners_.GetRasterTaskRunner()->PostTask(task);
}

◆ OnAnimatorNotifyIdle()

void flutter::Shell::OnAnimatorNotifyIdle ( fml::TimeDelta deadline )

overrideprivatevirtual

Implements flutter::Animator::Delegate.

Definition at line 1241 of file shell.cc.

                                                      {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (engine_) {
    engine_->NotifyIdle(deadline);
    volatile_path_tracker_->OnFrame();
  }
}

◆ OnAnimatorUpdateLatestFrameTargetTime()

void flutter::Shell::OnAnimatorUpdateLatestFrameTargetTime ( fml::TimePoint frame_target_time )

overrideprivatevirtual

Implements flutter::Animator::Delegate.

Definition at line 1251 of file shell.cc.

                                    {
  FML_DCHECK(is_set_up_);
 
  // record the target time for use by rasterizer.
  {
    std::scoped_lock time_recorder_lock(time_recorder_mutex_);
    if (!latest_frame_target_time_) {
      latest_frame_target_time_ = frame_target_time;
    } else if (latest_frame_target_time_ < frame_target_time) {
      latest_frame_target_time_ = frame_target_time;
    }
  }
}

◆ OnDisplayUpdates()

void flutter::Shell::OnDisplayUpdates ( std::vector< std::unique_ptr< Display > > displays )

Notifies the display manager of the updates.

Definition at line 2279 of file shell.cc.

                                                                       {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  std::vector<DisplayData> display_data;
  display_data.reserve(displays.size());
  for (const auto& display : displays) {
    display_data.push_back(display->GetDisplayData());
  }
  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(),
       display_data = std::move(display_data)]() {
        if (engine) {
          engine->SetDisplays(display_data);
        }
      });
 
  display_manager_->HandleDisplayUpdates(std::move(displays));
}

◆ OnEngineChannelUpdate()

void flutter::Shell::OnEngineChannelUpdate	(	std::string	name,
		bool	listening
	)

overrideprivatevirtual

Invoked when a listener is registered on a platform channel.

Parameters

[in]	name	The name of the platform channel to which a listener has been registered or cleared.
[in]	listening	Whether the listener has been set (true) or cleared (false).

Implements flutter::Engine::Delegate.

Definition at line 1380 of file shell.cc.

                                                                {
  FML_DCHECK(is_set_up_);
 
  task_runners_.GetPlatformTaskRunner()->PostTask(
      [view = platform_view_->GetWeakPtr(), name = std::move(name), listening] {
        if (view) {
          view->SendChannelUpdate(name, listening);
        }
      });
}

◆ OnEngineHandlePlatformMessage()

void flutter::Shell::OnEngineHandlePlatformMessage ( std::unique_ptr< PlatformMessage > message )

overrideprivatevirtual

When the Flutter application has a message to send to the underlying platform, the message needs to be forwarded to the platform on the appropriate thread (via the platform task runner). The engine delegates this task to the shell via this method.

See also: PlatformView::HandlePlatformMessage

Parameters

[in] message The message from the Flutter application to send to the underlying platform.

Implements flutter::Engine::Delegate.

Definition at line 1321 of file shell.cc.

                                            {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (message->channel() == kSkiaChannel) {
    HandleEngineSkiaMessage(std::move(message));
    return;
  }
 
  if (platform_message_handler_) {
    if (route_messages_through_platform_thread_ &&
        !platform_message_handler_
             ->DoesHandlePlatformMessageOnPlatformThread()) {
#if _WIN32
      // On Windows capturing a TaskRunner with a TaskRunner will cause an
      // uncaught exception in process shutdown because of the deletion order of
      // global variables. See also
      // https://github.com/flutter/flutter/issues/111575.
      // This won't be an issue until Windows supports background platform
      // channels (https://github.com/flutter/flutter/issues/93945). Then this
      // can potentially be addressed by capturing a weak_ptr to an object that
      // retains the ui TaskRunner, instead of the TaskRunner directly.
      FML_DCHECK(false);
#endif
      // We route messages through the platform thread temporarily when the
      // shell is being initialized to be backwards compatible with setting
      // message handlers in the same event as starting the isolate, but after
      // it is started.
      auto ui_task_runner = task_runners_.GetUITaskRunner();
      task_runners_.GetPlatformTaskRunner()->PostTask(fml::MakeCopyable(
          [weak_platform_message_handler =
               std::weak_ptr<PlatformMessageHandler>(platform_message_handler_),
           message = std::move(message), ui_task_runner]() mutable {
            ui_task_runner->PostTask(
                fml::MakeCopyable([weak_platform_message_handler,
                                   message = std::move(message)]() mutable {
                  auto platform_message_handler =
                      weak_platform_message_handler.lock();
                  if (platform_message_handler) {
                    platform_message_handler->HandlePlatformMessage(
                        std::move(message));
                  }
                }));
          }));
    } else {
      platform_message_handler_->HandlePlatformMessage(std::move(message));
    }
  } else {
    task_runners_.GetPlatformTaskRunner()->PostTask(
        fml::MakeCopyable([view = platform_view_->GetWeakPtr(),
                           message = std::move(message)]() mutable {
          if (view) {
            view->HandlePlatformMessage(std::move(message));
          }
        }));
  }
}

◆ OnEngineUpdateSemantics()

void flutter::Shell::OnEngineUpdateSemantics	(	SemanticsNodeUpdates	updates,
		CustomAccessibilityActionUpdates	actions
	)

overrideprivatevirtual

When the accessibility tree has been updated by the Flutter application, this new information needs to be conveyed to the underlying platform. The engine delegates this task to the shell via this call. The engine cannot access the underlying platform directly because of threading considerations. Most platform specific APIs to convey accessibility information are only safe to access on the platform task runner while the engine is running on the UI task runner.

See also: SemanticsNode, SemanticsNodeUpdates, CustomAccessibilityActionUpdates, PlatformView::UpdateSemantics

Parameters

[in]	updates	A map with the stable semantics node identifier as key and the node properties as the value.
[in]	actions	A map with the stable semantics node identifier as key and the custom node action as the value.

Implements flutter::Engine::Delegate.

Definition at line 1306 of file shell.cc.

                                                                              {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetPlatformTaskRunner()->PostTask(
      [view = platform_view_->GetWeakPtr(), update = std::move(update),
       actions = std::move(actions)] {
        if (view) {
          view->UpdateSemantics(update, actions);
        }
      });
}

◆ OnFrameRasterized()

void flutter::Shell::OnFrameRasterized ( const FrameTiming & frame_timing )

overrideprivatevirtual

Notifies the delegate that a frame has been rendered. The rasterizer collects profiling information for each part of the frame workload. This profiling information is made available to the delegate for forwarding to subsystems interested in collecting such profiles. Currently, the shell (the delegate) forwards this to the engine where Dart code can react to this information.

See also: FrameTiming

Parameters

[in] frame_timing Instrumentation information for each phase of the frame workload.

Implements flutter::Rasterizer::Delegate.

Definition at line 1560 of file shell.cc.

                                                       {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
 
  // The C++ callback defined in settings.h and set by Flutter runner. This is
  // independent of the timings report to the Dart side.
  if (settings_.frame_rasterized_callback) {
    settings_.frame_rasterized_callback(timing);
  }
 
  if (!needs_report_timings_) {
    return;
  }
 
  size_t old_count = unreported_timings_.size();
  (void)old_count;
  for (auto phase : FrameTiming::kPhases) {
    unreported_timings_.push_back(
        timing.Get(phase).ToEpochDelta().ToMicroseconds());
  }
  unreported_timings_.push_back(timing.GetLayerCacheCount());
  unreported_timings_.push_back(timing.GetLayerCacheBytes());
  unreported_timings_.push_back(timing.GetPictureCacheCount());
  unreported_timings_.push_back(timing.GetPictureCacheBytes());
  unreported_timings_.push_back(timing.GetFrameNumber());
  FML_DCHECK(unreported_timings_.size() ==
             old_count + FrameTiming::kStatisticsCount);
 
  // In tests using iPhone 6S with profile mode, sending a batch of 1 frame or a
  // batch of 100 frames have roughly the same cost of less than 0.1ms. Sending
  // a batch of 500 frames costs about 0.2ms. The 1 second threshold usually
  // kicks in before we reaching the following 100 frames threshold. The 100
  // threshold here is mainly for unit tests (so we don't have to write a
  // 1-second unit test), and make sure that our vector won't grow too big with
  // future 120fps, 240fps, or 1000fps displays.
  //
  // In the profile/debug mode, the timings are used by development tools which
  // require a latency of no more than 100ms. Hence we lower that 1-second
  // threshold to 100ms because performance overhead isn't that critical in
  // those cases.
  if (!first_frame_rasterized_ || UnreportedFramesCount() >= 100) {
    first_frame_rasterized_ = true;
    ReportTimings();
  } else if (!frame_timings_report_scheduled_) {
#if FLUTTER_RELEASE
    constexpr int kBatchTimeInMilliseconds = 1000;
#else
    constexpr int kBatchTimeInMilliseconds = 100;
#endif
 
    // Also make sure that frame times get reported with a max latency of 1
    // second. Otherwise, the timings of last few frames of an animation may
    // never be reported until the next animation starts.
    frame_timings_report_scheduled_ = true;
    task_runners_.GetRasterTaskRunner()->PostDelayedTask(
        [self = weak_factory_gpu_->GetWeakPtr()]() {
          if (!self) {
            return;
          }
          self->frame_timings_report_scheduled_ = false;
          if (self->UnreportedFramesCount() > 0) {
            self->ReportTimings();
          }
        },
        fml::TimeDelta::FromMilliseconds(kBatchTimeInMilliseconds));
  }
}

◆ OnPlatformViewAddView()

void flutter::Shell::OnPlatformViewAddView	(	int64_t	view_id,
		const ViewportMetrics &	viewport_metrics,
		AddViewCallback	callback
	)

overrideprivatevirtual

Allocate resources for a new non-implicit view and inform Dart about the view, and on success, schedules a new frame.

After the operation, |callback| should be invoked with whether the operation is successful.

Adding |kFlutterImplicitViewId| or an existing view ID should result in failure.

Parameters

[in]	view_id	The view ID of the new view.
[in]	viewport_metrics	The initial viewport metrics for the view.
[in]	callback	The callback that's invoked once the shell has attempted to add the view.

Implements flutter::PlatformView::Delegate.

Definition at line 2117 of file shell.cc.

                                                            {
  TRACE_EVENT0("flutter", "Shell::AddView");
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  FML_DCHECK(view_id != kFlutterImplicitViewId)
      << "Unexpected request to add the implicit view #"
      << kFlutterImplicitViewId << ". This view should never be added.";
 
  task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr(),  //
                                             viewport_metrics,                //
                                             view_id,                         //
                                             callback = std::move(callback)   //
  ] {
    if (engine) {
      engine->AddView(view_id, viewport_metrics, callback);
    }
  });
}

◆ OnPlatformViewCreated()

void flutter::Shell::OnPlatformViewCreated ( std::unique_ptr< Surface > surface )

overrideprivatevirtual

Notifies the delegate that the platform view was created with the given render surface. This surface is platform (iOS, Android) and client-rendering API (OpenGL, Software, Metal, Vulkan) specific. This is usually a sign to the rasterizer to set up and begin rendering to that surface.

Parameters

[in] surface The surface

Implements flutter::PlatformView::Delegate.

Definition at line 833 of file shell.cc.

                                                                {
  TRACE_EVENT0("flutter", "Shell::OnPlatformViewCreated");
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  // Prevent any request to change the thread configuration for raster and
  // platform queues while the platform view is being created.
  //
  // This prevents false positives such as this method starts assuming that the
  // raster and platform queues have a given thread configuration, but then the
  // configuration is changed by a task, and the assumption is no longer true.
  //
  // This incorrect assumption can lead to deadlock.
  // See `should_post_raster_task` for more.
  rasterizer_->DisableThreadMergerIfNeeded();
 
  // The normal flow executed by this method is that the platform thread is
  // starting the sequence and waiting on the latch. Later the UI thread posts
  // raster_task to the raster thread which signals the latch. If the raster and
  // the platform threads are the same this results in a deadlock as the
  // raster_task will never be posted to the platform/raster thread that is
  // blocked on a latch. To avoid the described deadlock, if the raster and the
  // platform threads are the same, should_post_raster_task will be false, and
  // then instead of posting a task to the raster thread, the ui thread just
  // signals the latch and the platform/raster thread follows with executing
  // raster_task.
  const bool should_post_raster_task =
      !task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread();
 
  auto raster_task = fml::MakeCopyable(
      [&waiting_for_first_frame = waiting_for_first_frame_,  //
       rasterizer = rasterizer_->GetWeakPtr(),               //
       surface = std::move(surface)                          //
  ]() mutable {
        if (rasterizer) {
          // Enables the thread merger which may be used by the external view
          // embedder.
          rasterizer->EnableThreadMergerIfNeeded();
          rasterizer->Setup(std::move(surface));
        }
 
        waiting_for_first_frame.store(true);
      });
 
  auto ui_task = [engine = engine_->GetWeakPtr()] {
    if (engine) {
      engine->ScheduleFrame();
    }
  };
 
  // Threading: Capture platform view by raw pointer and not the weak pointer.
  // We are going to use the pointer on the IO thread which is not safe with a
  // weak pointer. However, we are preventing the platform view from being
  // collected by using a latch.
  auto* platform_view = platform_view_.get();
  FML_DCHECK(platform_view);
  fml::AutoResetWaitableEvent latch;
 
  auto io_task = [io_manager = io_manager_->GetWeakPtr(), platform_view,
                  ui_task_runner = task_runners_.GetUITaskRunner(), ui_task,
                  raster_task_runner = task_runners_.GetRasterTaskRunner(),
                  raster_task, should_post_raster_task, &latch] {
    if (io_manager && !io_manager->GetResourceContext()) {
      sk_sp<GrDirectContext> resource_context =
          platform_view->CreateResourceContext();
      io_manager->NotifyResourceContextAvailable(resource_context);
    }
    // Step 1: Post a task on the UI thread to tell the engine that it has
    // an output surface.
    fml::TaskRunner::RunNowOrPostTask(ui_task_runner, ui_task);
 
    // Step 2: Tell the raster thread that it should create a surface for
    // its rasterizer.
    if (should_post_raster_task) {
      fml::TaskRunner::RunNowOrPostTask(raster_task_runner, raster_task);
    }
    latch.Signal();
  };
 
  fml::TaskRunner::RunNowOrPostTask(task_runners_.GetIOTaskRunner(), io_task);
 
  latch.Wait();
  if (!should_post_raster_task) {
    // See comment on should_post_raster_task, in this case the raster_task
    // wasn't executed, and we just run it here as the platform thread
    // is the raster thread.
    raster_task();
  }
}

◆ OnPlatformViewDestroyed()

void flutter::Shell::OnPlatformViewDestroyed ( )

overrideprivatevirtual

Notifies the delegate that the platform view was destroyed. This is usually a sign to the rasterizer to suspend rendering a previously configured surface and collect any intermediate resources.

Implements flutter::PlatformView::Delegate.

Definition at line 924 of file shell.cc.

                                    {
  TRACE_EVENT0("flutter", "Shell::OnPlatformViewDestroyed");
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  // Prevent any request to change the thread configuration for raster and
  // platform queues while the platform view is being destroyed.
  //
  // This prevents false positives such as this method starts assuming that the
  // raster and platform queues have a given thread configuration, but then the
  // configuration is changed by a task, and the assumption is no longer true.
  //
  // This incorrect assumption can lead to deadlock.
  rasterizer_->DisableThreadMergerIfNeeded();
 
  // Notify the Dart VM that the PlatformView has been destroyed and some
  // cleanup activity can be done (e.g: garbage collect the Dart heap).
  task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr()]() {
    if (engine) {
      engine->NotifyDestroyed();
    }
  });
 
  // Note:
  // This is a synchronous operation because certain platforms depend on
  // setup/suspension of all activities that may be interacting with the GPU in
  // a synchronous fashion.
  // The UI thread does not need to be serialized here - there is sufficient
  // guardrailing in the rasterizer to allow the UI thread to post work to it
  // even after the surface has been torn down.
 
  fml::AutoResetWaitableEvent latch;
 
  auto io_task = [io_manager = io_manager_.get(), &latch]() {
    // Execute any pending Skia object deletions while GPU access is still
    // allowed.
    io_manager->GetIsGpuDisabledSyncSwitch()->Execute(
        fml::SyncSwitch::Handlers().SetIfFalse(
            [&] { io_manager->GetSkiaUnrefQueue()->Drain(); }));
    // Step 4: All done. Signal the latch that the platform thread is waiting
    // on.
    latch.Signal();
  };
 
  auto raster_task = [rasterizer = rasterizer_->GetWeakPtr(),
                      io_task_runner = task_runners_.GetIOTaskRunner(),
                      io_task]() {
    if (rasterizer) {
      // Enables the thread merger which is required prior tearing down the
      // rasterizer. If the raster and platform threads are merged, tearing down
      // the rasterizer unmerges the threads.
      rasterizer->EnableThreadMergerIfNeeded();
      rasterizer->Teardown();
    }
    // Step 2: Tell the IO thread to complete its remaining work.
    fml::TaskRunner::RunNowOrPostTask(io_task_runner, io_task);
  };
 
  // Step 1: Post a task to the Raster thread (possibly this thread) to tell the
  // rasterizer the output surface is going away.
  fml::TaskRunner::RunNowOrPostTask(task_runners_.GetRasterTaskRunner(),
                                    raster_task);
  latch.Wait();
  // On Android, the external view embedder may post a task to the platform
  // thread, and wait until it completes if overlay surfaces must be released.
  // However, the platform thread might be blocked when Dart is initializing.
  // In this situation, calling TeardownExternalViewEmbedder is safe because no
  // platform views have been created before Flutter renders the first frame.
  // Overall, the longer term plan is to remove this implementation once
  // https://github.com/flutter/flutter/issues/96679 is fixed.
  rasterizer_->TeardownExternalViewEmbedder();
}

◆ OnPlatformViewDispatchPlatformMessage()

void flutter::Shell::OnPlatformViewDispatchPlatformMessage ( std::unique_ptr< PlatformMessage > message )

overrideprivatevirtual

Notifies the delegate that the platform has dispatched a platform message from the embedder to the Flutter application. This message must be forwarded to the running isolate hosted by the engine on the UI thread.

Parameters

[in] message The platform message to dispatch to the running root isolate.

Implements flutter::PlatformView::Delegate.

Definition at line 1051 of file shell.cc.

                                            {
  FML_DCHECK(is_set_up_);
#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
  if (!task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread()) {
    std::scoped_lock lock(misbehaving_message_channels_mutex_);
    auto inserted = misbehaving_message_channels_.insert(message->channel());
    if (inserted.second) {
      FML_LOG(ERROR)
          << "The '" << message->channel()
          << "' channel sent a message from native to Flutter on a "
             "non-platform thread. Platform channel messages must be sent on "
             "the platform thread. Failure to do so may result in data loss or "
             "crashes, and must be fixed in the plugin or application code "
             "creating that channel.\n"
             "See https://docs.flutter.dev/platform-integration/"
             "platform-channels#channels-and-platform-threading for more "
             "information.";
    }
  }
#endif  // FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
 
  // The static leak checker gets confused by the use of fml::MakeCopyable.
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
  task_runners_.GetUITaskRunner()->PostTask(fml::MakeCopyable(
      [engine = engine_->GetWeakPtr(), message = std::move(message)]() mutable {
        if (engine) {
          engine->DispatchPlatformMessage(std::move(message));
        }
      }));
}

◆ OnPlatformViewDispatchPointerDataPacket()

void flutter::Shell::OnPlatformViewDispatchPointerDataPacket ( std::unique_ptr< PointerDataPacket > packet )

overrideprivatevirtual

Notifies the delegate that the platform view has encountered a pointer event. This pointer event needs to be forwarded to the running root isolate hosted by the engine on the UI thread.

Parameters

[in] packet The pointer data packet containing multiple pointer events.

Implements flutter::PlatformView::Delegate.

Definition at line 1084 of file shell.cc.

                                             {
  TRACE_EVENT0_WITH_FLOW_IDS(
      "flutter", "Shell::OnPlatformViewDispatchPointerDataPacket",
      /*flow_id_count=*/1, /*flow_ids=*/&next_pointer_flow_id_);
  TRACE_FLOW_BEGIN("flutter", "PointerEvent", next_pointer_flow_id_);
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  task_runners_.GetUITaskRunner()->PostTask(
      fml::MakeCopyable([engine = weak_engine_, packet = std::move(packet),
                         flow_id = next_pointer_flow_id_]() mutable {
        if (engine) {
          engine->DispatchPointerDataPacket(std::move(packet), flow_id);
        }
      }));
  next_pointer_flow_id_++;
}

◆ OnPlatformViewDispatchSemanticsAction()

void flutter::Shell::OnPlatformViewDispatchSemanticsAction	(	int32_t	node_id,
		SemanticsAction	action,
		fml::MallocMapping	args
	)

overrideprivatevirtual

Notifies the delegate that the platform view has encountered an accessibility related action on the specified node. This event must be forwarded to the running root isolate hosted by the engine on the UI thread.

Parameters

[in]	node_id	The identifier of the accessibility node.
[in]	action	The accessibility related action performed on the node of the specified ID.
[in]	args	An optional list of argument that apply to the specified action.

Implements flutter::PlatformView::Delegate.

Definition at line 1103 of file shell.cc.

                                                                         {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetUITaskRunner()->PostTask(
      fml::MakeCopyable([engine = engine_->GetWeakPtr(), node_id, action,
                         args = std::move(args)]() mutable {
        if (engine) {
          engine->DispatchSemanticsAction(node_id, action, std::move(args));
        }
      }));
}

◆ OnPlatformViewGetSettings()

const Settings & flutter::Shell::OnPlatformViewGetSettings ( ) const

overrideprivatevirtual

Called by the platform view on the platform thread to get the settings object associated with the platform view instance.

Returns: The settings.

Implements flutter::PlatformView::Delegate.

Definition at line 1220 of file shell.cc.

                                                       {
  return settings_;
}

◆ OnPlatformViewMarkTextureFrameAvailable()

void flutter::Shell::OnPlatformViewMarkTextureFrameAvailable ( int64_t texture_id )

overrideprivatevirtual

Notifies the delegate that the embedder has updated the contents of the texture with the specified identifier. Typically, Flutter will only render a frame if there is an updated layer tree. However, in cases where the layer tree is static but one of the externally composited textures has been updated by the embedder, the embedder needs to notify the rasterizer to render a new frame. In such cases, the existing layer tree may be reused with the frame composited with all updated external textures.

Parameters

[in] texture_id The identifier of the texture that has been updated.

Implements flutter::PlatformView::Delegate.

Definition at line 1176 of file shell.cc.

                                                                      {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  // Tell the rasterizer that one of its textures has a new frame available.
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), texture_id]() {
        auto registry = rasterizer->GetTextureRegistry();
 
        if (!registry) {
          return;
        }
 
        auto texture = registry->GetTexture(texture_id);
 
        if (!texture) {
          return;
        }
 
        texture->MarkNewFrameAvailable();
      });
 
  // Schedule a new frame without having to rebuild the layer tree.
  task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr()]() {
    if (engine) {
      engine->ScheduleFrame(false);
    }
  });
}

◆ OnPlatformViewRegisterTexture()

void flutter::Shell::OnPlatformViewRegisterTexture ( std::shared_ptr< flutter::Texture > texture )

overrideprivate

Definition at line 1145 of file shell.cc.

                                           {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), texture] {
        if (rasterizer) {
          if (auto registry = rasterizer->GetTextureRegistry()) {
            registry->RegisterTexture(texture);
          }
        }
      });
}

◆ OnPlatformViewRemoveView()

void flutter::Shell::OnPlatformViewRemoveView	(	int64_t	view_id,
		RemoveViewCallback	callback
	)

overrideprivatevirtual

Deallocate resources for a removed view and inform Dart about the removal.

After the operation, |callback| should be invoked with whether the operation is successful.

Removing |kFlutterImplicitViewId| or an non-existent view ID should result in failure.

Parameters

[in]	view_id	The view ID of the view to be removed.
[in]	callback	The callback that's invoked once the shell has attempted to remove the view.

Implements flutter::PlatformView::Delegate.

Definition at line 2138 of file shell.cc.

                                                                  {
  TRACE_EVENT0("flutter", "Shell::RemoveView");
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  FML_DCHECK(view_id != kFlutterImplicitViewId)
      << "Unexpected request to remove the implicit view #"
      << kFlutterImplicitViewId << ". This view should never be removed.";
 
  expected_frame_sizes_.erase(view_id);
  task_runners_.GetUITaskRunner()->PostTask(
      [&task_runners = task_runners_,           //
       engine = engine_->GetWeakPtr(),          //
       rasterizer = rasterizer_->GetWeakPtr(),  //
       view_id,                                 //
       callback = std::move(callback)           //
  ] {
        if (engine) {
          bool removed = engine->RemoveView(view_id);
          callback(removed);
        }
        // Don't wait for the raster task here, which only cleans up memory and
        // does not affect functionality. Make sure it is done after Dart
        // removes the view to avoid receiving another rasterization request
        // that adds back the view record.
        task_runners.GetRasterTaskRunner()->PostTask([rasterizer, view_id]() {
          if (rasterizer) {
            rasterizer->CollectView(view_id);
          }
        });
      });
}

◆ OnPlatformViewScheduleFrame()

void flutter::Shell::OnPlatformViewScheduleFrame ( )

overrideprivatevirtual

Notifies the delegate that the platform needs to schedule a frame to regenerate the layer tree and redraw the surface.

Implements flutter::PlatformView::Delegate.

Definition at line 998 of file shell.cc.

                                        {
  TRACE_EVENT0("flutter", "Shell::OnPlatformViewScheduleFrame");
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetUITaskRunner()->PostTask([engine = engine_->GetWeakPtr()]() {
    if (engine) {
      engine->ScheduleFrame();
    }
  });
}

◆ OnPlatformViewSetAccessibilityFeatures()

void flutter::Shell::OnPlatformViewSetAccessibilityFeatures ( int32_t flags )

overrideprivatevirtual

Notifies the delegate that the embedder has expressed an opinion about the features to enable in the accessibility tree.

The engine does not care about the accessibility feature flags as all it does is forward this information from the embedder to the framework. However, curious readers may refer to AccessibilityFeatures in window.dart for currently supported accessibility feature flags.

Parameters

[in] flags The features to enable in the accessibility tree.

Implements flutter::PlatformView::Delegate.

Definition at line 1132 of file shell.cc.

                                                                {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), flags] {
        if (engine) {
          engine->SetAccessibilityFeatures(flags);
        }
      });
}

◆ OnPlatformViewSetNextFrameCallback()

void flutter::Shell::OnPlatformViewSetNextFrameCallback ( const fml::closure & closure )

overrideprivatevirtual

Notifies the delegate that the specified callback needs to be invoked after the rasterizer is done rendering the next frame. This callback will be called on the render thread and it is caller responsibility to perform any re-threading as necessary. Due to the asynchronous nature of rendering in Flutter, embedders usually add a placeholder over the contents in which Flutter is going to render when Flutter is first initialized. This callback may be used as a signal to remove that placeholder.

Attention: The callback will be invoked on the render thread and not the calling thread.

Parameters

[in] closure The callback to execute on the next frame.

Implements flutter::PlatformView::Delegate.

Definition at line 1207 of file shell.cc.

                                                                        {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), closure = closure]() {
        if (rasterizer) {
          rasterizer->SetNextFrameCallback(closure);
        }
      });
}

◆ OnPlatformViewSetSemanticsEnabled()

void flutter::Shell::OnPlatformViewSetSemanticsEnabled ( bool enabled )

overrideprivatevirtual

Notifies the delegate that the embedder has expressed an opinion about whether the accessibility tree needs to be enabled or disabled. This information needs to be forwarded to the root isolate running on the UI thread.

Parameters

[in] enabled Whether the accessibility tree is enabled or disabled.

Implements flutter::PlatformView::Delegate.

Definition at line 1119 of file shell.cc.

                                                          {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), enabled] {
        if (engine) {
          engine->SetSemanticsEnabled(enabled);
        }
      });
}

◆ OnPlatformViewSetViewportMetrics()

void flutter::Shell::OnPlatformViewSetViewportMetrics	(	int64_t	view_id,
		const ViewportMetrics &	metrics
	)

overrideprivatevirtual

Notifies the delegate the viewport metrics of a view have been updated. The rasterizer will need to be reconfigured to render the frame in the updated viewport metrics.

Parameters

[in]	view_id	The ID for the view that `metrics` describes.
[in]	metrics	The updated viewport metrics.

Implements flutter::PlatformView::Delegate.

Definition at line 1011 of file shell.cc.

                                                                             {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  if (metrics.device_pixel_ratio <= 0 || metrics.physical_width <= 0 ||
      metrics.physical_height <= 0) {
    // Ignore invalid view-port metrics.
    return;
  }
 
  // This is the formula Android uses.
  // https://android.googlesource.com/platform/frameworks/base/+/39ae5bac216757bc201490f4c7b8c0f63006c6cd/libs/hwui/renderthread/CacheManager.cpp#45
  resource_cache_limit_ =
      metrics.physical_width * metrics.physical_height * 12 * 4;
  size_t resource_cache_max_bytes =
      resource_cache_limit_calculator_->GetResourceCacheMaxBytes();
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), resource_cache_max_bytes] {
        if (rasterizer) {
          rasterizer->SetResourceCacheMaxBytes(resource_cache_max_bytes, false);
        }
      });
 
  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), view_id, metrics]() {
        if (engine) {
          engine->SetViewportMetrics(view_id, metrics);
        }
      });
 
  {
    std::scoped_lock<std::mutex> lock(resize_mutex_);
    expected_frame_sizes_[view_id] =
        SkISize::Make(metrics.physical_width, metrics.physical_height);
    device_pixel_ratio_ = metrics.device_pixel_ratio;
  }
}

◆ OnPlatformViewUnregisterTexture()

void flutter::Shell::OnPlatformViewUnregisterTexture ( int64_t texture_id )

overrideprivatevirtual

Notifies the delegate that the embedder will no longer attempt to composite the specified texture within the layer tree. This allows the rasterizer to collect associated resources.

Parameters

[in] texture_id The identifier of the texture to unregister. If the texture has not been previously registered, this call does nothing.

Implements flutter::PlatformView::Delegate.

Definition at line 1161 of file shell.cc.

                                                              {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  task_runners_.GetRasterTaskRunner()->PostTask(
      [rasterizer = rasterizer_->GetWeakPtr(), texture_id]() {
        if (rasterizer) {
          if (auto registry = rasterizer->GetTextureRegistry()) {
            registry->UnregisterTexture(texture_id);
          }
        }
      });
}

◆ OnPreEngineRestart()

void flutter::Shell::OnPreEngineRestart ( )

overrideprivatevirtual

Notifies the delegate that the root isolate of the application is about to be discarded and a new isolate with the same runtime started in its place. This should only happen in the Flutter "debug" runtime mode in the cold-restart scenario. The embedder may need to reset native resource in response to the restart.

See also: PlatformView::OnPreEngineRestart

Implements flutter::Engine::Delegate.

Definition at line 1428 of file shell.cc.

                               {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      [view = platform_view_->GetWeakPtr(), &latch]() {
        if (view) {
          view->OnPreEngineRestart();
        }
        latch.Signal();
      });
  // This is blocking as any embedded platform views has to be flushed before
  // we re-run the Dart code.
  latch.Wait();
}

◆ OnRootIsolateCreated()

void flutter::Shell::OnRootIsolateCreated ( )

overrideprivatevirtual

Notifies the shell that the root isolate is created. Currently, this information is to add to the service protocol list of available root isolates running in the VM and their names so that the appropriate isolate can be selected in the tools for debugging and instrumentation.

Implements flutter::Engine::Delegate.

Definition at line 1447 of file shell.cc.

                                 {
  if (is_added_to_service_protocol_) {
    return;
  }
  auto description = GetServiceProtocolDescription();
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetPlatformTaskRunner(),
      [self = weak_factory_.GetWeakPtr(),
       description = std::move(description)]() {
        if (self) {
          self->vm_->GetServiceProtocol()->AddHandler(self.get(), description);
        }
      });
  is_added_to_service_protocol_ = true;
}

◆ RegisterImageDecoder()

void flutter::Shell::RegisterImageDecoder	(	ImageGeneratorFactory	factory,
		int32_t	priority
	)

Install a new factory that can match against and decode image data.

Parameters

[in]	factory	Callback that produces `ImageGenerator`s for compatible input data.
[in]	priority	The priority used to determine the order in which factories are tried. Higher values mean higher priority. The built-in Skia decoders are installed at priority 0, and so a priority > 0 takes precedent over the builtin decoders. When multiple decoders are added with the same priority, those which are added earlier take precedent.

See also: CreateCompatibleGenerator

Definition at line 1866 of file shell.cc.

                                                   {
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  FML_DCHECK(is_set_up_);
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      [engine = engine_->GetWeakPtr(), factory = std::move(factory),
       priority]() {
        if (engine) {
          engine->GetImageGeneratorRegistry()->AddFactory(factory, priority);
        }
      });
}

◆ ReloadSystemFonts()

bool flutter::Shell::ReloadSystemFonts ( )

Used by embedders to reload the system fonts in FontCollection. It also clears the cached font families and send system channel message to framework to rebuild affected widgets.

Returns: Returns if shell reloads system fonts successfully.

Definition at line 2234 of file shell.cc.

                              {
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  if (!engine_) {
    return false;
  }
  engine_->SetupDefaultFontManager();
  engine_->GetFontCollection().GetFontCollection()->ClearFontFamilyCache();
  // After system fonts are reloaded, we send a system channel message
  // to notify flutter framework.
  SendFontChangeNotification();
  return true;
}

◆ RequestDartDeferredLibrary()

void flutter::Shell::RequestDartDeferredLibrary ( intptr_t loading_unit_id )

overrideprivatevirtual

Invoked when the Dart VM requests that a deferred library be loaded. Notifies the engine that the deferred library identified by the specified loading unit id should be downloaded and loaded into the Dart VM via LoadDartDeferredLibrary

Upon encountering errors or otherwise failing to load a loading unit with the specified id, the failure should be directly reported to dart by calling LoadDartDeferredLibraryFailure to ensure the waiting dart future completes with an error.

Parameters

[in] loading_unit_id The unique id of the deferred library's loading unit. This id is to be passed back into LoadDartDeferredLibrary in order to identify which deferred library to load.

Implements flutter::Engine::Delegate.

Definition at line 1524 of file shell.cc.

                                                               {
  task_runners_.GetPlatformTaskRunner()->PostTask(
      [view = platform_view_->GetWeakPtr(), loading_unit_id] {
        if (view) {
          view->RequestDartDeferredLibrary(loading_unit_id);
        }
      });
}

◆ RunEngine() [1/2]

void flutter::Shell::RunEngine ( RunConfiguration run_configuration )

Starts an isolate for the given RunConfiguration.

Definition at line 655 of file shell.cc.

                                                        {
  RunEngine(std::move(run_configuration), nullptr);
}

◆ RunEngine() [2/2]

void flutter::Shell::RunEngine	(	RunConfiguration	run_configuration,
		const std::function< void(Engine::RunStatus)> &	result_callback
	)

Starts an isolate for the given RunConfiguration. The result_callback will be called with the status of the operation.

Definition at line 659 of file shell.cc.

                                                               {
  auto result = [platform_runner = task_runners_.GetPlatformTaskRunner(),
                 result_callback](Engine::RunStatus run_result) {
    if (!result_callback) {
      return;
    }
    platform_runner->PostTask(
        [result_callback, run_result]() { result_callback(run_result); });
  };
  FML_DCHECK(is_set_up_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      fml::MakeCopyable(
          [run_configuration = std::move(run_configuration),
           weak_engine = weak_engine_, result]() mutable {
            if (!weak_engine) {
              FML_LOG(ERROR)
                  << "Could not launch engine with configuration - no engine.";
              result(Engine::RunStatus::Failure);
              return;
            }
            auto run_result = weak_engine->Run(std::move(run_configuration));
            if (run_result == flutter::Engine::RunStatus::Failure) {
              FML_LOG(ERROR) << "Could not launch engine with configuration.";
            }
 
            result(run_result);
          }));
}

◆ Screenshot()

Rasterizer::Screenshot flutter::Shell::Screenshot	(	Rasterizer::ScreenshotType	type,
		bool	base64_encode
	)

Captures a screenshot and optionally Base64 encodes the data of the last layer tree rendered by the rasterizer in this shell.

Parameters

[in]	type	The type of screenshot to capture.
[in]	base64_encode	If the screenshot data should be base64 encoded.

Returns: The screenshot result.

Definition at line 2171 of file shell.cc.

                        {
  if (settings_.enable_impeller) {
    switch (screenshot_type) {
      case Rasterizer::ScreenshotType::SkiaPicture:
        FML_LOG(ERROR)
            << "Impeller backend cannot produce ScreenshotType::SkiaPicture.";
        return {};
      case Rasterizer::ScreenshotType::UncompressedImage:
      case Rasterizer::ScreenshotType::CompressedImage:
      case Rasterizer::ScreenshotType::SurfaceData:
        break;
    }
  }
  TRACE_EVENT0("flutter", "Shell::Screenshot");
  fml::AutoResetWaitableEvent latch;
  Rasterizer::Screenshot screenshot;
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetRasterTaskRunner(), [&latch,                        //
                                            rasterizer = GetRasterizer(),  //
                                            &screenshot,                   //
                                            screenshot_type,               //
                                            base64_encode                  //
  ]() {
        if (rasterizer) {
          screenshot = rasterizer->ScreenshotLastLayerTree(screenshot_type,
                                                           base64_encode);
        }
        latch.Signal();
      });
  latch.Wait();
  return screenshot;
}

◆ SetGpuAvailability()

void flutter::Shell::SetGpuAvailability ( GpuAvailability availability )

Marks the GPU as available or unavailable.

Definition at line 2254 of file shell.cc.

                                                           {
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
  switch (availability) {
    case GpuAvailability::kAvailable:
      is_gpu_disabled_sync_switch_->SetSwitch(false);
      return;
    case GpuAvailability::kFlushAndMakeUnavailable: {
      fml::AutoResetWaitableEvent latch;
      fml::TaskRunner::RunNowOrPostTask(
          task_runners_.GetIOTaskRunner(),
          [io_manager = io_manager_.get(), &latch]() {
            io_manager->GetSkiaUnrefQueue()->Drain();
            latch.Signal();
          });
      latch.Wait();
    }
      // FALLTHROUGH
    case GpuAvailability::kUnavailable:
      is_gpu_disabled_sync_switch_->SetSwitch(true);
      return;
    default:
      FML_DCHECK(false);
  }
}

◆ SetNeedsReportTimings()

void flutter::Shell::SetNeedsReportTimings ( bool needs_reporting )

overrideprivatevirtual

Notifies the shell that the application has an opinion about whether its frame timings need to be reported backed to it. Due to the asynchronous nature of rendering in Flutter, it is not possible for the application to determine the total time it took to render a specific frame. While the layer-tree is constructed on the UI thread, it needs to be rendering on the raster thread. Dart code cannot execute on this thread. So any instrumentation about the frame times gathered on this thread needs to be aggregated and sent back to the UI thread for processing in Dart.

When the application indicates that frame times need to be reported, it collects this information till a specified number of data points are gathered. Then this information is sent back to Dart code via Engine::ReportTimings.

This option is engine counterpart of the Window._setNeedsReportTimings in window.dart.

Parameters

[in] needs_reporting If reporting information should be collected and send back to Dart.

Implements flutter::Engine::Delegate.

Definition at line 1470 of file shell.cc.

                                            {
  needs_report_timings_ = value;
}

◆ ShouldDiscardLayerTree()

bool flutter::Shell::ShouldDiscardLayerTree	(	int64_t	view_id,
		const flutter::LayerTree &	tree
	)

overrideprivatevirtual

Implements flutter::Rasterizer::Delegate.

Definition at line 1647 of file shell.cc.

                                                                 {
  std::scoped_lock<std::mutex> lock(resize_mutex_);
  auto expected_frame_size = ExpectedFrameSize(view_id);
  return !expected_frame_size.isEmpty() &&
         tree.frame_size() != expected_frame_size;
}

◆ Spawn()

std::unique_ptr< Shell > flutter::Shell::Spawn	(	RunConfiguration	run_configuration,
		const std::string &	initial_route,
		const CreateCallback< PlatformView > &	on_create_platform_view,
		const CreateCallback< Rasterizer > &	on_create_rasterizer
	)		const

Creates one Shell from another Shell where the created Shell takes the opportunity to share any internal components it can. This results is a Shell that has a smaller startup time cost and a smaller memory footprint than an Shell created with the Create function.

The new Shell is returned in a running state so RunEngine shouldn't be called again on the Shell. Once running, the second Shell is mostly independent from the original Shell and the original Shell doesn't need to keep running for the spawned Shell to keep functioning.

Parameters

[in] run_configuration A RunConfiguration used to run the Isolate associated with this new Shell. It doesn't have to be the same configuration as the current Shell but it needs to be in the same snapshot or AOT.

See also: http://flutter.dev/go/multiple-engines

Definition at line 589 of file shell.cc.

                                                                  {
  FML_DCHECK(task_runners_.IsValid());
  // It's safe to store this value since it is set on the platform thread.
  bool is_gpu_disabled = false;
  GetIsGpuDisabledSyncSwitch()->Execute(
      fml::SyncSwitch::Handlers()
          .SetIfFalse([&is_gpu_disabled] { is_gpu_disabled = false; })
          .SetIfTrue([&is_gpu_disabled] { is_gpu_disabled = true; }));
  std::unique_ptr<Shell> result = CreateWithSnapshot(
      PlatformData{}, task_runners_, rasterizer_->GetRasterThreadMerger(),
      io_manager_, resource_cache_limit_calculator_, GetSettings(), vm_,
      vm_->GetVMData()->GetIsolateSnapshot(), on_create_platform_view,
      on_create_rasterizer,
      [engine = this->engine_.get(), initial_route](
          Engine::Delegate& delegate,
          const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,
          const fml::RefPtr<const DartSnapshot>& isolate_snapshot,
          const TaskRunners& task_runners, const PlatformData& platform_data,
          const Settings& settings, std::unique_ptr<Animator> animator,
          const fml::WeakPtr<IOManager>& io_manager,
          const fml::RefPtr<SkiaUnrefQueue>& unref_queue,
          fml::TaskRunnerAffineWeakPtr<SnapshotDelegate> snapshot_delegate,
          const std::shared_ptr<VolatilePathTracker>& volatile_path_tracker,
          const std::shared_ptr<fml::SyncSwitch>& is_gpu_disabled_sync_switch,
          impeller::RuntimeStageBackend runtime_stage_backend) {
        return engine->Spawn(
            /*delegate=*/delegate,
            /*dispatcher_maker=*/dispatcher_maker,
            /*settings=*/settings,
            /*animator=*/std::move(animator),
            /*initial_route=*/initial_route,
            /*io_manager=*/io_manager,
            /*snapshot_delegate=*/std::move(snapshot_delegate),
            /*gpu_disabled_switch=*/is_gpu_disabled_sync_switch);
      },
      is_gpu_disabled);
  result->RunEngine(std::move(run_configuration));
  return result;
}

◆ UpdateAssetResolverByType()

void flutter::Shell::UpdateAssetResolverByType	(	std::unique_ptr< AssetResolver >	updated_asset_resolver,
		AssetResolver::AssetResolverType	type
	)

overrideprivatevirtual

Replaces the asset resolver handled by the engine's AssetManager of the specified type with updated_asset_resolver. The matching AssetResolver is removed and replaced with updated_asset_resolvers.

AssetResolvers should be updated when the existing resolver becomes obsolete and a newer one becomes available that provides updated access to the same type of assets as the existing one. This update process is meant to be performed at runtime.

If a null resolver is provided, nothing will be done. If no matching resolver is found, the provided resolver will be added to the end of the AssetManager resolvers queue. The replacement only occurs with the first matching resolver. Any additional matching resolvers are untouched.

Parameters

[in]	updated_asset_resolver	The asset resolver to replace the resolver of matching type with.
[in]	type	The type of AssetResolver to update. Only resolvers of the specified type will be replaced by the updated resolver.

Implements flutter::PlatformView::Delegate.

Definition at line 1508 of file shell.cc.

                                         {
  fml::TaskRunner::RunNowOrPostTask(
      task_runners_.GetUITaskRunner(),
      fml::MakeCopyable(
          [engine = weak_engine_, type,
           asset_resolver = std::move(updated_asset_resolver)]() mutable {
            if (engine) {
              engine->GetAssetManager()->UpdateResolverByType(
                  std::move(asset_resolver), type);
            }
          }));
}

◆ UpdateIsolateDescription()

void flutter::Shell::UpdateIsolateDescription	(	const std::string	isolate_name,
		int64_t	isolate_port
	)

overrideprivatevirtual

Notifies the shell of the name of the root isolate and its port when that isolate is launched, restarted (in the cold-restart scenario) or the application itself updates the name of the root isolate (via PlatformDispatcher.setIsolateDebugName in platform_dispatcher.dart). The name of the isolate is meaningless to the engine but is used in instrumentation and tooling. Currently, this information is to update the service protocol list of available root isolates running in the VM and their names so that the appropriate isolate can be selected in the tools for debugging and instrumentation.

Parameters

[in]	isolate_name	The isolate name
[in]	isolate_port	The isolate port

Implements flutter::Engine::Delegate.

Definition at line 1464 of file shell.cc.

                                                           {
  Handler::Description description(isolate_port, isolate_name);
  vm_->GetServiceProtocol()->SetHandlerDescription(this, description);
}

◆ WaitForFirstFrame()

fml::Status flutter::Shell::WaitForFirstFrame ( fml::TimeDelta timeout )

Pauses the calling thread until the first frame is presented.

Parameters

[in] timeout The duration to wait before timing out. If this duration would cause an overflow when added to std::chrono::steady_clock::now(), this method will wait indefinitely for the first frame.

Returns: 'kOk' when the first frame has been presented before the timeout successfully, 'kFailedPrecondition' if called from the GPU or UI thread, 'kDeadlineExceeded' if there is a timeout.

Definition at line 2206 of file shell.cc.

                                                       {
  FML_DCHECK(is_set_up_);
  if (task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread() ||
      task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread()) {
    return fml::Status(fml::StatusCode::kFailedPrecondition,
                       "WaitForFirstFrame called from thread that can't wait "
                       "because it is responsible for generating the frame.");
  }
 
  // Check for overflow.
  auto now = std::chrono::steady_clock::now();
  auto max_duration = std::chrono::steady_clock::time_point::max() - now;
  auto desired_duration = std::chrono::milliseconds(timeout.ToMilliseconds());
  auto duration =
      now + (desired_duration > max_duration ? max_duration : desired_duration);
 
  std::unique_lock<std::mutex> lock(waiting_for_first_frame_mutex_);
  bool success = waiting_for_first_frame_condition_.wait_until(
      lock, duration, [&waiting_for_first_frame = waiting_for_first_frame_] {
        return !waiting_for_first_frame.load();
      });
  if (success) {
    return fml::Status();
  } else {
    return fml::Status(fml::StatusCode::kDeadlineExceeded, "timeout");
  }
}

Friends And Related Symbol Documentation

◆ testing::ShellTest

friend class testing::ShellTest

friend

Definition at line 791 of file shell.h.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CreateCallback

◆ EngineCreateCallback

Constructor & Destructor Documentation

◆ ~Shell()

Member Function Documentation

◆ ComputePlatformResolvedLocale()

◆ Create()

◆ EngineHasLivePorts()

◆ GetConcurrentWorkerTaskRunner()

◆ GetCurrentTimePoint()

◆ GetDartVM()

◆ GetEngine()

◆ GetFrameBudget()

◆ GetIOManager()

◆ GetIsGpuDisabledSyncSwitch()

◆ GetLatestFrameTargetTime()

◆ GetMainDisplayRefreshRate()

◆ GetParentRasterThreadMerger()

◆ GetPlatformMessageHandler()

◆ GetPlatformView()

◆ GetRasterizer()

◆ GetResourceCacheLimit()

◆ GetScaledFontSize()

◆ GetServiceProtocolDescription()

◆ GetServiceProtocolHandlerTaskRunner()

◆ GetSettings()

◆ GetTaskRunners()

◆ GetUIIsolateLastError()

◆ GetVsyncWaiter()

◆ HandleServiceProtocolMessage()

◆ InferVmInitDataFromSettings()

◆ IsSetup()

◆ LoadDartDeferredLibrary()

◆ LoadDartDeferredLibraryError()

◆ NotifyLowMemoryWarning()

◆ OnAnimatorBeginFrame()

◆ OnAnimatorDraw()

◆ OnAnimatorDrawLastLayerTrees()

◆ OnAnimatorNotifyIdle()

◆ OnAnimatorUpdateLatestFrameTargetTime()

◆ OnDisplayUpdates()

◆ OnEngineChannelUpdate()

◆ OnEngineHandlePlatformMessage()

◆ OnEngineUpdateSemantics()

◆ OnFrameRasterized()

◆ OnPlatformViewAddView()

◆ OnPlatformViewCreated()

◆ OnPlatformViewDestroyed()

◆ OnPlatformViewDispatchPlatformMessage()

◆ OnPlatformViewDispatchPointerDataPacket()

◆ OnPlatformViewDispatchSemanticsAction()

◆ OnPlatformViewGetSettings()

◆ OnPlatformViewMarkTextureFrameAvailable()

◆ OnPlatformViewRegisterTexture()

◆ OnPlatformViewRemoveView()

◆ OnPlatformViewScheduleFrame()

◆ OnPlatformViewSetAccessibilityFeatures()

◆ OnPlatformViewSetNextFrameCallback()

◆ OnPlatformViewSetSemanticsEnabled()

◆ OnPlatformViewSetViewportMetrics()

◆ OnPlatformViewUnregisterTexture()

◆ OnPreEngineRestart()

◆ OnRootIsolateCreated()

◆ RegisterImageDecoder()

◆ ReloadSystemFonts()

◆ RequestDartDeferredLibrary()

◆ RunEngine() [1/2]

◆ RunEngine() [2/2]

◆ Screenshot()

◆ SetGpuAvailability()

◆ SetNeedsReportTimings()

◆ ShouldDiscardLayerTree()