#include <asset_manager.h>

Inheritance diagram for flutter::AssetManager:

Public Member Functions
	AssetManager ()

	~AssetManager () override

bool	PushFront (std::unique_ptr< AssetResolver > resolver)
	Adds an asset resolver to the front of the resolver queue. Assets would be loaded from this resolver before any follwing resolvers.

bool	PushBack (std::unique_ptr< AssetResolver > resolver)
	Adds an asset resolver to the end of the resolver queue. Assets would be loaded from this resolver after any previous resolvers.

void	UpdateResolverByType (std::unique_ptr< AssetResolver > updated_asset_resolver, AssetResolver::AssetResolverType type)
	Replaces an asset resolver of the specified `type` with `updated_asset_resolver`. The matching AssetResolver is removed and replaced with `updated_asset_resolvers`.

std::deque< std::unique_ptr< AssetResolver > >	TakeResolvers ()

bool	IsValid () const override

bool	IsValidAfterAssetManagerChange () const override
	Certain asset resolvers are still valid after the asset manager is replaced before a hot reload, or after a new run configuration is created during a hot restart. By preserving these resolvers and re-inserting them into the new resolver or run configuration, the tooling can avoid needing to sync all application assets through the Dart devFS upon connecting to the VM Service. Besides improving the startup performance of running a Flutter application, it also reduces the occurrence of tool failures due to repeated network flakes caused by damaged cables or hereto unknown bugs in the Dart HTTP server implementation.

AssetResolver::AssetResolverType	GetType () const override
	Gets the type of AssetResolver this is. Types are defined in AssetResolverType.

std::unique_ptr< fml::Mapping >	GetAsMapping (const std::string &asset_name) const override

std::vector< std::unique_ptr< fml::Mapping > >	GetAsMappings (const std::string &asset_pattern, const std::optional< std::string > &subdir) const override
	Same as GetAsMapping() but returns mappings for all files who's name matches a given pattern. Returns empty vector if no matching assets are found.

bool	operator== (const AssetResolver &other) const override

const AssetManager *	as_asset_manager () const override

Public Member Functions inherited from flutter::AssetResolver
	AssetResolver ()=default

virtual	~AssetResolver ()=default

virtual const APKAssetProvider *	as_apk_asset_provider () const

virtual const DirectoryAssetBundle *	as_directory_asset_bundle () const

bool	operator!= (const AssetResolver &other) const

Additional Inherited Members
Public Types inherited from flutter::AssetResolver
enum	AssetResolverType { kAssetManager , kApkAssetProvider , kDirectoryAssetBundle }
	Identifies the type of AssetResolver an instance is. More...

Detailed Description

Definition at line 19 of file asset_manager.h.

Constructor & Destructor Documentation

◆ AssetManager()

flutter::AssetManager::AssetManager ( )

default

◆ ~AssetManager()

flutter::AssetManager::~AssetManager ( )

overridedefault

Member Function Documentation

◆ as_asset_manager()

const AssetManager * flutter::AssetManager::as_asset_manager ( ) const

inlineoverridevirtual

Reimplemented from flutter::AssetResolver.

Definition at line 95 of file asset_manager.h.

95{ return this; }

◆ GetAsMapping()

std::unique_ptr< fml::Mapping > flutter::AssetManager::GetAsMapping ( const std::string & asset_name ) const

overridevirtual

Implements flutter::AssetResolver.

Definition at line 63 of file asset_manager.cc.

                                       {
  if (asset_name.empty()) {
    return nullptr;
  }
  TRACE_EVENT1("flutter", "AssetManager::GetAsMapping", "name",
               asset_name.c_str());
  for (const auto& resolver : resolvers_) {
    auto mapping = resolver->GetAsMapping(asset_name);
    if (mapping != nullptr) {
      return mapping;
    }
  }
  FML_DLOG(WARNING) << "Could not find asset: " << asset_name;
  return nullptr;
}

◆ GetAsMappings()

std::vector< std::unique_ptr< fml::Mapping > > flutter::AssetManager::GetAsMappings	(	const std::string &	asset_pattern,
		const std::optional< std::string > &	subdir
	)		const

overridevirtual

Same as GetAsMapping() but returns mappings for all files who's name matches a given pattern. Returns empty vector if no matching assets are found.

Parameters

[in]	asset_pattern	The pattern to match file names against.
[in]	subdir	Optional subdirectory in which to search for files. If supplied this function does a flat search within the subdirectory instead of a recursive search through the entire assets directory.

Returns: Returns a vector of mappings of files which match the search parameters.

Reimplemented from flutter::AssetResolver.

Definition at line 81 of file asset_manager.cc.

                                                {
  std::vector<std::unique_ptr<fml::Mapping>> mappings;
  if (asset_pattern.empty()) {
    return mappings;
  }
  TRACE_EVENT1("flutter", "AssetManager::GetAsMappings", "pattern",
               asset_pattern.c_str());
  for (const auto& resolver : resolvers_) {
    auto resolver_mappings = resolver->GetAsMappings(asset_pattern, subdir);
    mappings.insert(mappings.end(),
                    std::make_move_iterator(resolver_mappings.begin()),
                    std::make_move_iterator(resolver_mappings.end()));
  }
  return mappings;
}

