flutter::DartCallbackCache Class Reference

#include <callback_cache.h>

Static Public Member Functions
static void	SetCachePath (const std::string &path)
static std::string	GetCachePath ()
static int64_t	GetCallbackHandle (const std::string &name, const std::string &class_name, const std::string &library_path)
static Dart_Handle	GetCallback (int64_t handle)
static std::unique_ptr< DartCallbackRepresentation >	GetCallbackInformation (int64_t handle)
static void	LoadCacheFromDisk ()

Detailed Description

Definition at line 24 of file callback_cache.h.

Member Function Documentation

GetCachePath()

static std::string flutter::DartCallbackCache::GetCachePath ( )

inlinestatic

Definition at line 27 of file callback_cache.h.

{ return cache_path_; }

GetCallback()

Dart_Handle flutter::DartCallbackCache::GetCallback ( int64_t  handle )

static

Definition at line 39 of file callback_cache.cc.

                                                         {
  std::scoped_lock lock(mutex_);
  auto iterator = cache_.find(handle);
  if (iterator != cache_.end()) {
    DartCallbackRepresentation cb = iterator->second;
    return LookupDartClosure(cb.name, cb.class_name, cb.library_path);
  }
  return Dart_Null();
}

GetCallbackHandle()

int64_t flutter::DartCallbackCache::GetCallbackHandle ( const std::string &  name, const std::string &  class_name, const std::string &  library_path  )

static

Definition at line 49 of file callback_cache.cc.

                                                                            {
  std::scoped_lock lock(mutex_);
  std::hash<std::string> hasher;
  int64_t hash = hasher(name);
  hash += hasher(class_name);
  hash += hasher(library_path);
 
  if (cache_.find(hash) == cache_.end()) {
    cache_[hash] = {name, class_name, library_path};
    SaveCacheToDisk();
  }
  return hash;
}

GetCallbackInformation()

std::unique_ptr< DartCallbackRepresentation > flutter::DartCallbackCache::GetCallbackInformation ( int64_t  handle )

static

Definition at line 66 of file callback_cache.cc.

                                                        {
  std::scoped_lock lock(mutex_);
  auto iterator = cache_.find(handle);
  if (iterator != cache_.end()) {
    return std::make_unique<DartCallbackRepresentation>(iterator->second);
  }
  return nullptr;
}

LoadCacheFromDisk()

void flutter::DartCallbackCache::LoadCacheFromDisk ( )

static

Definition at line 117 of file callback_cache.cc.

                                          {
  std::scoped_lock lock(mutex_);
 
  // Don't reload the cache if it's already populated.
  if (!cache_.empty()) {
    return;
  }
  std::ifstream input(cache_path_);
  if (!input) {
    return;
  }
  std::string cache_contents{std::istreambuf_iterator<char>(input),
                             std::istreambuf_iterator<char>()};
  Document d;
  d.Parse(cache_contents.c_str());
  if (d.HasParseError() || !d.IsArray()) {
    // Could not parse callback cache, aborting restore.
    return;
  }
  const auto entries = d.GetArray();
  for (auto* it = entries.begin(); it != entries.end(); ++it) {
    const auto root_obj = it->GetObject();
    const auto representation = root_obj[kRepresentationKey].GetObject();
 
    const int64_t hash = root_obj[kHandleKey].GetInt64();
    DartCallbackRepresentation cb;
    cb.name = representation[kNameKey].GetString();
    cb.class_name = representation[kClassNameKey].GetString();
    cb.library_path = representation[kLibraryPathKey].GetString();
    cache_[hash] = cb;
  }
}

SetCachePath()

void flutter::DartCallbackCache::SetCachePath ( const std::string &  path )

static

Definition at line 35 of file callback_cache.cc.

                                                          {
  cache_path_ = fml::paths::JoinPaths({path, kCacheName});
}

---

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

• lib/ui/plugins/callback_cache.h
• lib/ui/plugins/callback_cache.cc