flutter::EmbedderLayers Class Reference

#include <embedder_layers.h>

Public Types
using	PresentCallback = std::function< bool(FlutterViewId view_id, const std::vector< const FlutterLayer * > &layers)>

Public Member Functions
	EmbedderLayers (DlISize frame_size, double device_pixel_ratio, DlMatrix root_surface_transformation, uint64_t presentation_time)
	~EmbedderLayers ()
void	PushBackingStoreLayer (const FlutterBackingStore *store, const std::vector< DlIRect > &drawn_region)
void	PushPlatformViewLayer (FlutterPlatformViewIdentifier identifier, const EmbeddedViewParams &params)
void	InvokePresentCallback (FlutterViewId view_id, const PresentCallback &callback) const

Detailed Description

Definition at line 17 of file embedder_layers.h.

Member Typedef Documentation

PresentCallback

using flutter::EmbedderLayers::PresentCallback = std::function<bool(FlutterViewId view_id, const std::vector<const FlutterLayer*>& layers)>

Definition at line 32 of file embedder_layers.h.

Constructor & Destructor Documentation

EmbedderLayers()

flutter::EmbedderLayers::EmbedderLayers	(	DlISize	frame_size,
		double	device_pixel_ratio,
		DlMatrix	root_surface_transformation,
		uint64_t	presentation_time
	)

Definition at line 11 of file embedder_layers.cc.

    : frame_size_(frame_size),
      device_pixel_ratio_(device_pixel_ratio),
      root_surface_transformation_(root_surface_transformation),
      presentation_time_(presentation_time) {}

~EmbedderLayers()

flutter::EmbedderLayers::~EmbedderLayers ( )

default

Member Function Documentation

InvokePresentCallback()

void flutter::EmbedderLayers::InvokePresentCallback	(	FlutterViewId	view_id,
		const PresentCallback &	callback
	)		const

Definition at line 242 of file embedder_layers.cc.

                                           {
  std::vector<const FlutterLayer*> presented_layers_pointers;
  presented_layers_pointers.reserve(presented_layers_.size());
  for (const auto& layer : presented_layers_) {
    presented_layers_pointers.push_back(&layer);
  }
  callback(view_id, presented_layers_pointers);
}

References callback, and view_id.

PushBackingStoreLayer()

void flutter::EmbedderLayers::PushBackingStoreLayer	(	const FlutterBackingStore *	store,
		const std::vector< DlIRect > &	drawn_region
	)

Definition at line 22 of file embedder_layers.cc.

                                                {
  FlutterLayer layer = {};
 
  layer.struct_size = sizeof(FlutterLayer);
  layer.type = kFlutterLayerContentTypeBackingStore;
  layer.backing_store = store;
 
  const auto layer_bounds = DlRect::MakeSize(frame_size_);
 
  const auto transformed_layer_bounds =
      layer_bounds.TransformAndClipBounds(root_surface_transformation_);
 
  layer.offset.x = transformed_layer_bounds.GetX();
  layer.offset.y = transformed_layer_bounds.GetY();
  layer.size.width = transformed_layer_bounds.GetWidth();
  layer.size.height = transformed_layer_bounds.GetHeight();
 
  auto paint_region_rects = std::make_unique<std::vector<FlutterRect>>();
  paint_region_rects->reserve(paint_region_vec.size());
 
  for (const auto& rect : paint_region_vec) {
    auto transformed_rect =
        DlRect::Make(rect).TransformAndClipBounds(root_surface_transformation_);
    paint_region_rects->push_back(FlutterRect{
        .left = transformed_rect.GetLeft(),
        .top = transformed_rect.GetTop(),
        .right = transformed_rect.GetRight(),
        .bottom = transformed_rect.GetBottom(),
    });
  }
 
  auto paint_region = std::make_unique<FlutterRegion>();
  paint_region->struct_size = sizeof(FlutterRegion);
  paint_region->rects = paint_region_rects->data();
  paint_region->rects_count = paint_region_rects->size();
  rects_referenced_.push_back(std::move(paint_region_rects));
 
  auto present_info = std::make_unique<FlutterBackingStorePresentInfo>();
  present_info->struct_size = sizeof(FlutterBackingStorePresentInfo);
  present_info->paint_region = paint_region.get();
  regions_referenced_.push_back(std::move(paint_region));
  layer.backing_store_present_info = present_info.get();
  layer.presentation_time = presentation_time_;
 
  present_info_referenced_.push_back(std::move(present_info));
  presented_layers_.push_back(layer);
}

References FlutterLayer::backing_store, FlutterLayer::backing_store_present_info, FlutterSize::height, kFlutterLayerContentTypeBackingStore, FlutterRect::left, impeller::TRect< Scalar >::Make(), impeller::TRect< Scalar >::MakeSize(), FlutterLayer::offset, FlutterLayer::presentation_time, FlutterLayer::size, FlutterLayer::struct_size, FlutterLayer::type, FlutterSize::width, FlutterPoint::x, and FlutterPoint::y.

