#include <FlutterThreadSynchronizer.h>

Inheritance diagram for FlutterThreadSynchronizer:

Instance Methods
(nullable instancetype)	- init

(void)	- beginResizeForView:size:notify:

(void)	- performCommitForView:size:notify:

(void)	- performOnPlatformThread:

(void)	- registerView:

(void)	- deregisterView:

(void)	- shutdown

(instancetype)	- initWithMainQueue: `[implementation]`

(BOOL)	- allViewsHaveFrame `[implementation]`

(BOOL)	- someViewsHaveFrame `[implementation]`

(void)	- drain `[implementation]`

(void)	- blockUntilFrameAvailable `[implementation]`

(BOOL)	- isWaitingWhenMutexIsAvailable `[implementation]`

Protected Attributes
dispatch_queue_t	_mainQueue

std::mutex	_mutex

BOOL	_shuttingDown

std::unordered_map< int64_t, CGSize >	_contentSizes

std::vector< dispatch_block_t >	_scheduledBlocks

BOOL	_beginResizeWaiting

std::condition_variable	_condBlockBeginResize

Detailed Description

Takes care of synchronization between raster and platform thread.

All methods of this class must be called from the platform thread, except for performCommitForView:size:notify:.

Definition at line 18 of file FlutterThreadSynchronizer.h.

Method Documentation

◆ allViewsHaveFrame

- (BOOL) allViewsHaveFrame

implementation

Returns true if all existing views have a non-zero size.

If there are no views, still returns true.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                          {
  for (auto const& [viewIdentifier, contentSize] : _contentSizes) {
    if (CGSizeEqualToSize(contentSize, CGSizeZero)) {
      return NO;
    }
  }
  return YES;
}

◆ beginResizeForView:size:notify:

- (void) beginResizeForView:	(FlutterViewIdentifier)	viewIdentifier
size:	(CGSize)	size
notify:	(nonnull dispatch_block_t)	notify

Blocks until all views have a commit with their given sizes (or empty) is requested.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                          :(FlutterViewIdentifier)viewIdentifier
                      size:(CGSize)size
                    notify:(nonnull dispatch_block_t)notify {
  dispatch_assert_queue(_mainQueue);
  std::unique_lock<std::mutex> lock(_mutex);
 
  if (![self allViewsHaveFrame] || _shuttingDown) {
    // No blocking until framework produces at least one frame
    notify();
    return;
  }
 
  [self drain];
 
  notify();
 
  _contentSizes[viewIdentifier] = CGSizeMake(-1, -1);
 
  _beginResizeWaiting = YES;
 
  while (true) {
    if (_shuttingDown) {
      break;
    }
    const CGSize& contentSize = _contentSizes[viewIdentifier];
    if (CGSizeEqualToSize(contentSize, size) || CGSizeEqualToSize(contentSize, CGSizeZero)) {
      break;
    }
    _condBlockBeginResize.wait(lock);
    [self drain];
  }
 
  _beginResizeWaiting = NO;
}

◆ blockUntilFrameAvailable

- (void) blockUntilFrameAvailable

implementation

Blocks current thread until there is frame available. Used in FlutterEngineTest.

Provided by category FlutterThreadSynchronizer(TestUtils).

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                                 {
  std::unique_lock<std::mutex> lock(_mutex);
  [self drain];
 
  _beginResizeWaiting = YES;
  while (![self someViewsHaveFrame] && !_shuttingDown) {
    _condBlockBeginResize.wait(lock);
    [self drain];
  }
 
  _beginResizeWaiting = NO;
}

◆ deregisterView:

- (void) deregisterView: (FlutterViewIdentifier) viewIdentifier

Requests the synchronizer to no longer track a view.

It is typically done when the view controller is destroyed.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                      :(FlutterViewIdentifier)viewIdentifier {
  dispatch_assert_queue(_mainQueue);
  std::unique_lock<std::mutex> lock(_mutex);
  _contentSizes.erase(viewIdentifier);
}

◆ drain

- (void) drain

implementation

Definition at line 26 of file FlutterThreadSynchronizer.mm.

              {
  dispatch_assert_queue(_mainQueue);
 
  [CATransaction begin];
  [CATransaction setDisableActions:YES];
  for (dispatch_block_t block : _scheduledBlocks) {
    block();
  }
  [CATransaction commit];
  _scheduledBlocks.clear();
}

◆ init

- (instancetype) init

Creates a FlutterThreadSynchronizer that uses the OS main thread as the platform thread.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                     {
  return [self initWithMainQueue:dispatch_get_main_queue()];
}

