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
(nullable instancetype)	- initWithMainQueue:
(BOOL)	- isWaitingWhenMutexIsAvailable
(void)	- blockUntilFrameAvailable

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

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 102 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;
}

Referenced by TEST().

blockUntilFrameAvailable

- (void) blockUntilFrameAvailable

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

Provided by category FlutterThreadSynchronizer(TestUtils).

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 186 of file FlutterThreadSynchronizer.mm.

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

init

- (instancetype) init

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

Definition at line 47 of file FlutterThreadSynchronizer.mm.

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

References initWithMainQueue:.

initWithMainQueue:

- (nullable instancetype) initWithMainQueue:

(nonnull dispatch_queue_t)

queue

Creates a FlutterThreadSynchronizer that uses the specified queue as the platform thread.

Provided by category FlutterThreadSynchronizer(TestUtils).

Referenced by init.

isWaitingWhenMutexIsAvailable

- (BOOL) isWaitingWhenMutexIsAvailable

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).

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 137 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();
}

Referenced by TEST(), and flutter::testing::TEST_F().

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 167 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 180 of file FlutterThreadSynchronizer.mm.

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

Referenced by TEST().

shutdown

- (void) shutdown

Called when the engine shuts down.

Prevents any further synchronization and no longer blocks any threads.

Definition at line 192 of file FlutterThreadSynchronizer.mm.

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

Referenced by TEST(), and flutter::testing::TEST_F().

---

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