flutter::ImmutableBuffer Class Reference

#include <immutable_buffer.h>

Inheritance diagram for flutter::ImmutableBuffer:

Public Member Functions
	~ImmutableBuffer () override
size_t	length () const
	The length of the data in bytes.
sk_sp< SkData >	data () const
	Callers should not modify the returned data. This is not exposed to Dart.
void	dispose ()
Public Member Functions inherited from flutter::RefCountedDartWrappable< ImmutableBuffer >
virtual void	RetainDartWrappableReference () const override
virtual void	ReleaseDartWrappableReference () const override
Public Member Functions inherited from fml::RefCountedThreadSafe< T >
void	Release () const
Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const
bool	HasOneRef () const
void	AssertHasOneRef () const
Public Member Functions inherited from tonic::DartWrappable
	DartWrappable ()
virtual const DartWrapperInfo &	GetDartWrapperInfo () const =0
Dart_Handle	CreateDartWrapper (DartState *dart_state)
void	AssociateWithDartWrapper (Dart_Handle wrappable)
void	ClearDartWrapper ()
Dart_WeakPersistentHandle	dart_wrapper () const

Static Public Member Functions
static Dart_Handle	init (Dart_Handle buffer_handle, Dart_Handle data, Dart_Handle callback_handle)
static Dart_Handle	initFromAsset (Dart_Handle buffer_handle, Dart_Handle asset_name_handle, Dart_Handle callback_handle)
static Dart_Handle	initFromFile (Dart_Handle buffer_handle, Dart_Handle file_path_handle, Dart_Handle callback_handle)

Additional Inherited Members
Public Types inherited from tonic::DartWrappable
enum	DartNativeFields { kPeerIndex , kNumberOfNativeFields }
Protected Member Functions inherited from fml::RefCountedThreadSafe< T >
	RefCountedThreadSafe ()
	~RefCountedThreadSafe ()
Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()
	~RefCountedThreadSafeBase ()
bool	Release () const
void	Adopt ()
Protected Member Functions inherited from tonic::DartWrappable
virtual	~DartWrappable ()
Static Protected Member Functions inherited from tonic::DartWrappable
static Dart_PersistentHandle	GetTypeForWrapper (tonic::DartState *dart_state, const tonic::DartWrapperInfo &wrapper_info)

Detailed Description

A simple opaque handle to an immutable byte buffer suitable for use internally by the engine.

This data is not known by the Dart VM.

It is expected that C++ users of this object will not modify the data argument. No Dart side calls are provided to do so.

Definition at line 27 of file immutable_buffer.h.

Constructor & Destructor Documentation

~ImmutableBuffer()

flutter::ImmutableBuffer::~ImmutableBuffer ( )

override

Definition at line 26 of file immutable_buffer.cc.

{}

Member Function Documentation

data()

sk_sp< SkData > flutter::ImmutableBuffer::data ( ) const

inline

Callers should not modify the returned data. This is not exposed to Dart.

Definition at line 80 of file immutable_buffer.h.

{ return data_; }

dispose()

void flutter::ImmutableBuffer::dispose ( )

inline

Clears the Dart native fields and removes the reference to the underlying byte buffer.

The byte buffer will continue to live if other objects hold a reference to it.

Definition at line 87 of file immutable_buffer.h.

                 {
    data_.reset();
    ClearDartWrapper();
  }

init()

Dart_Handle flutter::ImmutableBuffer::init ( Dart_Handle  buffer_handle, Dart_Handle  data, Dart_Handle  callback_handle  )

static

Initializes a new ImmutableData from a Dart Uint8List.

buffer_handle is the caller that will be registered as the Dart peer of the native ImmutableBuffer object.

data is a tonic::Uint8List of bytes to copy.

callback_handle is expected to be a void callback to signal when the copy has completed.

