FlutterThreadSynchronizer Class Reference

#import <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:

1. The operation has not started at all (with a return value FALSE.)
2. The operation has ended (with a return value FALSE.)
3. 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;
}

Member Data Documentation

_beginResizeWaiting

- (BOOL) _beginResizeWaiting

protected

Definition at line 23 of file FlutterThreadSynchronizer.mm.

_condBlockBeginResize

- (condition_variable FlutterThreadSynchronizer()):

protected

Definition at line 26 of file FlutterThreadSynchronizer.mm.

_contentSizes

- (unordered_map<int64_t, CGSize> FlutterThreadSynchronizer()):

protected

Definition at line 20 of file FlutterThreadSynchronizer.mm.

_mainQueue

- (dispatch_queue_t) _mainQueue

protected

Definition at line 17 of file FlutterThreadSynchronizer.mm.

_mutex

- (mutex FlutterThreadSynchronizer()):

protected

Definition at line 18 of file FlutterThreadSynchronizer.mm.

_scheduledBlocks

- (vector<dispatch_block_t> FlutterThreadSynchronizer()):

protected

Definition at line 21 of file FlutterThreadSynchronizer.mm.

_shuttingDown

- (BOOL) _shuttingDown

protected

Definition at line 19 of file FlutterThreadSynchronizer.mm.

---

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

• shell/platform/darwin/macos/framework/Source/FlutterThreadSynchronizer.h
• shell/platform/darwin/macos/framework/Source/FlutterThreadSynchronizer.mm