#include <FlutterSurfaceManager.h>

Inheritance diagram for FlutterSurfaceManager:

Instance Methods
(nullable instancetype)	- initWithDevice:commandQueue:layer:delegate:

(nonnull FlutterSurface *)	- surfaceForSize:

(void)	- presentSurfaces:atTime:notify:

(instancetype)	- initWithDevice:commandQueue:layer:delegate: `[implementation]`

(FlutterBackBufferCache *)	- backBufferCache `[implementation]`

(NSArray *)	- frontSurfaces `[implementation]`

(NSArray *)	- layers `[implementation]`

(BOOL)	- enableSurfaceDebugInfo `[implementation]`

(void)	- commit: `[implementation]`

(void)	- presentSurfaces:atTime:notify: `[implementation]`

Class Methods
(static CGSize)	+ GetRequiredFrameSize `[implementation]`

Protected Attributes
id< MTLDevice >	_device

id< MTLCommandQueue >	_commandQueue

CALayer *	_containingLayer

__weak id< FlutterSurfaceManagerDelegate >	_delegate

FlutterBackBufferCache *	_backBufferCache

NSMutableArray< FlutterSurface * > *	_frontSurfaces

NSMutableArray< CALayer * > *	_layers

NSNumber *	_enableSurfaceDebugInfo

CATextLayer *	_infoLayer

CFTimeInterval	_lastPresentationTime

Detailed Description

FlutterSurfaceManager is responsible for providing and presenting Core Animation render surfaces and managing sublayers.

Owned by FlutterView.

Definition at line 44 of file FlutterSurfaceManager.h.

Method Documentation

◆ backBufferCache

- (FlutterBackBufferCache *) backBufferCache

implementation

Provided by category FlutterSurfaceManager(Private).

Definition at line 38 of file FlutterSurfaceManager.mm.

                                           {
  return _backBufferCache;
}

◆ commit:

- (void) commit: (NSArray< FlutterSurfacePresentInfo * > *) surfaces

implementation

Updates underlying CALayers with the contents of the surfaces to present.

Definition at line 38 of file FlutterSurfaceManager.mm.

              :(NSArray<FlutterSurfacePresentInfo*>*)surfaces {
  FML_DCHECK([NSThread isMainThread]);
 
  // Release all unused back buffer surfaces and replace them with front surfaces.
  [_backBufferCache returnSurfaces:_frontSurfaces];
 
  // Front surfaces will be replaced by currently presented surfaces.
  [_frontSurfaces removeAllObjects];
  for (FlutterSurfacePresentInfo* info in surfaces) {
    [_frontSurfaces addObject:info.surface];
  }
 
  // Add or remove layers to match the count of surfaces to present.
  while (_layers.count > _frontSurfaces.count) {
    [_layers.lastObject removeFromSuperlayer];
    [_layers removeLastObject];
  }
  while (_layers.count < _frontSurfaces.count) {
    CALayer* layer = [CALayer layer];
    [_containingLayer addSublayer:layer];
    [_layers addObject:layer];
  }
 
  bool enableSurfaceDebugInfo = self.enableSurfaceDebugInfo;
 
  // Update contents of surfaces.
  for (size_t i = 0; i < surfaces.count; ++i) {
    FlutterSurfacePresentInfo* info = surfaces[i];
    CALayer* layer = _layers[i];
    CGFloat scale = _containingLayer.contentsScale;
    if (i == 0) {
      layer.frame = CGRectMake(info.offset.x / scale, info.offset.y / scale,
                               info.surface.size.width / scale, info.surface.size.height / scale);
      layer.contents = (__bridge id)info.surface.ioSurface;
    } else {
      layer.frame = CGRectZero;
      NSColor* borderColor = enableSurfaceDebugInfo ? GetBorderColorForLayer(i - 1) : nil;
      UpdateContentSubLayers(layer, info.surface.ioSurface, scale, info.surface.size, borderColor,
                             info.paintRegion);
    }
    layer.zPosition = info.zIndex;
  }
 
  if (enableSurfaceDebugInfo) {
    if (_infoLayer == nil) {
      _infoLayer = [[CATextLayer alloc] init];
      [_containingLayer addSublayer:_infoLayer];
      _infoLayer.fontSize = 15;
      _infoLayer.foregroundColor = [NSColor yellowColor].CGColor;
      _infoLayer.frame = CGRectMake(15, 15, 300, 100);
      _infoLayer.contentsScale = _containingLayer.contentsScale;
      _infoLayer.zPosition = 100000;
    }
    _infoLayer.string = [NSString stringWithFormat:@"Surface count: %li", _layers.count];
  }
}

◆ enableSurfaceDebugInfo

- (BOOL) enableSurfaceDebugInfo

implementation

Definition at line 38 of file FlutterSurfaceManager.mm.

                               {
  if (_enableSurfaceDebugInfo == nil) {
    _enableSurfaceDebugInfo =
        [[NSBundle mainBundle] objectForInfoDictionaryKey:@"FLTEnableSurfaceDebugInfo"];
    if (_enableSurfaceDebugInfo == nil) {
      _enableSurfaceDebugInfo = @NO;
    }
  }
  return [_enableSurfaceDebugInfo boolValue];
}

◆ frontSurfaces

- (NSArray *) frontSurfaces

implementation

Provided by category FlutterSurfaceManager(Private).

Definition at line 38 of file FlutterSurfaceManager.mm.

                          {
  return _frontSurfaces;
}

◆ GetRequiredFrameSize