Definition at line 28 of file immutable_buffer.cc.

                                                               {
  if (!Dart_IsClosure(callback_handle)) {
    return tonic::ToDart("Callback must be a function");
  }
 
  tonic::Uint8List dataList = tonic::Uint8List(data);
 
  auto sk_data = MakeSkDataWithCopy(dataList.data(), dataList.num_elements());
  dataList.Release();
  auto buffer = fml::MakeRefCounted<ImmutableBuffer>(sk_data);
  buffer->AssociateWithDartWrapper(buffer_handle);
  tonic::DartInvoke(callback_handle, {Dart_TypeVoid()});
 
  return Dart_Null();
}

initFromAsset()

Dart_Handle flutter::ImmutableBuffer::initFromAsset ( Dart_Handle  buffer_handle, Dart_Handle  asset_name_handle, Dart_Handle  callback_handle  )

static

Initializes a new ImmutableData from an asset matching a provided asset string.

The zero indexed argument is the caller that will be registered as the Dart peer of the native ImmutableBuffer object.

The first indexed argumented is a String corresponding to the asset to load.

The second indexed argument is expected to be a void callback to signal when the copy has completed.

Definition at line 46 of file immutable_buffer.cc.

                                                                        {
  UIDartState::ThrowIfUIOperationsProhibited();
  if (!Dart_IsClosure(callback_handle)) {
    return tonic::ToDart("Callback must be a function");
  }
 
  uint8_t* chars = nullptr;
  intptr_t asset_length = 0;
  Dart_Handle result =
      Dart_StringToUTF8(asset_name_handle, &chars, &asset_length);
  if (Dart_IsError(result)) {
    return tonic::ToDart("Asset name must be valid UTF8");
  }
 
  std::string asset_name = std::string{reinterpret_cast<const char*>(chars),
                                       static_cast<size_t>(asset_length)};
 
  auto* dart_state = UIDartState::Current();
  auto ui_task_runner = dart_state->GetTaskRunners().GetUITaskRunner();
  auto* buffer_callback_ptr =
      new tonic::DartPersistentValue(dart_state, callback_handle);
  auto* buffer_handle_ptr =
      new tonic::DartPersistentValue(dart_state, raw_buffer_handle);
  auto asset_manager = UIDartState::Current()
                           ->platform_configuration()
                           ->client()
                           ->GetAssetManager();
 
  auto ui_task = fml::MakeCopyable(
      [buffer_callback_ptr, buffer_handle_ptr](const sk_sp<SkData>& sk_data,
                                               size_t buffer_size) mutable {
        std::unique_ptr<tonic::DartPersistentValue> buffer_handle(
            buffer_handle_ptr);
        std::unique_ptr<tonic::DartPersistentValue> buffer_callback(
            buffer_callback_ptr);
 
        auto dart_state = buffer_callback->dart_state().lock();
        if (!dart_state) {
          return;
        }
        tonic::DartState::Scope scope(dart_state);
 
        if (!sk_data) {
          // -1 is used as a sentinel that the file could not be opened.
          tonic::DartInvoke(buffer_callback->Get(), {tonic::ToDart(-1)});
          return;
        }
        auto buffer = fml::MakeRefCounted<ImmutableBuffer>(sk_data);
        buffer->AssociateWithDartWrapper(buffer_handle->Get());
        tonic::DartInvoke(buffer_callback->Get(), {tonic::ToDart(buffer_size)});
      });
 
  dart_state->GetConcurrentTaskRunner()->PostTask(
      [asset_name = std::move(asset_name),
       asset_manager = std::move(asset_manager),
       ui_task_runner = std::move(ui_task_runner), ui_task] {
        std::unique_ptr<fml::Mapping> mapping =
            asset_manager->GetAsMapping(asset_name);
 
        sk_sp<SkData> sk_data;
        size_t buffer_size = 0;
        if (mapping != nullptr) {
          buffer_size = mapping->GetSize();
          const void* bytes = static_cast<const void*>(mapping->GetMapping());
          sk_data = MakeSkDataWithCopy(bytes, buffer_size);
        }
        ui_task_runner->PostTask(
            [sk_data = std::move(sk_data), ui_task = ui_task, buffer_size]() {
              ui_task(sk_data, buffer_size);
            });
      });
  return Dart_Null();
}

