| Flutter iOS Embedder |

Public Member Functions | List of all members
flutter::OverlayLayerPool Class Reference

Storage for Overlay layers across frames. More...

`#include <overlay_layer_pool.h>`

## Public Member Functions
| OverlayLayerPool ()=default
| ~OverlayLayerPool ()=default
std::shared_ptr< OverlayLayer > | GetNextLayer ()
| Gets a layer from the pool if available. More...
void | CreateLayer (const std::shared_ptr< IOSContext > &ios_context, MTLPixelFormat pixel_format)
| Create a new overlay layer. More...
std::vector< std::shared_ptr< OverlayLayer > > | RemoveUnusedLayers ()
| Removes unused layers from the pool. Returns the unused layers. More...
void | RecycleLayers ()
| Marks the layers in the pool as available for reuse. More...
size_t | size () const
| The count of layers currently in the pool. More...

## Detailed Description

Storage for Overlay layers across frames.

Note: this class does not synchronize access to its layers or any layer removal. As it is currently used, layers must be created on the platform thread but other methods of it are called on the raster thread. This is safe as overlay layers are only ever added while the raster thread is latched.

Definition at line 47 of file overlay_layer_pool.h.

## Constructor & Destructor Documentation

## ◆ OverlayLayerPool()

flutter::OverlayLayerPool::OverlayLayerPool | ( |  | ) |
| default

## ◆ ~OverlayLayerPool()

flutter::OverlayLayerPool::~OverlayLayerPool | ( |  | ) |
| default

## Member Function Documentation

## ◆ CreateLayer()

void flutter::OverlayLayerPool::CreateLayer | ( | const std::shared_ptr< IOSContext > & | ios_context,
|  | MTLPixelFormat | pixel_format
| ) |  |

Create a new overlay layer.

This method can only be called on the Platform thread.

Definition at line 56 of file overlay_layer_pool.mm.

57 {
58 FML_DCHECK([[NSThread currentThread] isMainThread]);
59 std::shared_ptr<OverlayLayer> layer;
60 UIView* overlay_view;
61 UIView* overlay_view_wrapper;
62
63 CGFloat screenScale = [UIScreen mainScreen].scale;
64 overlay_view = [[FlutterOverlayView alloc] initWithContentsScale:screenScale
65 pixelFormat:pixel_format];
66 overlay_view_wrapper = [[FlutterOverlayView alloc] initWithContentsScale:screenScale
67 pixelFormat:pixel_format];
68
69 CALayer* ca_layer = overlay_view.layer;
70 std::unique_ptr<IOSSurface> ios_surface = IOSSurface::Create(ios_context, ca_layer);
71 std::unique_ptr<Surface> surface = ios_surface->CreateGPUSurface();
72
73 layer = std::make_shared<OverlayLayer>(overlay_view, overlay_view_wrapper, std::move(ios_surface),
74 std::move(surface));
75
76 // The overlay view wrapper masks the overlay view.
77 // This is required to keep the backing surface size unchanged between frames.
78 //
79 // Otherwise, changing the size of the overlay would require a new surface,
80 // which can be very expensive.
81 //
82 // This is the case of an animation in which the overlay size is changing in every frame.
83 //
84 // +------------------------+
85 // | overlay_view |
86 // | +--------------+ | +--------------+
87 // | | wrapper | | == mask => | overlay_view |
88 // | +--------------+ | +--------------+
89 // +------------------------+
90 layer->overlay_view_wrapper.clipsToBounds = YES;
91 [layer->overlay_view_wrapper addSubview:layer->overlay_view];
92
93 layers_.push_back(layer);
94 }
flutter::IOSSurface::Create
static std::unique_ptr< IOSSurface > Create(std::shared_ptr< IOSContext > context, CALayer *layer)
Definition: ios_surface.mm:18
FlutterOverlayView
Definition: FlutterOverlayView.h:23

References flutter::IOSSurface::Create().

## ◆ GetNextLayer()

std::shared_ptr< OverlayLayer > flutter::OverlayLayerPool::GetNextLayer | ( |  | ) |

Gets a layer from the pool if available.

The layer is marked as used until [RecycleLayers] is called.

Definition at line 46 of file overlay_layer_pool.mm.

46 {
47 std::shared_ptr<OverlayLayer> result;
48 if (available_layer_index_ < layers_.size()) {
49 result = layers_[available_layer_index_];
50 available_layer_index_++;
51 }
52
53 return result;
54 }

## ◆ RecycleLayers()

void flutter::OverlayLayerPool::RecycleLayers | ( |  | ) |

Marks the layers in the pool as available for reuse.

Definition at line 96 of file overlay_layer_pool.mm.

96 {
97 available_layer_index_ = 0;
98 }

## ◆ RemoveUnusedLayers()

std::vector< std::shared_ptr< OverlayLayer > > flutter::OverlayLayerPool::RemoveUnusedLayers | ( |  | ) |

Removes unused layers from the pool. Returns the unused layers.

Definition at line 100 of file overlay_layer_pool.mm.

100 {
101 std::vector<std::shared_ptr<OverlayLayer>> results;
102 for (size_t i = available_layer_index_; i < layers_.size(); i++) {
103 results.push_back(layers_[i]);
104 }
105 // Leave at least one overlay layer, to work around cases where scrolling
106 // platform views under an app bar continually adds and removes an
107 // overlay layer. This logic could be removed if https://github.com/flutter/flutter/issues/150646
108 // is fixed.
109 static constexpr size_t kLeakLayerCount = 1;
110 size_t erase_offset = std::max(available_layer_index_, kLeakLayerCount);
111 if (erase_offset < layers_.size()) {
112 layers_.erase(layers_.begin() + erase_offset, layers_.end());
113 }
114 return results;
115 }

## ◆ size()

size_t flutter::OverlayLayerPool::size | ( |  | ) | const

The count of layers currently in the pool.

Definition at line 117 of file overlay_layer_pool.mm.

117 {
118 return layers_.size();
119 }

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

- shell/platform/darwin/ios/framework/Source/overlay_layer_pool.h
- shell/platform/darwin/ios/framework/Source/overlay_layer_pool.mm