+ (static CGSize) GetRequiredFrameSize (NSArray< FlutterSurfacePresentInfo * > *) surfaces

implementation

Definition at line 209 of file FlutterSurfaceManager.mm.

                                                                                  {
  CGSize size = CGSizeZero;
  for (FlutterSurfacePresentInfo* info in surfaces) {
    size = CGSizeMake(std::max(size.width, info.offset.x + info.surface.size.width),
                      std::max(size.height, info.offset.y + info.surface.size.height));
  }
  return size;
}

◆ initWithDevice:commandQueue:layer:delegate: [1/2]

- (instancetype) initWithDevice:	(id<MTLDevice>)	device
commandQueue:	(id<MTLCommandQueue>)	commandQueue
layer:	(CALayer*)	containingLayer
delegate:	(__weak id<FlutterSurfaceManagerDelegate>)	delegate

implementation

Definition at line 38 of file FlutterSurfaceManager.mm.

                              :(id<MTLDevice>)device
                  commandQueue:(id<MTLCommandQueue>)commandQueue
                         layer:(CALayer*)containingLayer
                      delegate:(__weak id<FlutterSurfaceManagerDelegate>)delegate {
  if (self = [super init]) {
    _device = device;
    _commandQueue = commandQueue;
    _containingLayer = containingLayer;
    _delegate = delegate;
 
    _backBufferCache = [[FlutterBackBufferCache alloc] init];
    _frontSurfaces = [NSMutableArray array];
    _layers = [NSMutableArray array];
  }
  return self;
}

◆ initWithDevice:commandQueue:layer:delegate: [2/2]

- (nullable instancetype) initWithDevice:	(nonnull id< MTLDevice >)	device
commandQueue:	(nonnull id< MTLCommandQueue >)	commandQueue
layer:	(nonnull CALayer *)	containingLayer
delegate:	(nonnull id< FlutterSurfaceManagerDelegate >)	delegate

Initializes and returns a surface manager that renders to a child layer (referred to as the content layer) of the containing layer.

◆ layers

- (NSArray *) layers

implementation

Provided by category FlutterSurfaceManager(Private).

Definition at line 38 of file FlutterSurfaceManager.mm.

                   {
  return _layers;
}

◆ presentSurfaces:atTime:notify: [1/2]

- (void) presentSurfaces:	(nonnull NSArray< FlutterSurfacePresentInfo * > *)	surfaces
atTime:	(CFTimeInterval)	presentationTime
notify:	(nullable dispatch_block_t)	notify

Sets the provided surfaces as contents of FlutterView. Will create, update and remove sublayers as needed.

Must be called on raster thread. This will schedule a commit on the platform thread and block the raster thread until the commit is done. The notify block will be invoked on the platform thread and can be used to perform additional work, such as mutating platform views. It is guaranteed be called in the same CATransaction.

◆ presentSurfaces:atTime:notify: [2/2]

- (void) presentSurfaces:	(NSArray<FlutterSurfacePresentInfo>)	surfaces
atTime:	(CFTimeInterval)	presentationTime
notify:	(dispatch_block_t)	notify

implementation

Definition at line 209 of file FlutterSurfaceManager.mm.

                       :(NSArray<FlutterSurfacePresentInfo*>*)surfaces
                 atTime:(CFTimeInterval)presentationTime
                 notify:(dispatch_block_t)notify {
  id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
  [commandBuffer commit];
  [commandBuffer waitUntilScheduled];
 
  dispatch_block_t presentBlock = ^{
    // Get the actual dimensions of the frame (relevant for thread synchronizer).
    CGSize size = GetRequiredFrameSize(surfaces);
    [_delegate onPresent:size
               withBlock:^{
                 _lastPresentationTime = presentationTime;
                 [self commit:surfaces];
                 if (notify != nil) {
                   notify();
                 }
               }];
  };
 
  if (presentationTime > 0) {
    // Enforce frame pacing. It seems that the target timestamp of CVDisplayLink does not
    // exactly correspond to core animation deadline. Especially with 120hz, setting the frame
    // contents too close after previous target timestamp will result in uneven frame pacing.
    // Empirically setting the content in the second half of frame interval seems to work
    // well for both 60hz and 120hz.
    //
    // This schedules a timer on current (raster) thread runloop. Raster thread at
    // this point should be idle (the next frame vsync has not been signalled yet).
    //
    // Alternative could be simply blocking the raster thread, but that would show
    // as a average_frame_rasterizer_time_millis regresson.
    CFTimeInterval minPresentationTime = (presentationTime + _lastPresentationTime) / 2.0;
    CFTimeInterval now = CACurrentMediaTime();
    if (now < minPresentationTime) {
      NSTimer* timer = [NSTimer timerWithTimeInterval:minPresentationTime - now
                                              repeats:NO
                                                block:^(NSTimer* timer) {
                                                  presentBlock();
                                                }];
      [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
      return;
    }
  }
  presentBlock();
}

◆ surfaceForSize:

- (FlutterSurface *) surfaceForSize: (CGSize) size

Returns a back buffer surface of the given size to which Flutter can render content. A cached surface will be returned if available; otherwise a new one will be created.

Must be called on raster thread.

Definition at line 38 of file FlutterSurfaceManager.mm.

                                 :(CGSize)size {
  FlutterSurface* surface = [_backBufferCache removeSurfaceForSize:size];
  if (surface == nil) {
    surface = [[FlutterSurface alloc] initWithSize:size device:_device];
  }
  return surface;
}