PushPlatformViewLayer()

void flutter::EmbedderLayers::PushPlatformViewLayer	(	FlutterPlatformViewIdentifier	identifier,
		const EmbeddedViewParams &	params
	)

Definition at line 135 of file embedder_layers.cc.

                                      {
  {
    FlutterPlatformView view = {};
    view.struct_size = sizeof(FlutterPlatformView);
    view.identifier = identifier;
 
    const auto& mutators = params.mutatorsStack();
 
    std::vector<const FlutterPlatformViewMutation*> mutations_array;
 
    for (auto i = mutators.Bottom(); i != mutators.Top(); ++i) {
      const auto& mutator = *i;
      switch (mutator->GetType()) {
        case MutatorType::kClipRect: {
          mutations_array.push_back(
              mutations_referenced_
                  .emplace_back(ConvertMutation(mutator->GetRect()))
                  .get());
        } break;
        case MutatorType::kClipRRect: {
          mutations_array.push_back(
              mutations_referenced_
                  .emplace_back(ConvertMutation(mutator->GetRRect()))
                  .get());
        } break;
        case MutatorType::kClipRSE: {
          mutations_array.push_back(
              mutations_referenced_
                  .emplace_back(ConvertMutation(mutator->GetRSEApproximation()))
                  .get());
        } break;
        case MutatorType::kClipPath: {
          // Unsupported mutation.
        } break;
        case MutatorType::kTransform: {
          const auto& matrix = mutator->GetMatrix();
          if (!matrix.IsIdentity()) {
            mutations_array.push_back(
                mutations_referenced_.emplace_back(ConvertMutation(matrix))
                    .get());
          }
        } break;
        case MutatorType::kOpacity: {
          const double opacity =
              std::clamp(mutator->GetAlphaFloat(), 0.0f, 1.0f);
          if (opacity < 1.0) {
            mutations_array.push_back(
                mutations_referenced_.emplace_back(ConvertMutation(opacity))
                    .get());
          }
        } break;
        case MutatorType::kBackdropFilter:
          break;
      }
    }
 
    if (!mutations_array.empty()) {
      // If there are going to be any mutations, they must first take into
      // account the root surface transformation.
      if (!root_surface_transformation_.IsIdentity()) {
        mutations_array.push_back(
            mutations_referenced_
                .emplace_back(ConvertMutation(root_surface_transformation_))
                .get());
      }
 
      auto mutations =
          std::make_unique<std::vector<const FlutterPlatformViewMutation*>>(
              mutations_array.rbegin(), mutations_array.rend());
      mutations_arrays_referenced_.emplace_back(std::move(mutations));
 
      view.mutations_count = mutations_array.size();
      view.mutations = mutations_arrays_referenced_.back().get()->data();
    }
 
    platform_views_referenced_.emplace_back(
        std::make_unique<FlutterPlatformView>(view));
  }
 
  FlutterLayer layer = {};
 
  layer.struct_size = sizeof(FlutterLayer);
  layer.type = kFlutterLayerContentTypePlatformView;
  layer.platform_view = platform_views_referenced_.back().get();
 
  const auto layer_bounds =
      DlRect::MakeXYWH(params.finalBoundingRect().GetX(),                //
                       params.finalBoundingRect().GetY(),                //
                       params.sizePoints().width * device_pixel_ratio_,  //
                       params.sizePoints().height * device_pixel_ratio_  //
      );
 
  const auto transformed_layer_bounds =
      layer_bounds.TransformAndClipBounds(root_surface_transformation_);
 
  layer.offset.x = transformed_layer_bounds.GetX();
  layer.offset.y = transformed_layer_bounds.GetY();
  layer.size.width = transformed_layer_bounds.GetWidth();
  layer.size.height = transformed_layer_bounds.GetHeight();
 
  layer.presentation_time = presentation_time_;
 
  presented_layers_.push_back(layer);
}

References flutter::ConvertMutation(), FlutterSize::height, i, impeller::Matrix::IsIdentity(), flutter::kBackdropFilter, flutter::kClipPath, flutter::kClipRect, flutter::kClipRRect, flutter::kClipRSE, kFlutterLayerContentTypePlatformView, flutter::kOpacity, flutter::kTransform, impeller::TRect< Scalar >::MakeXYWH(), FlutterLayer::offset, params, FlutterLayer::platform_view, FlutterLayer::presentation_time, FlutterLayer::size, FlutterPlatformView::struct_size, FlutterLayer::struct_size, FlutterLayer::type, view, FlutterSize::width, FlutterPoint::x, and FlutterPoint::y.

---

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

• shell/platform/embedder/embedder_layers.h
• shell/platform/embedder/embedder_layers.cc