◆ initWithMainQueue:

- (instancetype) initWithMainQueue: (dispatch_queue_t) queue

implementation

Provided by category FlutterThreadSynchronizer(TestUtils).

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                                 :(dispatch_queue_t)queue {
  self = [super init];
  if (self != nil) {
    _mainQueue = queue;
  }
  return self;
}

◆ isWaitingWhenMutexIsAvailable

- (BOOL) isWaitingWhenMutexIsAvailable

implementation

Blocks current thread until the mutex is available, then return whether the synchronizer is waiting for a correct commit during resizing.

After calling an operation of the thread synchronizer, call this method, and when it returns, the thread synchronizer can be at one of the following 3 states:

The operation has not started at all (with a return value FALSE.)
The operation has ended (with a return value FALSE.)
beginResizeForView: is in progress, waiting (with a return value TRUE.)

By eliminating the 1st case (such as using the notify callback), we can use this return value to decide whether the synchronizer is in case 2 or case 3, that is whether the resizing is blocked by a mismatching commit.

Provided by category FlutterThreadSynchronizer(TestUtils).

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                                      {
  std::unique_lock<std::mutex> lock(_mutex);
  return _beginResizeWaiting;
}

◆ performCommitForView:size:notify:

- (void) performCommitForView:	(FlutterViewIdentifier)	viewIdentifier
size:	(CGSize)	size
notify:	(nonnull dispatch_block_t)	notify

Called from raster thread. Schedules the given block on platform thread and blocks until it is performed.

If platform thread is blocked in beginResize: for given size (or size is empty), unblocks platform thread.

The notify block is guaranteed to be called within a core animation transaction.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                            :(FlutterViewIdentifier)viewIdentifier
                        size:(CGSize)size
                      notify:(nonnull dispatch_block_t)notify {
  dispatch_assert_queue_not(_mainQueue);
  fml::AutoResetWaitableEvent event;
  {
    std::unique_lock<std::mutex> lock(_mutex);
    if (_shuttingDown) {
      // Engine is shutting down, main thread may be blocked by the engine
      // waiting for raster thread to finish.
      return;
    }
    fml::AutoResetWaitableEvent& e = event;
    _scheduledBlocks.push_back(^{
      notify();
      _contentSizes[viewIdentifier] = size;
      e.Signal();
    });
    if (_beginResizeWaiting) {
      _condBlockBeginResize.notify_all();
    } else {
      dispatch_async(_mainQueue, ^{
        std::unique_lock<std::mutex> lock(_mutex);
        [self drain];
      });
    }
  }
  event.Wait();
}

◆ performOnPlatformThread:

- (void) performOnPlatformThread: (nonnull dispatch_block_t) block

Schedules the given block to be performed on the platform thread. The block will be performed even if the platform thread is blocked waiting for a commit.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                               :(nonnull dispatch_block_t)block {
  std::unique_lock<std::mutex> lock(_mutex);
  _scheduledBlocks.push_back(block);
  if (_beginResizeWaiting) {
    _condBlockBeginResize.notify_all();
  } else {
    dispatch_async(_mainQueue, ^{
      std::unique_lock<std::mutex> lock(_mutex);
      [self drain];
    });
  }
}

◆ registerView:

- (void) registerView: (FlutterViewIdentifier) viewIdentifier

Requests the synchronizer to track another view.

A view must be registered before calling begineResizeForView: or performCommitForView:. It is typically done when the view controller is created.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                    :(FlutterViewIdentifier)viewIdentifier {
  dispatch_assert_queue(_mainQueue);
  std::unique_lock<std::mutex> lock(_mutex);
  _contentSizes[viewIdentifier] = CGSizeZero;
}

◆ shutdown

- (void) shutdown

Called when the engine shuts down.

Prevents any further synchronization and no longer blocks any threads.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                 {
  dispatch_assert_queue(_mainQueue);
  std::unique_lock<std::mutex> lock(_mutex);
  _shuttingDown = YES;
  _condBlockBeginResize.notify_all();
  [self drain];
}

◆ someViewsHaveFrame

- (BOOL) someViewsHaveFrame

implementation

Returns true if there are any views that have a non-zero size.

If there are no views, returns false.

Definition at line 26 of file FlutterThreadSynchronizer.mm.

                           {
  for (auto const& [viewIdentifier, contentSize] : _contentSizes) {
    if (!CGSizeEqualToSize(contentSize, CGSizeZero)) {
      return YES;
    }
  }
  return NO;
}