initFromFile()

Dart_Handle flutter::ImmutableBuffer::initFromFile ( Dart_Handle  buffer_handle, Dart_Handle  file_path_handle, Dart_Handle  callback_handle  )

static

Initializes a new ImmutableData from an File path.

The zero indexed argument is the caller that will be registered as the Dart peer of the native ImmutableBuffer object.

The first indexed argumented is a String corresponding to the file path to load.

The second indexed argument is expected to be a void callback to signal when the copy has completed.

Definition at line 122 of file immutable_buffer.cc.

                                                                       {
  UIDartState::ThrowIfUIOperationsProhibited();
  if (!Dart_IsClosure(callback_handle)) {
    return tonic::ToDart("Callback must be a function");
  }
 
  uint8_t* chars = nullptr;
  intptr_t file_path_length = 0;
  Dart_Handle result =
      Dart_StringToUTF8(file_path_handle, &chars, &file_path_length);
  if (Dart_IsError(result)) {
    return tonic::ToDart("File path must be valid UTF8");
  }
 
  std::string file_path = std::string{reinterpret_cast<const char*>(chars),
                                      static_cast<size_t>(file_path_length)};
 
  auto* dart_state = UIDartState::Current();
  auto ui_task_runner = dart_state->GetTaskRunners().GetUITaskRunner();
  auto* buffer_callback_ptr =
      new tonic::DartPersistentValue(dart_state, callback_handle);
  auto* buffer_handle_ptr =
      new tonic::DartPersistentValue(dart_state, raw_buffer_handle);
 
  auto ui_task = fml::MakeCopyable(
      [buffer_callback_ptr, buffer_handle_ptr](const sk_sp<SkData>& sk_data,
                                               size_t buffer_size) mutable {
        std::unique_ptr<tonic::DartPersistentValue> buffer_handle(
            buffer_handle_ptr);
        std::unique_ptr<tonic::DartPersistentValue> buffer_callback(
            buffer_callback_ptr);
        auto dart_state = buffer_callback->dart_state().lock();
        if (!dart_state) {
          return;
        }
        tonic::DartState::Scope scope(dart_state);
 
        if (!sk_data) {
          // -1 is used as a sentinel that the file could not be opened.
          tonic::DartInvoke(buffer_callback->Get(), {tonic::ToDart(-1)});
          return;
        }
        auto buffer = fml::MakeRefCounted<ImmutableBuffer>(sk_data);
        buffer->AssociateWithDartWrapper(buffer_handle->Get());
        tonic::DartInvoke(buffer_callback->Get(), {tonic::ToDart(buffer_size)});
      });
 
  dart_state->GetConcurrentTaskRunner()->PostTask(
      [file_path = std::move(file_path),
       ui_task_runner = std::move(ui_task_runner), ui_task] {
        auto mapping = std::make_unique<fml::FileMapping>(fml::OpenFile(
            file_path.c_str(), false, fml::FilePermission::kRead));
 
        sk_sp<SkData> sk_data;
        size_t buffer_size = 0;
        if (mapping->IsValid()) {
          buffer_size = mapping->GetSize();
          const void* bytes = static_cast<const void*>(mapping->GetMapping());
          sk_data = MakeSkDataWithCopy(bytes, buffer_size);
        }
        ui_task_runner->PostTask(
            [sk_data = std::move(sk_data), ui_task = ui_task, buffer_size]() {
              ui_task(sk_data, buffer_size);
            });
      });
  return Dart_Null();
}

length()

size_t flutter::ImmutableBuffer::length ( ) const

inline

The length of the data in bytes.

Definition at line 74 of file immutable_buffer.h.

                        {
    FML_DCHECK(data_);
    return data_->size();
  }

---

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

• lib/ui/painting/immutable_buffer.h
• lib/ui/painting/immutable_buffer.cc