◆ GetType()

AssetResolver::AssetResolverType flutter::AssetManager::GetType ( ) const

overridevirtual

Gets the type of AssetResolver this is. Types are defined in AssetResolverType.

Returns: Returns the AssetResolverType that this resolver is.

Implements flutter::AssetResolver.

Definition at line 110 of file asset_manager.cc.

                                                           {
  return AssetResolverType::kAssetManager;
}

◆ IsValid()

bool flutter::AssetManager::IsValid ( ) const

overridevirtual

Implements flutter::AssetResolver.

Definition at line 100 of file asset_manager.cc.

                                 {
  return !resolvers_.empty();
}

◆ IsValidAfterAssetManagerChange()

bool flutter::AssetManager::IsValidAfterAssetManagerChange ( ) const

overridevirtual

Certain asset resolvers are still valid after the asset manager is replaced before a hot reload, or after a new run configuration is created during a hot restart. By preserving these resolvers and re-inserting them into the new resolver or run configuration, the tooling can avoid needing to sync all application assets through the Dart devFS upon connecting to the VM Service. Besides improving the startup performance of running a Flutter application, it also reduces the occurrence of tool failures due to repeated network flakes caused by damaged cables or hereto unknown bugs in the Dart HTTP server implementation.

Returns: Returns whether this resolver is valid after the asset manager or run configuration is updated.

Implements flutter::AssetResolver.

Definition at line 105 of file asset_manager.cc.

                                                        {
  return false;
}

◆ operator==()

bool flutter::AssetManager::operator== ( const AssetResolver & other ) const

overridevirtual

Implements flutter::AssetResolver.

Definition at line 114 of file asset_manager.cc.

                                                              {
  const AssetManager* other_manager = other.as_asset_manager();
  if (!other_manager) {
    return false;
  }
  if (resolvers_.size() != other_manager->resolvers_.size()) {
    return false;
  }
 
  for (size_t i = 0; i < resolvers_.size(); i++) {
    if (*resolvers_[i] != *other_manager->resolvers_[i]) {
      return false;
    }
  }
  return true;
}

◆ PushBack()

bool flutter::AssetManager::PushBack ( std::unique_ptr< AssetResolver > resolver )

Adds an asset resolver to the end of the resolver queue. Assets would be loaded from this resolver after any previous resolvers.

Returns: Returns whether this resolver is valid and has been added to the resolver queue.

Definition at line 25 of file asset_manager.cc.

                                                                 {
  if (resolver == nullptr || !resolver->IsValid()) {
    return false;
  }
 
  resolvers_.push_back(std::move(resolver));
  return true;
}

◆ PushFront()

bool flutter::AssetManager::PushFront ( std::unique_ptr< AssetResolver > resolver )

Adds an asset resolver to the front of the resolver queue. Assets would be loaded from this resolver before any follwing resolvers.

Returns: Returns whether this resolver is valid and has been added to the resolver queue.

Definition at line 16 of file asset_manager.cc.

                                                                  {
  if (resolver == nullptr || !resolver->IsValid()) {
    return false;
  }
 
  resolvers_.push_front(std::move(resolver));
  return true;
}

◆ TakeResolvers()

std::deque< std::unique_ptr< AssetResolver > > flutter::AssetManager::TakeResolvers ( )

Definition at line 58 of file asset_manager.cc.

                                                                   {
  return std::move(resolvers_);
}

◆ UpdateResolverByType()

void flutter::AssetManager::UpdateResolverByType	(	std::unique_ptr< AssetResolver >	updated_asset_resolver,
		AssetResolver::AssetResolverType	type
	)

Replaces an asset resolver 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.

Definition at line 34 of file asset_manager.cc.

                                         {
  if (updated_asset_resolver == nullptr) {
    return;
  }
  bool updated = false;
  std::deque<std::unique_ptr<AssetResolver>> new_resolvers;
  for (auto& old_resolver : resolvers_) {
    if (!updated && old_resolver->GetType() == type) {
      // Push the replacement updated resolver in place of the old_resolver.
      new_resolvers.push_back(std::move(updated_asset_resolver));
      updated = true;
    } else {
      new_resolvers.push_back(std::move(old_resolver));
    }
  }
  // Append resolver to the end if not used as a replacement.
  if (!updated) {
    new_resolvers.push_back(std::move(updated_asset_resolver));
  }
  resolvers_.swap(new_resolvers);
}

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

assets/asset_manager.h
assets/asset_manager.cc

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AssetManager()

◆ ~AssetManager()

Member Function Documentation

◆ as_asset_manager()

◆ GetAsMapping()

◆ GetAsMappings()

◆ GetType()

◆ IsValid()

◆ IsValidAfterAssetManagerChange()

◆ operator==()

◆ PushBack()

◆ PushFront()

◆ TakeResolvers()

◆ UpdateResolverByType()