#include <FlutterViewController.h>

Inheritance diagram for FlutterViewController:

Instance Methods
(instancetype)	- initWithEngine:nibName:bundle:

(instancetype)	- initWithProject:nibName:bundle:

(instancetype)	- initWithProject:initialRoute:nibName:bundle:

(instancetype)	- initWithCoder:

(void)	- setFlutterViewDidRenderCallback:

(NSString *)	- lookupKeyForAsset:

(NSString *)	- lookupKeyForAsset:fromPackage:

(void)	- setInitialRoute:

(void)	- popRoute

(void)	- pushRoute:

(id< FlutterPluginRegistry >)	- pluginRegistry

(BOOL)	- loadDefaultSplashScreenView

(nonnull instancetype)	- initWithProject:

(nonnull instancetype)	- initWithNibName:bundle:

(nonnull instancetype)	- initWithCoder:

(nonnull instancetype)	- initWithEngine:nibName:bundle:

(BOOL)	- attached

(void)	- onPreEngineRestart

(nonnull NSString *)	- lookupKeyForAsset:

(nonnull NSString *)	- lookupKeyForAsset:fromPackage:

(instancetype)	- initWithProject:nibName:bundle: `[implementation]`

(instancetype)	- initWithProject:initialRoute:nibName:bundle: `[implementation]`

(instancetype)	- initWithNibName:bundle: `[implementation]`

(void)	- awakeFromNib `[implementation]`

(instancetype)	- init `[implementation]`

(void)	- sharedSetupWithProject:initialRoute: `[implementation]`

(BOOL)	- isViewOpaque `[implementation]`

(void)	- setViewOpaque: `[implementation]`

(void)	- performCommonViewControllerInitialization `[implementation]`

(fml::WeakNSObject< FlutterViewController >)	- getWeakNSObject `[implementation]`

(void)	- setUpNotificationCenterObservers `[implementation]`

(void)	- setUpSceneLifecycleNotifications: `[implementation]`

(void)	- setUpApplicationLifecycleNotifications: `[implementation]`

(void)	- setInitialRoute: `[implementation]`

(void)	- loadView `[implementation]`

(flutter::PointerData)	- generatePointerDataForFake `[implementation]`

(BOOL)	- scrollViewShouldScrollToTop: `[implementation]`

(void)	- installSplashScreenViewIfNecessary `[implementation]`

(void)	- setDisplayingFlutterUI: `[implementation]`

(void)	- callViewRenderedCallback `[implementation]`

(void)	- removeSplashScreenView: `[implementation]`

(void)	- installFirstFrameCallback `[implementation]`

(UIView *)	- keyboardAnimationView `[implementation]`

(SpringAnimation *)	- keyboardSpringAnimation `[implementation]`

(UIView *)	- splashScreenFromStoryboard: `[implementation]`

(UIView *)	- splashScreenFromXib: `[implementation]`

(void)	- setSplashScreenView: `[implementation]`

(void)	- surfaceUpdated: `[implementation]`

(void)	- viewDidLoad `[implementation]`

(void)	- addInternalPlugins `[implementation]`

(void)	- removeInternalPlugins `[implementation]`

(void)	- viewWillAppear: `[implementation]`

(void)	- viewDidAppear: `[implementation]`

(void)	- viewWillDisappear: `[implementation]`

(void)	- viewDidDisappear: `[implementation]`

(void)	- viewWillTransitionToSize:withTransitionCoordinator: `[implementation]`

(void)	- flushOngoingTouches `[implementation]`

(void)	- deregisterNotifications `[implementation]`

(void)	- dealloc `[implementation]`

(void)	- applicationBecameActive: `[implementation]`

(void)	- applicationWillResignActive: `[implementation]`

(void)	- applicationWillTerminate: `[implementation]`

(void)	- applicationDidEnterBackground: `[implementation]`

(void)	- applicationWillEnterForeground: `[implementation]`

(void)	- sceneBecameActive: `[implementation]`

(void)	- sceneWillResignActive: `[implementation]`

(void)	- sceneWillDisconnect: `[implementation]`

(void)	- sceneDidEnterBackground: `[implementation]`

(void)	- sceneWillEnterForeground: `[implementation]`

(void)	- appOrSceneBecameActive `[implementation]`

(void)	- appOrSceneWillResignActive `[implementation]`

(void)	- appOrSceneWillTerminate `[implementation]`

(void)	- appOrSceneDidEnterBackground `[implementation]`

(void)	- appOrSceneWillEnterForeground `[implementation]`

(void)	- goToApplicationLifecycle: `[implementation]`

(void)	- dispatchTouches:pointerDataChangeOverride:event: `[implementation]`

(void)	- touchesBegan:withEvent: `[implementation]`

(void)	- touchesMoved:withEvent: `[implementation]`

(void)	- touchesEnded:withEvent: `[implementation]`

(void)	- touchesCancelled:withEvent: `[implementation]`

(void)	- forceTouchesCancelled: `[implementation]`

(void)	- createTouchRateCorrectionVSyncClientIfNeeded `[implementation]`

(void)	- triggerTouchRateCorrectionIfNeeded: `[implementation]`

(void)	- invalidateTouchRateCorrectionVSyncClient `[implementation]`

(void)	- updateViewportMetricsIfNeeded `[implementation]`

(void)	- viewDidLayoutSubviews `[implementation]`

(void)	- viewSafeAreaInsetsDidChange `[implementation]`

(void)	- setViewportMetricsSize `[implementation]`

(void)	- setViewportMetricsPaddings `[implementation]`

(void)	- keyboardWillShowNotification: `[implementation]`

(void)	- keyboardWillChangeFrame: `[implementation]`

(void)	- keyboardWillBeHidden: `[implementation]`

(void)	- handleKeyboardNotification: `[implementation]`

(BOOL)	- shouldIgnoreKeyboardNotification: `[implementation]`

(BOOL)	- isKeyboardNotificationForDifferentView: `[implementation]`

(FlutterKeyboardMode)	- calculateKeyboardAttachMode: `[implementation]`

(CGFloat)	- calculateMultitaskingAdjustment:keyboardFrame: `[implementation]`

(CGFloat)	- calculateKeyboardInset:keyboardMode: `[implementation]`

(void)	- startKeyBoardAnimation: `[implementation]`

(void)	- setUpKeyboardSpringAnimationIfNeeded: `[implementation]`

(void)	- setUpKeyboardAnimationVsyncClient: `[implementation]`

(void)	- invalidateKeyboardAnimationVSyncClient `[implementation]`

(void)	- removeKeyboardAnimationView `[implementation]`

(void)	- ensureViewportMetricsIsCorrect `[implementation]`

(void)	- handlePressEvent:nextAction: `[implementation]`

(void)	- pressesBegan:withEvent: `[implementation]`

(void)	- pressesChanged:withEvent: `[implementation]`

(void)	- pressesEnded:withEvent: `[implementation]`

(void)	- pressesCancelled:withEvent: `[implementation]`

(void)	- onOrientationPreferencesUpdated: `[implementation]`

(void)	- requestGeometryUpdateForWindowScenes: `[implementation]`

(void)	- performOrientationUpdate: `[implementation]`

(void)	- onHideHomeIndicatorNotification: `[implementation]`

(void)	- onShowHomeIndicatorNotification: `[implementation]`

(void)	- setIsHomeIndicatorHidden: `[implementation]`

(BOOL)	- prefersHomeIndicatorAutoHidden `[implementation]`

(BOOL)	- shouldAutorotate `[implementation]`

(NSUInteger)	- supportedInterfaceOrientations `[implementation]`

(void)	- onAccessibilityStatusChanged: `[implementation]`

(int32_t)	- accessibilityFlags `[implementation]`

(BOOL)	- accessibilityPerformEscape `[implementation]`

(void)	- traitCollectionDidChange: `[implementation]`

(void)	- onUserSettingsChanged: `[implementation]`

(CGFloat)	- textScaleFactor `[implementation]`

(BOOL)	- supportsShowingSystemContextMenu `[implementation]`

(BOOL)	- isAlwaysUse24HourFormat `[implementation]`

(NSString *)	- brightnessMode `[implementation]`

(NSString *)	- contrastMode `[implementation]`

(UIStatusBarStyle)	- preferredStatusBarStyle `[implementation]`

(void)	- onPreferredStatusBarStyleUpdated: `[implementation]`

(void)	- setPrefersStatusBarHidden: `[implementation]`

(BOOL)	- prefersStatusBarHidden `[implementation]`
	Whether the status bar is preferred hidden.

(std::shared_ptr< flutter::FlutterPlatformViewsController > &)	- platformViewsController `[implementation]`

(void)	- sendOnChannel:message: `[implementation]`

(void)	- sendOnChannel:message:binaryReply: `[implementation]`

(NSObject< FlutterTaskQueue > *)	- makeBackgroundTaskQueue `[implementation]`
	TODO(gaaclarke): Remove optional when macos supports Background Platform Channels.

(FlutterBinaryMessengerConnection)	- setMessageHandlerOnChannel:binaryMessageHandler: `[implementation]`

(FlutterBinaryMessengerConnection)	- setMessageHandlerOnChannel:binaryMessageHandler:taskQueue: `[implementation]`

(void)	- cleanUpConnection: `[implementation]`

(int64_t)	- registerTexture: `[implementation]`

(void)	- unregisterTexture: `[implementation]`

(void)	- textureFrameAvailable: `[implementation]`

(NSObject< FlutterPluginRegistrar > *)	- registrarForPlugin: `[implementation]`

(BOOL)	- hasPlugin: `[implementation]`

(NSObject *)	- valuePublishedByPlugin: `[implementation]`

(void)	- presentViewController:animated:completion: `[implementation]`

(BOOL)	- isPresentingViewController `[implementation]`

()	- ios `[implementation]`

(BOOL)	- gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer: `[implementation]`

(BOOL)	- gestureRecognizer:shouldReceiveEvent: `[implementation]`

(void)	- hoverEvent: `[implementation]`

(void)	- discreteScrollEvent: `[implementation]`

(void)	- continuousScrollEvent: `[implementation]`

(void)	- pinchEvent: `[implementation]`

(void)	- encodeRestorableStateWithCoder: `[implementation]`

(void)	- decodeRestorableStateWithCoder: `[implementation]`

(FlutterRestorationPlugin *)	- restorationPlugin `[implementation]`

(BOOL)	- isDispatchingKeyEvent: `[implementation]`

(void)	- viewWillAppear `[implementation]`

(void)	- viewWillDisappear `[implementation]`

(void)	- setMouseTrackingMode: `[implementation]`

(void)	- setBackgroundColor: `[implementation]`

(void)	- notifySemanticsEnabledChanged `[implementation]`

(std::weak_ptr< flutter::AccessibilityBridgeMac >)	- accessibilityBridge `[implementation]`

(void)	- setUpWithEngine:viewIdentifier:threadSynchronizer: `[implementation]`

(void)	- detachFromEngine `[implementation]`

(void)	- updateSemantics: `[implementation]`

(BOOL)	- launchEngine `[implementation]`

(void)	- listenForMetaModifiedKeyUpEvents `[implementation]`

(void)	- configureTrackingArea `[implementation]`

(void)	- initializeKeyboard `[implementation]`

(void)	- dispatchMouseEvent: `[implementation]`

(void)	- dispatchGestureEvent: `[implementation]`

(void)	- dispatchMouseEvent:phase: `[implementation]`

(void)	- onAccessibilityStatusChanged: `[implementation]`

(std::shared_ptr< flutter::AccessibilityBridgeMac >)	- createAccessibilityBridgeWithEngine: `[implementation]`

(nonnull FlutterView *)	- createFlutterViewWithMTLDevice:commandQueue: `[implementation]`

(void)	- onKeyboardLayoutChanged `[implementation]`

(void)	- viewDidReshape: `[implementation]`

(BOOL)	- viewShouldAcceptFirstResponder: `[implementation]`

(void)	- sendKeyEvent:callback:userData: `[implementation]`

(id< FlutterBinaryMessenger >)	- getBinaryMessenger `[implementation]`

(BOOL)	- onTextInputKeyEvent: `[implementation]`

(void)	- subscribeToKeyboardLayoutChange: `[implementation]`

(LayoutClue)	- lookUpLayoutForKeyCode:shift: `[implementation]`

(nonnull NSDictionary *)	- getPressedState `[implementation]`

(BOOL)	- acceptsFirstResponder `[implementation]`

(void)	- keyDown: `[implementation]`

(void)	- keyUp: `[implementation]`

(void)	- flagsChanged: `[implementation]`

(void)	- mouseEntered: `[implementation]`

(void)	- mouseExited: `[implementation]`

(void)	- mouseDown: `[implementation]`

(void)	- mouseUp: `[implementation]`

(void)	- mouseDragged: `[implementation]`

(void)	- rightMouseDown: `[implementation]`

(void)	- rightMouseUp: `[implementation]`

(void)	- rightMouseDragged: `[implementation]`

(void)	- otherMouseDown: `[implementation]`

(void)	- otherMouseUp: `[implementation]`

(void)	- otherMouseDragged: `[implementation]`

(void)	- mouseMoved: `[implementation]`

(void)	- scrollWheel: `[implementation]`

(void)	- magnifyWithEvent: `[implementation]`

(void)	- rotateWithEvent: `[implementation]`

(void)	- swipeWithEvent: `[implementation]`

(void)	- touchesBeganWithEvent: `[implementation]`

(UIHoverGestureRecognizer *hoverGestureRecognizer)	- API_AVAILABLE `[implementation]`

(UIPanGestureRecognizer *discreteScrollingPanGestureRecognizer)	- API_AVAILABLE `[implementation]`

(UIPanGestureRecognizer *continuousScrollingPanGestureRecognizer)	- API_AVAILABLE `[implementation]`

(UIPinchGestureRecognizer *pinchGestureRecognizer)	- API_AVAILABLE `[implementation]`

(UIRotationGestureRecognizer *rotationGestureRecognizer)	- API_AVAILABLE `[implementation]`

Instance Methods inherited from <FlutterPluginRegistry>
(nonnull id< FlutterPluginRegistrar >)	- registrarForPlugin:

(nullable NSObject *)	- valuePublishedByPlugin:

Instance Methods inherited from <FlutterBinaryMessenger>
(void)	- sendOnChannel:message:

(void)	- sendOnChannel:message:binaryReply:

(FlutterBinaryMessengerConnection)	- setMessageHandlerOnChannel:binaryMessageHandler:

Instance Methods inherited from <FlutterViewResponder>
(void)	- touchesEstimatedPropertiesUpdated:

Instance Methods inherited from <FlutterKeyboardViewDelegate>
(void)	- subscribeToKeyboardLayoutChange:

Class Methods
(BOOL)	+ isUIAccessibilityIsVoiceOverRunning

(static UIView *)	+ GetViewOrPlaceholder `[implementation]`

(static void)	+ SendFakeTouchEvent `[implementation]`

(BOOL)	+ automaticallyNotifiesObserversOfDisplayingFlutterUI `[implementation]`

(static flutter::PointerData::Change)	+ PointerDataChangeFromUITouchPhase `[implementation]`

(static flutter::PointerData::DeviceKind)	+ DeviceKindFromTouchType `[implementation]`

(BOOL)	+ accessibilityIsOnOffSwitchLabelsEnabled `[implementation]`

(static void)	+ CommonInit `[implementation]`

(static NSData *)	+ CurrentKeyboardLayoutData `[implementation]`

Properties
BOOL	displayingFlutterUI

UIView *	splashScreenView

BOOL	viewOpaque

FlutterEngine *	engine

NSObject< FlutterBinaryMessenger > *	binaryMessenger

BOOL	engineAllowHeadlessExecution

FlutterMouseTrackingMode	mouseTrackingMode

FlutterViewIdentifier	viewIdentifier

NSColor *	backgroundColor

BOOL	isHomeIndicatorHidden `[implementation]`

BOOL	isPresentingViewControllerAnimating `[implementation]`

BOOL	shouldIgnoreViewportMetricsUpdatesDuringRotation `[implementation]`

CGFloat	targetViewInsetBottom `[implementation]`

CGFloat	originalViewInsetBottom `[implementation]`

VSyncClient *	keyboardAnimationVSyncClient `[implementation]`

BOOL	keyboardAnimationIsShowing `[implementation]`

fml::TimePoint	keyboardAnimationStartTime `[implementation]`

BOOL	isKeyboardInOrTransitioningFromBackground `[implementation]`

VSyncClient *	touchRateCorrectionVSyncClient `[implementation]`

BOOL	isVoiceOverRunning `[implementation]`

FlutterKeyboardManager *	keyboardManager `[implementation]`

NSTrackingArea *	trackingArea `[implementation]`

MouseState	mouseState `[implementation]`

id	keyUpMonitor `[implementation]`

KeyboardLayoutNotifier	keyboardLayoutNotifier `[implementation]`

NSData *	keyboardLayoutData `[implementation]`

FlutterView *	flutterView `[implementation]`

FlutterTextInputPlugin *	textInputPlugin `[implementation]`

Properties inherited from <FlutterViewResponder>
UIView *	view

Properties inherited from <FlutterKeyboardViewDelegate>
NSResponder *	nextResponder

Detailed Description

A UIViewController implementation for Flutter views.

Dart execution, channel communication, texture registration, and plugin registration are all handled by FlutterEngine. Calls on this class to those members all proxy through to the FlutterEngine attached FlutterViewController.

A FlutterViewController can be initialized either with an already-running FlutterEngine via the initWithEngine: initializer, or it can be initialized with a FlutterDartProject that will be used to implicitly spin up a new FlutterEngine. Creating a FlutterEngine before showing a FlutterViewController can be used to pre-initialize the Dart VM and to prepare the isolate in order to reduce the latency to the first rendered frame. See https://flutter.dev/docs/development/add-to-app/performance for more details on loading latency.

Holding a FlutterEngine independently of FlutterViewControllers can also be used to not to lose Dart-related state and asynchronous tasks when navigating back and forth between a FlutterViewController and other UIViewControllers.

Controls a view that displays Flutter content and manages input.

A FlutterViewController works with a FlutterEngine. Upon creation, the view controller is always added to an engine, either a given engine, or it implicitly creates an engine and add itself to that engine.

The FlutterEngine assigns each view controller attached to it a unique ID. Each view controller corresponds to a view, and the ID is used by the framework to specify which view to operate.

A FlutterViewController can also be unattached to an engine after it is manually unset from the engine, or transiently during the initialization process. An unattached view controller is invalid. Whether the view controller is attached can be queried using attached (FlutterViewController).

The FlutterViewController strongly references the FlutterEngine, while the engine weakly the view controller. When a FlutterViewController is deallocated, it automatically removes itself from its attached engine. When a FlutterEngine has no FlutterViewControllers attached, it might shut down itself or not depending on its configuration.

Definition at line 56 of file FlutterViewController.h.

Method Documentation

◆ acceptsFirstResponder

- (BOOL) acceptsFirstResponder

implementation

Definition at line 891 of file FlutterViewController.mm.

                              {
  return YES;
}

◆ accessibilityBridge

- (weak_ptr<) flutter:

implementation

Definition at line 338 of file FlutterViewController.mm.

                                                                  {
  return _bridge;
}

◆ accessibilityFlags

- (int32_t) accessibilityFlags

implementation

Definition at line 1112 of file FlutterViewController.mm.

                              {
  int32_t flags = 0;
  if (UIAccessibilityIsInvertColorsEnabled()) {
    flags |= static_cast<int32_t>(flutter::AccessibilityFeatureFlag::kInvertColors);
  }
  if (UIAccessibilityIsReduceMotionEnabled()) {
    flags |= static_cast<int32_t>(flutter::AccessibilityFeatureFlag::kReduceMotion);
  }
  if (UIAccessibilityIsBoldTextEnabled()) {
    flags |= static_cast<int32_t>(flutter::AccessibilityFeatureFlag::kBoldText);
  }
  if (UIAccessibilityDarkerSystemColorsEnabled()) {
    flags |= static_cast<int32_t>(flutter::AccessibilityFeatureFlag::kHighContrast);
  }
  if ([FlutterViewController accessibilityIsOnOffSwitchLabelsEnabled]) {
    flags |= static_cast<int32_t>(flutter::AccessibilityFeatureFlag::kOnOffSwitchLabels);
  }
 
  return flags;
}

◆ accessibilityIsOnOffSwitchLabelsEnabled

+ (BOOL) accessibilityIsOnOffSwitchLabelsEnabled

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                                {
  if (@available(iOS 13, *)) {
    return UIAccessibilityIsOnOffSwitchLabelsEnabled();
  } else {
    return NO;
  }
}

◆ accessibilityPerformEscape

- (BOOL) accessibilityPerformEscape

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                   {
  FlutterMethodChannel* navigationChannel = [_engine.get() navigationChannel];
  if (navigationChannel) {
    [self popRoute];
    return YES;
  }
  return NO;
}

◆ addInternalPlugins

- (void) addInternalPlugins

implementation

Creates and registers plugins used by this view controller.

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                           {
  self.keyboardManager = [[[FlutterKeyboardManager alloc] init] autorelease];
  fml::WeakNSObject<FlutterViewController> weakSelf = [self getWeakNSObject];
  FlutterSendKeyEvent sendEvent =
      ^(const FlutterKeyEvent& event, FlutterKeyEventCallback callback, void* userData) {
        if (weakSelf) {
          [weakSelf.get()->_engine.get() sendKeyEvent:event callback:callback userData:userData];
        }
      };
  [self.keyboardManager addPrimaryResponder:[[[FlutterEmbedderKeyResponder alloc]
                                                initWithSendEvent:sendEvent] autorelease]];
  FlutterChannelKeyResponder* responder = [[[FlutterChannelKeyResponder alloc]
      initWithChannel:self.engine.keyEventChannel] autorelease];
  [self.keyboardManager addPrimaryResponder:responder];
  FlutterTextInputPlugin* textInputPlugin = self.engine.textInputPlugin;
  if (textInputPlugin != nil) {
    [self.keyboardManager addSecondaryResponder:textInputPlugin];
  }
  if ([_engine.get() viewController] == self) {
    [textInputPlugin setUpIndirectScribbleInteraction:self];
  }
}

◆ API_AVAILABLE [1/5]

- (UIHoverGestureRecognizer *hoverGestureRecognizer) API_AVAILABLE (ios(13.4))

implementation

Provided by category FlutterViewController().

◆ API_AVAILABLE [2/5]

- (UIPanGestureRecognizer *discreteScrollingPanGestureRecognizer) API_AVAILABLE (ios(13.4))

implementation

Provided by category FlutterViewController().

◆ API_AVAILABLE [3/5]

- (UIPanGestureRecognizer *continuousScrollingPanGestureRecognizer) API_AVAILABLE (ios(13.4))

implementation

Provided by category FlutterViewController().

◆ API_AVAILABLE [4/5]

- (UIPinchGestureRecognizer *pinchGestureRecognizer) API_AVAILABLE (ios(13.4))

implementation

Provided by category FlutterViewController().

◆ API_AVAILABLE [5/5]

- (UIRotationGestureRecognizer *rotationGestureRecognizer) API_AVAILABLE (ios(13.4))

implementation

Provided by category FlutterViewController().

◆ applicationBecameActive:

- (void) applicationBecameActive: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                               :(NSNotification*)notification {
  TRACE_EVENT0("flutter", "applicationBecameActive");
  [self appOrSceneBecameActive];
}

◆ applicationDidEnterBackground:

- (void) applicationDidEnterBackground: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                     :(NSNotification*)notification {
  TRACE_EVENT0("flutter", "applicationDidEnterBackground");
  [self appOrSceneDidEnterBackground];
}

◆ applicationWillEnterForeground:

- (void) applicationWillEnterForeground: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                      :(NSNotification*)notification {
  TRACE_EVENT0("flutter", "applicationWillEnterForeground");
  [self appOrSceneWillEnterForeground];
}

◆ applicationWillResignActive:

- (void) applicationWillResignActive: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                   :(NSNotification*)notification {
  TRACE_EVENT0("flutter", "applicationWillResignActive");
  [self appOrSceneWillResignActive];
}

◆ applicationWillTerminate:

- (void) applicationWillTerminate: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                :(NSNotification*)notification {
  [self appOrSceneWillTerminate];
}

◆ appOrSceneBecameActive

- (void) appOrSceneBecameActive

implementation

Definition at line 527 of file FlutterViewController.mm.

                               {
  self.isKeyboardInOrTransitioningFromBackground = NO;
  if (_viewportMetrics.physical_width) {
    [self surfaceUpdated:YES];
  }
  [self performSelector:@selector(goToApplicationLifecycle:)
             withObject:@"AppLifecycleState.resumed"
             afterDelay:0.0f];
}

◆ appOrSceneDidEnterBackground

- (void) appOrSceneDidEnterBackground

implementation

Definition at line 527 of file FlutterViewController.mm.

                                     {
  self.isKeyboardInOrTransitioningFromBackground = YES;
  [self surfaceUpdated:NO];
  [self goToApplicationLifecycle:@"AppLifecycleState.paused"];
}

◆ appOrSceneWillEnterForeground

- (void) appOrSceneWillEnterForeground

implementation

Definition at line 527 of file FlutterViewController.mm.

                                      {
  [self goToApplicationLifecycle:@"AppLifecycleState.inactive"];
}

◆ appOrSceneWillResignActive

- (void) appOrSceneWillResignActive

implementation

Definition at line 527 of file FlutterViewController.mm.

                                   {
  [NSObject cancelPreviousPerformRequestsWithTarget:self
                                           selector:@selector(goToApplicationLifecycle:)
                                             object:@"AppLifecycleState.resumed"];
  [self goToApplicationLifecycle:@"AppLifecycleState.inactive"];
}

◆ appOrSceneWillTerminate

- (void) appOrSceneWillTerminate

implementation

Definition at line 527 of file FlutterViewController.mm.

                                {
  [self goToApplicationLifecycle:@"AppLifecycleState.detached"];
  [self.engine destroyContext];
}

◆ attached

- (BOOL) attached

Return YES if the view controller is attached to an engine.

Definition at line 338 of file FlutterViewController.mm.

                 {
  return _engine != nil;
}

◆ automaticallyNotifiesObserversOfDisplayingFlutterUI

+ (BOOL) automaticallyNotifiesObserversOfDisplayingFlutterUI

implementation

Definition at line 527 of file FlutterViewController.mm.

                                                            {
  return NO;
}

◆ awakeFromNib

- (void) awakeFromNib

implementation

Definition at line 152 of file FlutterViewController.mm.

                     {
  [super awakeFromNib];
  if (!_engine) {
    [self sharedSetupWithProject:nil initialRoute:nil];
  }
}

◆ brightnessMode

- (NSString *) brightnessMode

implementation

Definition at line 1112 of file FlutterViewController.mm.

                            {
  if (@available(iOS 13, *)) {
    UIUserInterfaceStyle style = self.traitCollection.userInterfaceStyle;
 
    if (style == UIUserInterfaceStyleDark) {
      return @"dark";
    } else {
      return @"light";
    }
  } else {
    return @"light";
  }
}

◆ calculateKeyboardAttachMode:

- (FlutterKeyboardMode) calculateKeyboardAttachMode: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                                  :(NSNotification*)notification {
  // There are multiple types of keyboard: docked, undocked, split, split docked,
  // floating, expanded shortcuts bar, minimized shortcuts bar. This function will categorize
  // the keyboard as one of the following modes: docked, floating, or hidden.
  // Docked mode includes docked, split docked, expanded shortcuts bar (when opening via click),
  // and minimized shortcuts bar (when opened via click).
  // Floating includes undocked, split, floating, expanded shortcuts bar (when dragged and dropped),
  // and minimized shortcuts bar (when dragged and dropped).
  NSDictionary* info = notification.userInfo;
  CGRect keyboardFrame = [info[UIKeyboardFrameEndUserInfoKey] CGRectValue];
 
  if (notification.name == UIKeyboardWillHideNotification) {
    return FlutterKeyboardModeHidden;
  }
 
  // If keyboard's dimensions and position are all zeroes, that means it's a Minimized/Expanded
  // Shortcuts Bar that has been dropped after dragging, which we categorize as floating.
  if (CGRectEqualToRect(keyboardFrame, CGRectZero)) {
    return FlutterKeyboardModeFloating;
  }
  // If keyboard's width or height are 0, it's hidden.
  if (CGRectIsEmpty(keyboardFrame)) {
    return FlutterKeyboardModeHidden;
  }
 
  CGRect screenRect = [self flutterScreenIfViewLoaded].bounds;
  CGRect adjustedKeyboardFrame = keyboardFrame;
  adjustedKeyboardFrame.origin.y += [self calculateMultitaskingAdjustment:screenRect
                                                            keyboardFrame:keyboardFrame];
 
  // If the keyboard is partially or fully showing within the screen, it's either docked or
  // floating. Sometimes with custom keyboard extensions, the keyboard's position may be off by a
  // small decimal amount (which is why CGRectIntersectRect can't be used). Round to compare.
  CGRect intersection = CGRectIntersection(adjustedKeyboardFrame, screenRect);
  CGFloat intersectionHeight = CGRectGetHeight(intersection);
  CGFloat intersectionWidth = CGRectGetWidth(intersection);
  if (round(intersectionHeight) > 0 && intersectionWidth > 0) {
    // If the keyboard is above the bottom of the screen, it's floating.
    CGFloat screenHeight = CGRectGetHeight(screenRect);
    CGFloat adjustedKeyboardBottom = CGRectGetMaxY(adjustedKeyboardFrame);
    if (round(adjustedKeyboardBottom) < screenHeight) {
      return FlutterKeyboardModeFloating;
    }
    return FlutterKeyboardModeDocked;
  }
  return FlutterKeyboardModeHidden;
}

◆ calculateKeyboardInset:keyboardMode:

- (CGFloat) calculateKeyboardInset:	(CGRect)	keyboardFrame
keyboardMode:	(NSInteger)	keyboardMode

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                 :(CGRect)keyboardFrame keyboardMode:(NSInteger)keyboardMode {
  // Only docked keyboards will have an inset.
  if (keyboardMode == FlutterKeyboardModeDocked) {
    // Calculate how much of the keyboard intersects with the view.
    CGRect viewRectRelativeToScreen =
        [self.viewIfLoaded convertRect:self.viewIfLoaded.frame
                     toCoordinateSpace:[self flutterScreenIfViewLoaded].coordinateSpace];
    CGRect intersection = CGRectIntersection(keyboardFrame, viewRectRelativeToScreen);
    CGFloat portionOfKeyboardInView = CGRectGetHeight(intersection);
 
    // The keyboard is treated as an inset since we want to effectively reduce the window size by
    // the keyboard height. The Dart side will compute a value accounting for the keyboard-consuming
    // bottom padding.
    CGFloat scale = [self flutterScreenIfViewLoaded].scale;
    return portionOfKeyboardInView * scale;
  }
  return 0;
}

◆ calculateMultitaskingAdjustment:keyboardFrame:

- (CGFloat) calculateMultitaskingAdjustment:	(CGRect)	screenRect
keyboardFrame:	(CGRect)	keyboardFrame

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                          :(CGRect)screenRect keyboardFrame:(CGRect)keyboardFrame {
  // In Slide Over mode, the keyboard's frame does not include the space
  // below the app, even though the keyboard may be at the bottom of the screen.
  // To handle, shift the Y origin by the amount of space below the app.
  if (self.viewIfLoaded.traitCollection.userInterfaceIdiom == UIUserInterfaceIdiomPad &&
      self.viewIfLoaded.traitCollection.horizontalSizeClass == UIUserInterfaceSizeClassCompact &&
      self.viewIfLoaded.traitCollection.verticalSizeClass == UIUserInterfaceSizeClassRegular) {
    CGFloat screenHeight = CGRectGetHeight(screenRect);
    CGFloat keyboardBottom = CGRectGetMaxY(keyboardFrame);
 
    // Stage Manager mode will also meet the above parameters, but it does not handle
    // the keyboard positioning the same way, so skip if keyboard is at bottom of page.
    if (screenHeight == keyboardBottom) {
      return 0;
    }
    CGRect viewRectRelativeToScreen =
        [self.viewIfLoaded convertRect:self.viewIfLoaded.frame
                     toCoordinateSpace:[self flutterScreenIfViewLoaded].coordinateSpace];
    CGFloat viewBottom = CGRectGetMaxY(viewRectRelativeToScreen);
    CGFloat offset = screenHeight - viewBottom;
    if (offset > 0) {
      return offset;
    }
  }
  return 0;
}

◆ callViewRenderedCallback

- (void) callViewRenderedCallback

implementation

Definition at line 527 of file FlutterViewController.mm.

                                 {
  self.displayingFlutterUI = YES;
  if (_flutterViewRenderedCallback != nil) {
    _flutterViewRenderedCallback.get()();
    _flutterViewRenderedCallback.reset();
  }
}

◆ cleanUpConnection:

- (void) cleanUpConnection: (FlutterBinaryMessengerConnection) connection

implementation

Clears out a channel's message handler if that handler is still the one that was created as a result of setMessageHandlerOnChannel:binaryMessageHandler:.

Parameters

connection The result from setMessageHandlerOnChannel:binaryMessageHandler:.

Reimplemented from <FlutterBinaryMessenger>.

Definition at line 1112 of file FlutterViewController.mm.

                         :(FlutterBinaryMessengerConnection)connection {
  [_engine.get().binaryMessenger cleanUpConnection:connection];
}

◆ CommonInit

+ (static void) CommonInit	(FlutterViewController *)	controller
	(FlutterEngine *)	engine

implementation

Performs initialization that's common between the different init paths.

Definition at line 338 of file FlutterViewController.mm.

                                                                                 {
  if (!engine) {
    engine = [[FlutterEngine alloc] initWithName:@"io.flutter"
                                         project:controller->_project
                          allowHeadlessExecution:NO];
  }
  NSCAssert(controller.engine == nil,
            @"The FlutterViewController is unexpectedly attached to "
            @"engine %@ before initialization.",
            controller.engine);
  [engine addViewController:controller];
  NSCAssert(controller.engine != nil,
            @"The FlutterViewController unexpectedly stays unattached after initialization. "
            @"In unit tests, this is likely because either the FlutterViewController or "
            @"the FlutterEngine is mocked. Please subclass these classes instead.",
            controller.engine, controller.viewIdentifier);
  controller->_mouseTrackingMode = kFlutterMouseTrackingModeInKeyWindow;
  controller->_textInputPlugin = [[FlutterTextInputPlugin alloc] initWithViewController:controller];
  [controller initializeKeyboard];
  [controller notifySemanticsEnabledChanged];
  // macOS fires this message when changing IMEs.
  CFNotificationCenterRef cfCenter = CFNotificationCenterGetDistributedCenter();
  __weak FlutterViewController* weakSelf = controller;
  CFNotificationCenterAddObserver(cfCenter, (__bridge void*)weakSelf, OnKeyboardLayoutChanged,
                                  kTISNotifySelectedKeyboardInputSourceChanged, NULL,
                                  CFNotificationSuspensionBehaviorDeliverImmediately);
}

◆ configureTrackingArea

- (void) configureTrackingArea

implementation

Updates |trackingArea| for the current tracking settings, creating it with the correct mode if tracking is enabled, or removing it if not.

Definition at line 338 of file FlutterViewController.mm.

                              {
  if (!self.viewLoaded) {
    // The viewDidLoad will call configureTrackingArea again when
    // the view is actually loaded.
    return;
  }
  if (_mouseTrackingMode != kFlutterMouseTrackingModeNone && self.flutterView) {
    NSTrackingAreaOptions options = NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
                                    NSTrackingInVisibleRect | NSTrackingEnabledDuringMouseDrag;
    switch (_mouseTrackingMode) {
      case kFlutterMouseTrackingModeInKeyWindow:
        options |= NSTrackingActiveInKeyWindow;
        break;
      case kFlutterMouseTrackingModeInActiveApp:
        options |= NSTrackingActiveInActiveApp;
        break;
      case kFlutterMouseTrackingModeAlways:
        options |= NSTrackingActiveAlways;
        break;
      default:
        NSLog(@"Error: Unrecognized mouse tracking mode: %ld", _mouseTrackingMode);
        return;
    }
    _trackingArea = [[NSTrackingArea alloc] initWithRect:NSZeroRect
                                                 options:options
                                                   owner:self
                                                userInfo:nil];
    [self.flutterView addTrackingArea:_trackingArea];
  } else if (_trackingArea) {
    [self.flutterView removeTrackingArea:_trackingArea];
    _trackingArea = nil;
  }
}

◆ continuousScrollEvent:

- (void) continuousScrollEvent: (ios(13.4)) API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                             :(UIPanGestureRecognizer*)recognizer API_AVAILABLE(ios(13.4)) {
  CGPoint translation = [recognizer translationInView:self.view];
  const CGFloat scale = [self flutterScreenIfViewLoaded].scale;
 
  flutter::PointerData pointer_data = [self generatePointerDataAtLastMouseLocation];
  pointer_data.device = reinterpret_cast<int64_t>(recognizer);
  pointer_data.kind = flutter::PointerData::DeviceKind::kTrackpad;
  pointer_data.view_id = self.viewIdentifier;
  switch (recognizer.state) {
    case UIGestureRecognizerStateBegan:
      pointer_data.change = flutter::PointerData::Change::kPanZoomStart;
      break;
    case UIGestureRecognizerStateChanged:
      pointer_data.change = flutter::PointerData::Change::kPanZoomUpdate;
      pointer_data.pan_x = translation.x * scale;
      pointer_data.pan_y = translation.y * scale;
      pointer_data.pan_delta_x = 0;  // Delta will be generated in pointer_data_packet_converter.cc.
      pointer_data.pan_delta_y = 0;  // Delta will be generated in pointer_data_packet_converter.cc.
      pointer_data.scale = 1;
      break;
    case UIGestureRecognizerStateEnded:
    case UIGestureRecognizerStateCancelled:
      _scrollInertiaEventStartline =
          [[NSProcessInfo processInfo] systemUptime] +
          0.1;  // Time to lift fingers off trackpad (experimentally determined)
      // When running an iOS app on an Apple Silicon Mac, AppKit will send an event
      // of type UIEventTypeScroll when trackpad scroll momentum has ended. This event
      // is sent whether the momentum ended normally or was cancelled by a trackpad touch.
      // Since Flutter scrolling inertia will likely not match the system inertia, we should
      // only send a PointerScrollInertiaCancel event for user-initiated cancellations.
      // The following (curve-fitted) calculation provides a cutoff point after which any
      // UIEventTypeScroll event will likely be from the system instead of the user.
      // See https://github.com/flutter/engine/pull/34929.
      _scrollInertiaEventAppKitDeadline =
          [[NSProcessInfo processInfo] systemUptime] +
          (0.1821 * log(fmax([recognizer velocityInView:self.view].x,
                             [recognizer velocityInView:self.view].y))) -
          0.4825;
      pointer_data.change = flutter::PointerData::Change::kPanZoomEnd;
      break;
    default:
      // continuousScrollEvent: should only ever be triggered with the above phases
      NSAssert(false, @"Trackpad pan event occured with unexpected phase 0x%lx",
               (long)recognizer.state);
      break;
  }
 
  auto packet = std::make_unique<flutter::PointerDataPacket>(1);
  packet->SetPointerData(/*i=*/0, pointer_data);
  [_engine.get() dispatchPointerDataPacket:std::move(packet)];
}

◆ contrastMode

- (NSString *) contrastMode

implementation

Definition at line 1112 of file FlutterViewController.mm.

                          {
  if (@available(iOS 13, *)) {
    UIAccessibilityContrast contrast = self.traitCollection.accessibilityContrast;
 
    if (contrast == UIAccessibilityContrastHigh) {
      return @"high";
    } else {
      return @"normal";
    }
  } else {
    return @"normal";
  }
}

◆ createAccessibilityBridgeWithEngine:

- (shared_ptr<) flutter: (nonnull FlutterEngine*) engine

implementation

Reimplemented in AccessibilityBridgeTestViewController.

Provided by category FlutterViewController(TestMethods).

Definition at line 338 of file FlutterViewController.mm.

                                                                                   :
    (nonnull FlutterEngine*)engine {
  return std::make_shared<flutter::AccessibilityBridgeMac>(engine, self);
}

◆ createFlutterViewWithMTLDevice:commandQueue:

- (nonnull FlutterView *) createFlutterViewWithMTLDevice:	(id<MTLDevice>)	device
commandQueue:	(id<MTLCommandQueue>)	commandQueue

implementation

Reimplemented in TextInputTestViewController.

Provided by category FlutterViewController(TestMethods).

Definition at line 338 of file FlutterViewController.mm.

                                                      :(id<MTLDevice>)device
                                          commandQueue:(id<MTLCommandQueue>)commandQueue {
  return [[FlutterView alloc] initWithMTLDevice:device
                                   commandQueue:commandQueue
                                       delegate:self
                             threadSynchronizer:_threadSynchronizer
                                 viewIdentifier:_viewIdentifier];
}

◆ createTouchRateCorrectionVSyncClientIfNeeded

- (void) createTouchRateCorrectionVSyncClientIfNeeded

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                                     {
  if (_touchRateCorrectionVSyncClient != nil) {
    return;
  }
 
  double displayRefreshRate = DisplayLinkManager.displayRefreshRate;
  const double epsilon = 0.1;
  if (displayRefreshRate < 60.0 + epsilon) {  // displayRefreshRate <= 60.0
 
    // If current device's max frame rate is not larger than 60HZ, the delivery rate of touch events
    // is the same with render vsync rate. So it is unnecessary to create
    // _touchRateCorrectionVSyncClient to correct touch callback's rate.
    return;
  }
 
  flutter::Shell& shell = [_engine.get() shell];
  auto callback = [](std::unique_ptr<flutter::FrameTimingsRecorder> recorder) {
    // Do nothing in this block. Just trigger system to callback touch events with correct rate.
  };
  _touchRateCorrectionVSyncClient =
      [[VSyncClient alloc] initWithTaskRunner:shell.GetTaskRunners().GetPlatformTaskRunner()
                                     callback:callback];
  _touchRateCorrectionVSyncClient.allowPauseAfterVsync = NO;
}

◆ CurrentKeyboardLayoutData

+ (static NSData *) CurrentKeyboardLayoutData

implementation

Returns the current Unicode layout data (kTISPropertyUnicodeKeyLayoutData).

To use the returned data, convert it to CFDataRef first, finds its bytes with CFDataGetBytePtr, then reinterpret it into const UCKeyboardLayout*. It's returned in NSData* to enable auto reference count.

Definition at line 891 of file FlutterViewController.mm.

                                           {
  TISInputSourceRef source = TISCopyCurrentKeyboardInputSource();
  CFTypeRef layout_data = TISGetInputSourceProperty(source, kTISPropertyUnicodeKeyLayoutData);
  if (layout_data == nil) {
    CFRelease(source);
    // TISGetInputSourceProperty returns null with Japanese keyboard layout.
    // Using TISCopyCurrentKeyboardLayoutInputSource to fix NULL return.
    // https://github.com/microsoft/node-native-keymap/blob/5f0699ded00179410a14c0e1b0e089fe4df8e130/src/keyboard_mac.mm#L91
    source = TISCopyCurrentKeyboardLayoutInputSource();
    layout_data = TISGetInputSourceProperty(source, kTISPropertyUnicodeKeyLayoutData);
  }
  return (__bridge_transfer NSData*)CFRetain(layout_data);
}

◆ dealloc

- (void) dealloc

implementation

Definition at line 527 of file FlutterViewController.mm.

                {
  // It will be destroyed and invalidate its weak pointers
  // before any other members are destroyed.
  _weakFactory.reset();
 
  [self removeInternalPlugins];
  [self deregisterNotifications];
 
  [self invalidateKeyboardAnimationVSyncClient];
  [self invalidateTouchRateCorrectionVSyncClient];
  _scrollView.get().delegate = nil;
  _hoverGestureRecognizer.delegate = nil;
  [_hoverGestureRecognizer release];
  _discreteScrollingPanGestureRecognizer.delegate = nil;
  [_discreteScrollingPanGestureRecognizer release];
  _continuousScrollingPanGestureRecognizer.delegate = nil;
  [_continuousScrollingPanGestureRecognizer release];
  _pinchGestureRecognizer.delegate = nil;
  [_pinchGestureRecognizer release];
  _rotationGestureRecognizer.delegate = nil;
  [_rotationGestureRecognizer release];
  [super dealloc];
}

◆ decodeRestorableStateWithCoder:

- (void) decodeRestorableStateWithCoder: (NSCoder*) coder

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                      :(NSCoder*)coder {
  NSUInteger restorationDataLength;
  const unsigned char* restorationBytes = [coder decodeBytesForKey:kFlutterRestorationStateAppData
                                                    returnedLength:&restorationDataLength];
  NSData* restorationData = [NSData dataWithBytes:restorationBytes length:restorationDataLength];
  [[_engine.get() restorationPlugin] setRestorationData:restorationData];
}

◆ deregisterNotifications

- (void) deregisterNotifications

implementation

Definition at line 527 of file FlutterViewController.mm.

                                {
  [[NSNotificationCenter defaultCenter] postNotificationName:FlutterViewControllerWillDealloc
                                                      object:self
                                                    userInfo:nil];
  [[NSNotificationCenter defaultCenter] removeObserver:self];
}

◆ detachFromEngine

- (void) detachFromEngine

implementation

Reset the engine and id of this controller.

This method is called by FlutterEngine.

Definition at line 338 of file FlutterViewController.mm.

                         {
  NSAssert(_engine != nil, @"Not attached to any engine.");
  [_threadSynchronizer deregisterView:_viewIdentifier];
  _threadSynchronizer = nil;
  _engine = nil;
}

◆ DeviceKindFromTouchType

+ (static) PointerData: (UITouch *) touch

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                                                            {
  switch (touch.type) {
    case UITouchTypeDirect:
    case UITouchTypeIndirect:
      return flutter::PointerData::DeviceKind::kTouch;
    case UITouchTypeStylus:
      return flutter::PointerData::DeviceKind::kStylus;
    case UITouchTypeIndirectPointer:
      return flutter::PointerData::DeviceKind::kMouse;
    default:
      FML_DLOG(INFO) << "Unhandled touch type: " << touch.type;
      break;
  }
 
  return flutter::PointerData::DeviceKind::kTouch;
}

◆ discreteScrollEvent:

- (void) discreteScrollEvent: (ios(13.4)) API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                           :(UIPanGestureRecognizer*)recognizer API_AVAILABLE(ios(13.4)) {
  CGPoint translation = [recognizer translationInView:self.view];
  const CGFloat scale = [self flutterScreenIfViewLoaded].scale;
 
  translation.x *= scale;
  translation.y *= scale;
 
  flutter::PointerData pointer_data = [self generatePointerDataAtLastMouseLocation];
  pointer_data.device = reinterpret_cast<int64_t>(recognizer);
  pointer_data.kind = flutter::PointerData::DeviceKind::kMouse;
  pointer_data.signal_kind = flutter::PointerData::SignalKind::kScroll;
  pointer_data.scroll_delta_x = (translation.x - _mouseState.last_translation.x);
  pointer_data.scroll_delta_y = -(translation.y - _mouseState.last_translation.y);
  pointer_data.view_id = self.viewIdentifier;
 
  // The translation reported by UIPanGestureRecognizer is the total translation
  // generated by the pan gesture since the gesture began. We need to be able
  // to keep track of the last translation value in order to generate the deltaX
  // and deltaY coordinates for each subsequent scroll event.
  if (recognizer.state != UIGestureRecognizerStateEnded) {
    _mouseState.last_translation = translation;
  } else {
    _mouseState.last_translation = CGPointZero;
  }
 
  auto packet = std::make_unique<flutter::PointerDataPacket>(1);
  packet->SetPointerData(/*i=*/0, pointer_data);
  [_engine.get() dispatchPointerDataPacket:std::move(packet)];
}

◆ dispatchGestureEvent:

- (void) dispatchGestureEvent: (nonnull NSEvent *) event

implementation

Calls dispatchMouseEvent:phase: with a phase determined by event.phase.

Definition at line 338 of file FlutterViewController.mm.

                            :(nonnull NSEvent*)event {
  if (event.phase == NSEventPhaseBegan || event.phase == NSEventPhaseMayBegin) {
    [self dispatchMouseEvent:event phase:kPanZoomStart];
  } else if (event.phase == NSEventPhaseChanged) {
    [self dispatchMouseEvent:event phase:kPanZoomUpdate];
  } else if (event.phase == NSEventPhaseEnded || event.phase == NSEventPhaseCancelled) {
    [self dispatchMouseEvent:event phase:kPanZoomEnd];
  } else if (event.phase == NSEventPhaseNone && event.momentumPhase == NSEventPhaseNone) {
    [self dispatchMouseEvent:event phase:kHover];
  } else {
    // Waiting until the first momentum change event is a workaround for an issue where
    // touchesBegan: is called unexpectedly while in low power mode within the interval between
    // momentum start and the first momentum change.
    if (event.momentumPhase == NSEventPhaseChanged) {
      _mouseState.last_scroll_momentum_changed_time = event.timestamp;
    }
    // Skip momentum update events, the framework will generate scroll momentum.
    NSAssert(event.momentumPhase != NSEventPhaseNone,
             @"Received gesture event with unexpected phase");
  }
}

◆ dispatchMouseEvent:

- (void) dispatchMouseEvent: (nonnull NSEvent *) event

implementation

Calls dispatchMouseEvent:phase: with a phase determined by self.mouseState.

mouseState.buttons should be updated before calling this method.

Definition at line 338 of file FlutterViewController.mm.

                          :(nonnull NSEvent*)event {
  FlutterPointerPhase phase = _mouseState.buttons == 0
                                  ? (_mouseState.flutter_state_is_down ? kUp : kHover)
                                  : (_mouseState.flutter_state_is_down ? kMove : kDown);
  [self dispatchMouseEvent:event phase:phase];
}

◆ dispatchMouseEvent:phase:

- (void) dispatchMouseEvent:	(NSEvent*)	event
phase:	(FlutterPointerPhase)	phase

implementation

Definition at line 338 of file FlutterViewController.mm.

                          :(NSEvent*)event phase:(FlutterPointerPhase)phase {
  NSAssert(self.viewLoaded, @"View must be loaded before it handles the mouse event");
  // There are edge cases where the system will deliver enter out of order relative to other
  // events (e.g., drag out and back in, release, then click; mouseDown: will be called before
  // mouseEntered:). Discard those events, since the add will already have been synthesized.
  if (_mouseState.flutter_state_is_added && phase == kAdd) {
    return;
  }
 
  // Multiple gesture recognizers could be active at once, we can't send multiple kPanZoomStart.
  // For example: rotation and magnification.
  if (phase == kPanZoomStart || phase == kPanZoomEnd) {
    if (event.type == NSEventTypeScrollWheel) {
      _mouseState.pan_gesture_phase = event.phase;
    } else if (event.type == NSEventTypeMagnify) {
      _mouseState.scale_gesture_phase = event.phase;
    } else if (event.type == NSEventTypeRotate) {
      _mouseState.rotate_gesture_phase = event.phase;
    }
  }
  if (phase == kPanZoomStart) {
    if (event.type == NSEventTypeScrollWheel) {
      // Ensure scroll inertia cancel event is not sent afterwards.
      _mouseState.last_scroll_momentum_changed_time = 0;
    }
    if (_mouseState.flutter_state_is_pan_zoom_started) {
      // Already started on a previous gesture type
      return;
    }
    _mouseState.flutter_state_is_pan_zoom_started = true;
  }
  if (phase == kPanZoomEnd) {
    if (!_mouseState.flutter_state_is_pan_zoom_started) {
      // NSEventPhaseCancelled is sometimes received at incorrect times in the state
      // machine, just ignore it here if it doesn't make sense
      // (we have no active gesture to cancel).
      NSAssert(event.phase == NSEventPhaseCancelled,
               @"Received gesture event with unexpected phase");
      return;
    }
    // NSEventPhase values are powers of two, we can use this to inspect merged phases.
    NSEventPhase all_gestures_fields = _mouseState.pan_gesture_phase |
                                       _mouseState.scale_gesture_phase |
                                       _mouseState.rotate_gesture_phase;
    NSEventPhase active_mask = NSEventPhaseBegan | NSEventPhaseChanged;
    if ((all_gestures_fields & active_mask) != 0) {
      // Even though this gesture type ended, a different type is still active.
      return;
    }
  }
 
  // If a pointer added event hasn't been sent, synthesize one using this event for the basic
  // information.
  if (!_mouseState.flutter_state_is_added && phase != kAdd) {
    // Only the values extracted for use in flutterEvent below matter, the rest are dummy values.
    NSEvent* addEvent = [NSEvent enterExitEventWithType:NSEventTypeMouseEntered
                                               location:event.locationInWindow
                                          modifierFlags:0
                                              timestamp:event.timestamp
                                           windowNumber:event.windowNumber
                                                context:nil
                                            eventNumber:0
                                         trackingNumber:0
                                               userData:NULL];
    [self dispatchMouseEvent:addEvent phase:kAdd];
  }
 
  NSPoint locationInView = [self.flutterView convertPoint:event.locationInWindow fromView:nil];
  NSPoint locationInBackingCoordinates = [self.flutterView convertPointToBacking:locationInView];
  int32_t device = kMousePointerDeviceId;
  FlutterPointerDeviceKind deviceKind = kFlutterPointerDeviceKindMouse;
  if (phase == kPanZoomStart || phase == kPanZoomUpdate || phase == kPanZoomEnd) {
    device = kPointerPanZoomDeviceId;
    deviceKind = kFlutterPointerDeviceKindTrackpad;
  }
  FlutterPointerEvent flutterEvent = {
      .struct_size = sizeof(flutterEvent),
      .phase = phase,
      .timestamp = static_cast<size_t>(event.timestamp * USEC_PER_SEC),
      .x = locationInBackingCoordinates.x,
      .y = -locationInBackingCoordinates.y,  // convertPointToBacking makes this negative.
      .device = device,
      .device_kind = deviceKind,
      // If a click triggered a synthesized kAdd, don't pass the buttons in that event.
      .buttons = phase == kAdd ? 0 : _mouseState.buttons,
      .view_id = static_cast<FlutterViewIdentifier>(_viewIdentifier),
  };
 
  if (phase == kPanZoomUpdate) {
    if (event.type == NSEventTypeScrollWheel) {
      _mouseState.delta_x += event.scrollingDeltaX * self.flutterView.layer.contentsScale;
      _mouseState.delta_y += event.scrollingDeltaY * self.flutterView.layer.contentsScale;
    } else if (event.type == NSEventTypeMagnify) {
      _mouseState.scale += event.magnification;
    } else if (event.type == NSEventTypeRotate) {
      _mouseState.rotation += event.rotation * (-M_PI / 180.0);
    }
    flutterEvent.pan_x = _mouseState.delta_x;
    flutterEvent.pan_y = _mouseState.delta_y;
    // Scale value needs to be normalized to range 0->infinity.
    flutterEvent.scale = pow(2.0, _mouseState.scale);
    flutterEvent.rotation = _mouseState.rotation;
  } else if (phase == kPanZoomEnd) {
    _mouseState.GestureReset();
  } else if (phase != kPanZoomStart && event.type == NSEventTypeScrollWheel) {
    flutterEvent.signal_kind = kFlutterPointerSignalKindScroll;
 
    double pixelsPerLine = 1.0;
    if (!event.hasPreciseScrollingDeltas) {
      // The scrollingDelta needs to be multiplied by the line height.
      // CGEventSourceGetPixelsPerLine() will return 10, which will result in
      // scrolling that is noticeably slower than in other applications.
      // Using 40.0 as the multiplier to match Chromium.
      // See https://source.chromium.org/chromium/chromium/src/+/main:ui/events/cocoa/events_mac.mm
      pixelsPerLine = 40.0;
    }
    double scaleFactor = self.flutterView.layer.contentsScale;
    // When mouse input is received while shift is pressed (regardless of
    // any other pressed keys), Mac automatically flips the axis. Other
    // platforms do not do this, so we flip it back to normalize the input
    // received by the framework. The keyboard+mouse-scroll mechanism is exposed
    // in the ScrollBehavior of the framework so developers can customize the
    // behavior.
    // At time of change, Apple does not expose any other type of API or signal
    // that the X/Y axes have been flipped.
    double scaledDeltaX = -event.scrollingDeltaX * pixelsPerLine * scaleFactor;
    double scaledDeltaY = -event.scrollingDeltaY * pixelsPerLine * scaleFactor;
    if (event.modifierFlags & NSShiftKeyMask) {
      flutterEvent.scroll_delta_x = scaledDeltaY;
      flutterEvent.scroll_delta_y = scaledDeltaX;
    } else {
      flutterEvent.scroll_delta_x = scaledDeltaX;
      flutterEvent.scroll_delta_y = scaledDeltaY;
    }
  }
 
  [_keyboardManager syncModifiersIfNeeded:event.modifierFlags timestamp:event.timestamp];
  [_engine sendPointerEvent:flutterEvent];
 
  // Update tracking of state as reported to Flutter.
  if (phase == kDown) {
    _mouseState.flutter_state_is_down = true;
  } else if (phase == kUp) {
    _mouseState.flutter_state_is_down = false;
    if (_mouseState.has_pending_exit) {
      [self dispatchMouseEvent:event phase:kRemove];
      _mouseState.has_pending_exit = false;
    }
  } else if (phase == kAdd) {
    _mouseState.flutter_state_is_added = true;
  } else if (phase == kRemove) {
    _mouseState.Reset();
  }
}

◆ dispatchTouches:pointerDataChangeOverride:event:

- (void) dispatchTouches:	(NSSet*)	touches
pointerDataChangeOverride:	(flutter::PointerData::Change*)	overridden_change
event:	(UIEvent*)	event

implementation

Definition at line 1112 of file FlutterViewController.mm.

                       :(NSSet*)touches
    pointerDataChangeOverride:(flutter::PointerData::Change*)overridden_change
                        event:(UIEvent*)event {
  if (!_engine) {
    return;
  }
 
  // If the UIApplicationSupportsIndirectInputEvents in Info.plist returns YES, then the platform
  // dispatches indirect pointer touches (trackpad clicks) as UITouch with a type of
  // UITouchTypeIndirectPointer and different identifiers for each click. They are translated into
  // Flutter pointer events with type of kMouse and different device IDs. These devices must be
  // terminated with kRemove events when the touches end, otherwise they will keep triggering hover
  // events.
  //
  // If the UIApplicationSupportsIndirectInputEvents in Info.plist returns NO, then the platform
  // dispatches indirect pointer touches (trackpad clicks) as UITouch with a type of
  // UITouchTypeIndirectPointer and different identifiers for each click. They are translated into
  // Flutter pointer events with type of kTouch and different device IDs. Removing these devices is
  // neither necessary nor harmful.
  //
  // Therefore Flutter always removes these devices. The touches_to_remove_count tracks how many
  // remove events are needed in this group of touches to properly allocate space for the packet.
  // The remove event of a touch is synthesized immediately after its normal event.
  //
  // See also:
  // https://developer.apple.com/documentation/uikit/pointer_interactions?language=objc
  // https://developer.apple.com/documentation/bundleresources/information_property_list/uiapplicationsupportsindirectinputevents?language=objc
  NSUInteger touches_to_remove_count = 0;
  for (UITouch* touch in touches) {
    if (touch.phase == UITouchPhaseEnded || touch.phase == UITouchPhaseCancelled) {
      touches_to_remove_count++;
    }
  }
 
  // Activate or pause the correction of delivery frame rate of touch events.
  [self triggerTouchRateCorrectionIfNeeded:touches];
 
  const CGFloat scale = [self flutterScreenIfViewLoaded].scale;
  auto packet =
      std::make_unique<flutter::PointerDataPacket>(touches.count + touches_to_remove_count);
 
  size_t pointer_index = 0;
 
  for (UITouch* touch in touches) {
    CGPoint windowCoordinates = [touch locationInView:self.view];
 
    flutter::PointerData pointer_data;
    pointer_data.Clear();
 
    constexpr int kMicrosecondsPerSecond = 1000 * 1000;
    pointer_data.time_stamp = touch.timestamp * kMicrosecondsPerSecond;
 
    pointer_data.change = overridden_change != nullptr
                              ? *overridden_change
                              : PointerDataChangeFromUITouchPhase(touch.phase);
 
    pointer_data.kind = DeviceKindFromTouchType(touch);
 
    pointer_data.device = reinterpret_cast<int64_t>(touch);
 
    pointer_data.view_id = self.viewIdentifier;
 
    // Pointer will be generated in pointer_data_packet_converter.cc.
    pointer_data.pointer_identifier = 0;
 
    pointer_data.physical_x = windowCoordinates.x * scale;
    pointer_data.physical_y = windowCoordinates.y * scale;
 
    // Delta will be generated in pointer_data_packet_converter.cc.
    pointer_data.physical_delta_x = 0.0;
    pointer_data.physical_delta_y = 0.0;
 
    NSNumber* deviceKey = [NSNumber numberWithLongLong:pointer_data.device];
    // Track touches that began and not yet stopped so we can flush them
    // if the view controller goes away.
    switch (pointer_data.change) {
      case flutter::PointerData::Change::kDown:
        [_ongoingTouches addObject:deviceKey];
        break;
      case flutter::PointerData::Change::kCancel:
      case flutter::PointerData::Change::kUp:
        [_ongoingTouches removeObject:deviceKey];
        break;
      case flutter::PointerData::Change::kHover:
      case flutter::PointerData::Change::kMove:
        // We're only tracking starts and stops.
        break;
      case flutter::PointerData::Change::kAdd:
      case flutter::PointerData::Change::kRemove:
        // We don't use kAdd/kRemove.
        break;
      case flutter::PointerData::Change::kPanZoomStart:
      case flutter::PointerData::Change::kPanZoomUpdate:
      case flutter::PointerData::Change::kPanZoomEnd:
        // We don't send pan/zoom events here
        break;
    }
 
    // pressure_min is always 0.0
    pointer_data.pressure = touch.force;
    pointer_data.pressure_max = touch.maximumPossibleForce;
    pointer_data.radius_major = touch.majorRadius;
    pointer_data.radius_min = touch.majorRadius - touch.majorRadiusTolerance;
    pointer_data.radius_max = touch.majorRadius + touch.majorRadiusTolerance;
 
    // iOS Documentation: altitudeAngle
    // A value of 0 radians indicates that the stylus is parallel to the surface. The value of
    // this property is Pi/2 when the stylus is perpendicular to the surface.
    //
    // PointerData Documentation: tilt
    // The angle of the stylus, in radians in the range:
    //    0 <= tilt <= pi/2
    // giving the angle of the axis of the stylus, relative to the axis perpendicular to the input
    // surface (thus 0.0 indicates the stylus is orthogonal to the plane of the input surface,
    // while pi/2 indicates that the stylus is flat on that surface).
    //
    // Discussion:
    // The ranges are the same. Origins are swapped.
    pointer_data.tilt = M_PI_2 - touch.altitudeAngle;
 
    // iOS Documentation: azimuthAngleInView:
    // With the tip of the stylus touching the screen, the value of this property is 0 radians
    // when the cap end of the stylus (that is, the end opposite of the tip) points along the
    // positive x axis of the device's screen. The azimuth angle increases as the user swings the
    // cap end of the stylus in a clockwise direction around the tip.
    //
    // PointerData Documentation: orientation
    // The angle of the stylus, in radians in the range:
    //    -pi < orientation <= pi
    // giving the angle of the axis of the stylus projected onto the input surface, relative to
    // the positive y-axis of that surface (thus 0.0 indicates the stylus, if projected onto that
    // surface, would go from the contact point vertically up in the positive y-axis direction, pi
    // would indicate that the stylus would go down in the negative y-axis direction; pi/4 would
    // indicate that the stylus goes up and to the right, -pi/2 would indicate that the stylus
    // goes to the left, etc).
    //
    // Discussion:
    // Sweep direction is the same. Phase of M_PI_2.
    pointer_data.orientation = [touch azimuthAngleInView:nil] - M_PI_2;
 
    if (@available(iOS 13.4, *)) {
      if (event != nullptr) {
        pointer_data.buttons = (((event.buttonMask & UIEventButtonMaskPrimary) > 0)
                                    ? flutter::PointerButtonMouse::kPointerButtonMousePrimary
                                    : 0) |
                               (((event.buttonMask & UIEventButtonMaskSecondary) > 0)
                                    ? flutter::PointerButtonMouse::kPointerButtonMouseSecondary
                                    : 0);
      }
    }
 
    packet->SetPointerData(pointer_index++, pointer_data);
 
    if (touch.phase == UITouchPhaseEnded || touch.phase == UITouchPhaseCancelled) {
      flutter::PointerData remove_pointer_data = pointer_data;
      remove_pointer_data.change = flutter::PointerData::Change::kRemove;
      packet->SetPointerData(pointer_index++, remove_pointer_data);
    }
  }
 
  [_engine.get() dispatchPointerDataPacket:std::move(packet)];
}

◆ encodeRestorableStateWithCoder:

- (void) encodeRestorableStateWithCoder: (NSCoder*) coder

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                      :(NSCoder*)coder {
  NSData* restorationData = [[_engine.get() restorationPlugin] restorationData];
  [coder encodeBytes:(const unsigned char*)restorationData.bytes
              length:restorationData.length
              forKey:kFlutterRestorationStateAppData];
  [super encodeRestorableStateWithCoder:coder];
}

◆ ensureViewportMetricsIsCorrect

- (void) ensureViewportMetricsIsCorrect

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                       {
  if (_viewportMetrics.physical_view_inset_bottom != self.targetViewInsetBottom) {
    // Make sure the `physical_view_inset_bottom` is the target value.
    _viewportMetrics.physical_view_inset_bottom = self.targetViewInsetBottom;
    [self updateViewportMetricsIfNeeded];
  }
}

◆ flagsChanged:

- (void) flagsChanged: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                    :(NSEvent*)event {
  [_keyboardManager handleEvent:event];
}

◆ flushOngoingTouches

- (void) flushOngoingTouches

implementation

Definition at line 527 of file FlutterViewController.mm.

                            {
  if (_engine && _ongoingTouches.get().count > 0) {
    auto packet = std::make_unique<flutter::PointerDataPacket>(_ongoingTouches.get().count);
    size_t pointer_index = 0;
    // If the view controller is going away, we want to flush cancel all the ongoing
    // touches to the framework so nothing gets orphaned.
    for (NSNumber* device in _ongoingTouches.get()) {
      // Create fake PointerData to balance out each previously started one for the framework.
      flutter::PointerData pointer_data = [self generatePointerDataForFake];
 
      pointer_data.change = flutter::PointerData::Change::kCancel;
      pointer_data.device = device.longLongValue;
      pointer_data.pointer_identifier = 0;
      pointer_data.view_id = self.viewIdentifier;
 
      // Anything we put here will be arbitrary since there are no touches.
      pointer_data.physical_x = 0;
      pointer_data.physical_y = 0;
      pointer_data.physical_delta_x = 0.0;
      pointer_data.physical_delta_y = 0.0;
      pointer_data.pressure = 1.0;
      pointer_data.pressure_max = 1.0;
 
      packet->SetPointerData(pointer_index++, pointer_data);
    }
 
    [_ongoingTouches removeAllObjects];
    [_engine.get() dispatchPointerDataPacket:std::move(packet)];
  }
}

◆ forceTouchesCancelled:

- (void) forceTouchesCancelled: (NSSet *) touches

implementation

Send touches to the Flutter Engine while forcing the change type to be cancelled. The phases in touches are ignored.

Reimplemented from <FlutterViewResponder>.

Definition at line 1112 of file FlutterViewController.mm.

                             :(NSSet*)touches {
  flutter::PointerData::Change cancel = flutter::PointerData::Change::kCancel;
  [self dispatchTouches:touches pointerDataChangeOverride:&cancel event:nullptr];
}

◆ generatePointerDataForFake

- (PointerData) FlutterViewController:

implementation

Provided by category FlutterViewController(Tests).

Definition at line 463 of file FlutterViewController.mm.

                                                 {
  flutter::PointerData pointer_data;
  pointer_data.Clear();
  pointer_data.kind = flutter::PointerData::DeviceKind::kTouch;
  // `UITouch.timestamp` is defined as seconds since system startup. Synthesized events can get this
  // time with `NSProcessInfo.systemUptime`. See
  // https://developer.apple.com/documentation/uikit/uitouch/1618144-timestamp?language=objc
  pointer_data.time_stamp = [[NSProcessInfo processInfo] systemUptime] * kMicrosecondsPerSecond;
  return pointer_data;
}

◆ gestureRecognizer:shouldReceiveEvent:

- (BOOL) gestureRecognizer:	(UIGestureRecognizer*)	gestureRecognizer
shouldReceiveEvent:	(ios(13.4))	API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                         :(UIGestureRecognizer*)gestureRecognizer
       shouldReceiveEvent:(UIEvent*)event API_AVAILABLE(ios(13.4)) {
  if (gestureRecognizer == _continuousScrollingPanGestureRecognizer &&
      event.type == UIEventTypeScroll) {
    // Events with type UIEventTypeScroll are only received when running on macOS under emulation.
    flutter::PointerData pointer_data = [self generatePointerDataAtLastMouseLocation];
    pointer_data.device = reinterpret_cast<int64_t>(_continuousScrollingPanGestureRecognizer);
    pointer_data.kind = flutter::PointerData::DeviceKind::kTrackpad;
    pointer_data.signal_kind = flutter::PointerData::SignalKind::kScrollInertiaCancel;
    pointer_data.view_id = self.viewIdentifier;
 
    if (event.timestamp < _scrollInertiaEventAppKitDeadline) {
      // Only send the event if it occured before the expected natural end of gesture momentum.
      // If received after the deadline, it's not likely the event is from a user-initiated cancel.
      auto packet = std::make_unique<flutter::PointerDataPacket>(1);
      packet->SetPointerData(/*i=*/0, pointer_data);
      [_engine.get() dispatchPointerDataPacket:std::move(packet)];
      _scrollInertiaEventAppKitDeadline = 0;
    }
  }
  // This method is also called for UITouches, should return YES to process all touches.
  return YES;
}

◆ gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:

- (BOOL) gestureRecognizer:	(UIGestureRecognizer*)	gestureRecognizer
shouldRecognizeSimultaneouslyWithGestureRecognizer:	(ios(13.4))	API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                         :(UIGestureRecognizer*)gestureRecognizer
    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer*)otherGestureRecognizer
    API_AVAILABLE(ios(13.4)) {
  return YES;
}

◆ getBinaryMessenger

- (id< FlutterBinaryMessenger >) getBinaryMessenger

implementation

Get a binary messenger to send channel messages with.

This method is used to create the key data channel and typically forwards to |FlutterEngine.binaryMessenger|.

Reimplemented from <FlutterKeyboardViewDelegate>.

Definition at line 891 of file FlutterViewController.mm.

                                                 {
  return _engine.binaryMessenger;
}

◆ getPressedState

- (nonnull NSDictionary *) getPressedState

implementation

Returns the keyboard pressed state.

Returns the keyboard pressed state. The dictionary contains one entry per pressed keys, mapping from the logical key to the physical key.

Reimplemented from <FlutterKeyboardViewDelegate>.

Definition at line 891 of file FlutterViewController.mm.

                                         {
  return [_keyboardManager getPressedState];
}

◆ GetViewOrPlaceholder

+ (static UIView *) GetViewOrPlaceholder (UIView *) existing_view

implementation

Definition at line 463 of file FlutterViewController.mm.

                                                           {
  if (existing_view) {
    return existing_view;
  }
 
  auto placeholder = [[[UIView alloc] init] autorelease];
 
  placeholder.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
  if (@available(iOS 13.0, *)) {
    placeholder.backgroundColor = UIColor.systemBackgroundColor;
  } else {
    placeholder.backgroundColor = UIColor.whiteColor;
  }
  placeholder.autoresizesSubviews = YES;
 
  // Only add the label when we know we have failed to enable tracing (and it was necessary).
  // Otherwise, a spurious warning will be shown in cases where an engine cannot be initialized for
  // other reasons.
  if (flutter::GetTracingResult() == flutter::TracingResult::kDisabled) {
    auto messageLabel = [[[UILabel alloc] init] autorelease];
    messageLabel.numberOfLines = 0u;
    messageLabel.textAlignment = NSTextAlignmentCenter;
    messageLabel.autoresizingMask =
        UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
    messageLabel.text =
        @"In iOS 14+, debug mode Flutter apps can only be launched from Flutter tooling, "
        @"IDEs with Flutter plugins or from Xcode.\n\nAlternatively, build in profile or release "
        @"modes to enable launching from the home screen.";
    [placeholder addSubview:messageLabel];
  }
 
  return placeholder;
}

◆ getWeakNSObject

- (WeakNSObject< FlutterViewController >) FlutterViewController:

implementation

Definition at line 152 of file FlutterViewController.mm.

                                                          {
  return _weakFactory->GetWeakNSObject();
}

◆ goToApplicationLifecycle:

- (void) goToApplicationLifecycle: (nonnull NSString*) state

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                :(nonnull NSString*)state {
  // Accessing self.view will create the view. Instead use viewIfLoaded
  // to check whether the view is attached to window.
  if (self.viewIfLoaded.window) {
    [[_engine.get() lifecycleChannel] sendMessage:state];
  }
}

◆ handleKeyboardNotification:

- (void) handleKeyboardNotification: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                  :(NSNotification*)notification {
  // See https://flutter.dev/go/ios-keyboard-calculating-inset for more details
  // on why notifications are used and how things are calculated.
  if ([self shouldIgnoreKeyboardNotification:notification]) {
    return;
  }
 
  NSDictionary* info = notification.userInfo;
  CGRect beginKeyboardFrame = [info[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
  CGRect keyboardFrame = [info[UIKeyboardFrameEndUserInfoKey] CGRectValue];
  FlutterKeyboardMode keyboardMode = [self calculateKeyboardAttachMode:notification];
  CGFloat calculatedInset = [self calculateKeyboardInset:keyboardFrame keyboardMode:keyboardMode];
 
  // Avoid double triggering startKeyBoardAnimation.
  if (self.targetViewInsetBottom == calculatedInset) {
    return;
  }
 
  self.targetViewInsetBottom = calculatedInset;
  NSTimeInterval duration = [info[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
 
  // Flag for simultaneous compounding animation calls.
  // This captures animation calls made while the keyboard animation is currently animating. If the
  // new animation is in the same direction as the current animation, this flag lets the current
  // animation continue with an updated targetViewInsetBottom instead of starting a new keyboard
  // animation. This allows for smoother keyboard animation interpolation.
  BOOL keyboardWillShow = beginKeyboardFrame.origin.y > keyboardFrame.origin.y;
  BOOL keyboardAnimationIsCompounding =
      self.keyboardAnimationIsShowing == keyboardWillShow && _keyboardAnimationVSyncClient != nil;
 
  // Mark keyboard as showing or hiding.
  self.keyboardAnimationIsShowing = keyboardWillShow;
 
  if (!keyboardAnimationIsCompounding) {
    [self startKeyBoardAnimation:duration];
  } else if ([self keyboardSpringAnimation]) {
    [self keyboardSpringAnimation].toValue = self.targetViewInsetBottom;
  }
}

◆ handlePressEvent:nextAction:

- (void) handlePressEvent:	(FlutterUIPressProxy*)	press
nextAction:	(ios(13.4))	API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                        :(FlutterUIPressProxy*)press
              nextAction:(void (^)())next API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
  } else {
    next();
    return;
  }
  [self.keyboardManager handlePress:press nextAction:next];
}

◆ hasPlugin:

- (BOOL) hasPlugin: (NSString *) pluginKey

implementation

Returns whether the specified plugin has been registered.

Parameters

pluginKey The unique key identifying the plugin.

Returns: YES if registrarForPlugin has been called with pluginKey.

Reimplemented from <FlutterPluginRegistry>.

Definition at line 1112 of file FlutterViewController.mm.

                 :(NSString*)pluginKey {
  return [_engine.get() hasPlugin:pluginKey];
}

◆ hoverEvent:

- (void) hoverEvent: (ios(13.4)) API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                  :(UIPanGestureRecognizer*)recognizer API_AVAILABLE(ios(13.4)) {
  CGPoint location = [recognizer locationInView:self.view];
  CGFloat scale = [self flutterScreenIfViewLoaded].scale;
  CGPoint oldLocation = _mouseState.location;
  _mouseState.location = {location.x * scale, location.y * scale};
 
  flutter::PointerData pointer_data = [self generatePointerDataAtLastMouseLocation];
  pointer_data.device = reinterpret_cast<int64_t>(recognizer);
  pointer_data.kind = flutter::PointerData::DeviceKind::kMouse;
  pointer_data.view_id = self.viewIdentifier;
 
  switch (_hoverGestureRecognizer.state) {
    case UIGestureRecognizerStateBegan:
      pointer_data.change = flutter::PointerData::Change::kAdd;
      break;
    case UIGestureRecognizerStateChanged:
      pointer_data.change = flutter::PointerData::Change::kHover;
      break;
    case UIGestureRecognizerStateEnded:
    case UIGestureRecognizerStateCancelled:
      pointer_data.change = flutter::PointerData::Change::kRemove;
      break;
    default:
      // Sending kHover is the least harmful thing to do here
      // But this state is not expected to ever be reached.
      pointer_data.change = flutter::PointerData::Change::kHover;
      break;
  }
 
  NSTimeInterval time = [NSProcessInfo processInfo].systemUptime;
  BOOL isRunningOnMac = NO;
  if (@available(iOS 14.0, *)) {
    // This "stationary pointer" heuristic is not reliable when running within macOS.
    // We instead receive a scroll cancel event directly from AppKit.
    // See gestureRecognizer:shouldReceiveEvent:
    isRunningOnMac = [NSProcessInfo processInfo].iOSAppOnMac;
  }
  if (!isRunningOnMac && CGPointEqualToPoint(oldLocation, _mouseState.location) &&
      time > _scrollInertiaEventStartline) {
    // iPadOS reports trackpad movements events with high (sub-pixel) precision. When an event
    // is received with the same position as the previous one, it can only be from a finger
    // making or breaking contact with the trackpad surface.
    auto packet = std::make_unique<flutter::PointerDataPacket>(2);
    packet->SetPointerData(/*i=*/0, pointer_data);
    flutter::PointerData inertia_cancel = pointer_data;
    inertia_cancel.device = reinterpret_cast<int64_t>(_continuousScrollingPanGestureRecognizer);
    inertia_cancel.kind = flutter::PointerData::DeviceKind::kTrackpad;
    inertia_cancel.signal_kind = flutter::PointerData::SignalKind::kScrollInertiaCancel;
    inertia_cancel.view_id = self.viewIdentifier;
    packet->SetPointerData(/*i=*/1, inertia_cancel);
    [_engine.get() dispatchPointerDataPacket:std::move(packet)];
    _scrollInertiaEventStartline = DBL_MAX;
  } else {
    auto packet = std::make_unique<flutter::PointerDataPacket>(1);
    packet->SetPointerData(/*i=*/0, pointer_data);
    [_engine.get() dispatchPointerDataPacket:std::move(packet)];
  }
}

◆ init

- (instancetype) init

implementation

Reimplemented in ShareViewController.

Definition at line 152 of file FlutterViewController.mm.

                     {
  return [self initWithProject:nil nibName:nil bundle:nil];
}

◆ initializeKeyboard

- (void) initializeKeyboard

implementation

Creates and registers keyboard related components.

Definition at line 338 of file FlutterViewController.mm.

                           {
  // TODO(goderbauer): Seperate keyboard/textinput stuff into ViewController specific and Engine
  // global parts. Move the global parts to FlutterEngine.
  _keyboardManager = [[FlutterKeyboardManager alloc] initWithViewDelegate:self];
}

◆ initWithCoder: [1/2]

- (nonnull instancetype) initWithCoder: (nonnull NSCoder *) NS_DESIGNATED_INITIALIZER

◆ initWithCoder: [2/2]

- (instancetype) initWithCoder: (NSCoder*) NS_DESIGNATED_INITIALIZER

Initializer that is called from loading a FlutterViewController from a XIB.

Definition at line 152 of file FlutterViewController.mm.

                             :(NSCoder*)aDecoder {
  self = [super initWithCoder:aDecoder];
  return self;
}

◆ initWithEngine:nibName:bundle: [1/2]

- (instancetype) initWithEngine:	(FlutterEngine*)	engine
nibName:	(nullable NSString*)	nibName
bundle:	(nullable NSBundle*)	NS_DESIGNATED_INITIALIZER

Initializes this FlutterViewController with the specified FlutterEngine.

The initialized viewcontroller will attach itself to the engine as part of this process.

Parameters

engine	The `FlutterEngine` instance to attach to. Cannot be nil.
nibName	The NIB name to initialize this UIViewController with.
nibBundle	The NIB bundle.

Definition at line 152 of file FlutterViewController.mm.

                              :(FlutterEngine*)engine
                       nibName:(nullable NSString*)nibName
                        bundle:(nullable NSBundle*)nibBundle {
  NSAssert(engine != nil, @"Engine is required");
  self = [super initWithNibName:nibName bundle:nibBundle];
  if (self) {
    _viewOpaque = YES;
    if (engine.viewController) {
      FML_LOG(ERROR) << "The supplied FlutterEngine " << [[engine description] UTF8String]
                     << " is already used with FlutterViewController instance "
                     << [[engine.viewController description] UTF8String]
                     << ". One instance of the FlutterEngine can only be attached to one "
                        "FlutterViewController at a time. Set FlutterEngine.viewController "
                        "to nil before attaching it to another FlutterViewController.";
    }
    _engine.reset([engine retain]);
    _engineNeedsLaunch = NO;
    _flutterView.reset([[FlutterView alloc] initWithDelegate:_engine
                                                      opaque:self.isViewOpaque
                                             enableWideGamut:engine.project.isWideGamutEnabled]);
    _weakFactory = std::make_unique<fml::WeakNSObjectFactory<FlutterViewController>>(self);
    _ongoingTouches.reset([[NSMutableSet alloc] init]);
 
    [self performCommonViewControllerInitialization];
    [engine setViewController:self];
  }
 
  return self;
}

◆ initWithEngine:nibName:bundle: [2/2]

- (instancetype) initWithEngine:	(nonnull FlutterEngine*)	engine
nibName:	(nullable NSString*)	nibName
bundle:	(nullable NSBundle*)	NS_DESIGNATED_INITIALIZER

Initializes this FlutterViewController with an existing FlutterEngine.

The initialized view controller will add itself to the engine as part of this process.

This initializer is suitable for both the first Flutter view controller and the following ones of the app.

Parameters

engine	The `FlutterEngine` instance to attach to. Cannot be nil.
nibName	The NIB name to initialize this controller with.
nibBundle	The NIB bundle.

Definition at line 338 of file FlutterViewController.mm.

                              :(nonnull FlutterEngine*)engine
                       nibName:(nullable NSString*)nibName
                        bundle:(nullable NSBundle*)nibBundle {
  NSAssert(engine != nil, @"Engine is required");
 
  self = [super initWithNibName:nibName bundle:nibBundle];
  if (self) {
    CommonInit(self, engine);
  }
 
  return self;
}

◆ initWithNibName:bundle: [1/2]

- (instancetype) initWithNibName:	(NSString*)	nibNameOrNil
bundle:	(NSBundle*)	nibBundleOrNil

implementation

Definition at line 152 of file FlutterViewController.mm.

                               :(NSString*)nibNameOrNil bundle:(NSBundle*)nibBundleOrNil {
  return [self initWithProject:nil nibName:nil bundle:nil];
}

◆ initWithNibName:bundle: [2/2]

- (nonnull instancetype) initWithNibName:	(nullable NSString *)	nibNameOrNil
bundle:	(nullable NSBundle *)	NS_DESIGNATED_INITIALIZER

◆ initWithProject:

- (instancetype) initWithProject: (nullable FlutterDartProject*) NS_DESIGNATED_INITIALIZER

Initializes a controller that will run the given project.

In this initializer, this controller creates an engine, and is attached to that engine as the default controller. In this way, this controller can not be set to other engines. This initializer is suitable for the first Flutter view controller of the app. To use the controller with an existing engine, use initWithEngine:nibName:bundle: instead.

Parameters

project The project to run in this view controller. If nil, a default FlutterDartProject will be used.

Definition at line 338 of file FlutterViewController.mm.

                               :(nullable FlutterDartProject*)project {
  self = [super initWithNibName:nil bundle:nil];
  NSAssert(self, @"Super init cannot be nil");
 
  _project = project;
  CommonInit(self, nil);
  return self;
}

◆ initWithProject:initialRoute:nibName:bundle: [1/2]

- (instancetype) initWithProject:	(FlutterDartProject*)	project
initialRoute:	(NSString*)	initialRoute
nibName:	(NSString*)	nibName
bundle:	(NSBundle*)	nibBundle

implementation

Definition at line 152 of file FlutterViewController.mm.

                               :(FlutterDartProject*)project
                   initialRoute:(NSString*)initialRoute
                        nibName:(NSString*)nibName
                         bundle:(NSBundle*)nibBundle {
  self = [super initWithNibName:nibName bundle:nibBundle];
  if (self) {
    [self sharedSetupWithProject:project initialRoute:initialRoute];
  }
 
  return self;
}

◆ initWithProject:initialRoute:nibName:bundle: [2/2]

- (instancetype) initWithProject:	(nullable FlutterDartProject *)	project
initialRoute:	(nullable NSString *)	initialRoute
nibName:	(nullable NSString *)	nibName
bundle:	(nullable NSBundle *)	NS_DESIGNATED_INITIALIZER

Initializes a new FlutterViewController and FlutterEngine with the specified FlutterDartProject and initialRoute.

This will implicitly create a new FlutterEngine which is retrievable via the engine property after initialization.

Parameters

project	The `FlutterDartProject` to initialize the `FlutterEngine` with.
initialRoute	The initial `Navigator` route to load.
nibName	The NIB name to initialize this UIViewController with.
nibBundle	The NIB bundle.

◆ initWithProject:nibName:bundle: [1/2]

- (instancetype) initWithProject:	(FlutterDartProject*)	project
nibName:	(NSString*)	nibName
bundle:	(NSBundle*)	nibBundle

implementation

Definition at line 152 of file FlutterViewController.mm.

                               :(FlutterDartProject*)project
                        nibName:(NSString*)nibName
                         bundle:(NSBundle*)nibBundle {
  self = [super initWithNibName:nibName bundle:nibBundle];
  if (self) {
    [self sharedSetupWithProject:project initialRoute:nil];
  }
 
  return self;
}

◆ initWithProject:nibName:bundle: [2/2]

- (instancetype) initWithProject:	(nullable FlutterDartProject *)	project
nibName:	(nullable NSString *)	nibName
bundle:	(nullable NSBundle *)	NS_DESIGNATED_INITIALIZER

Initializes a new FlutterViewController and FlutterEngine with the specified FlutterDartProject.

This will implicitly create a new FlutterEngine which is retrievable via the engine property after initialization.

Parameters

project	The `FlutterDartProject` to initialize the `FlutterEngine` with.
nibName	The NIB name to initialize this UIViewController with.
nibBundle	The NIB bundle.

◆ installFirstFrameCallback

- (void) installFirstFrameCallback

implementation

Definition at line 527 of file FlutterViewController.mm.

                                  {
  if (!_engine) {
    return;
  }
 
  fml::WeakPtr<flutter::PlatformViewIOS> weakPlatformView = [_engine.get() platformView];
  if (!weakPlatformView) {
    return;
  }
 
  // Start on the platform thread.
  weakPlatformView->SetNextFrameCallback([weakSelf = [self getWeakNSObject],
                                          platformTaskRunner = [_engine.get() platformTaskRunner],
                                          rasterTaskRunner = [_engine.get() rasterTaskRunner]]() {
    FML_DCHECK(rasterTaskRunner->RunsTasksOnCurrentThread());
    // Get callback on raster thread and jump back to platform thread.
    platformTaskRunner->PostTask([weakSelf]() {
      if (weakSelf) {
        fml::scoped_nsobject<FlutterViewController> flutterViewController(
            [(FlutterViewController*)weakSelf.get() retain]);
        if (flutterViewController) {
          if (flutterViewController.get()->_splashScreenView) {
            [flutterViewController removeSplashScreenView:^{
              [flutterViewController callViewRenderedCallback];
            }];
          } else {
            [flutterViewController callViewRenderedCallback];
          }
        }
      }
    });
  });
}

◆ installSplashScreenViewIfNecessary

- (void) installSplashScreenViewIfNecessary

implementation

Definition at line 527 of file FlutterViewController.mm.

                                           {
  // Show the launch screen view again on top of the FlutterView if available.
  // This launch screen view will be removed once the first Flutter frame is rendered.
  if (_splashScreenView && (self.isBeingPresented || self.isMovingToParentViewController)) {
    [_splashScreenView.get() removeFromSuperview];
    _splashScreenView.reset();
    return;
  }
 
  // Use the property getter to initialize the default value.
  UIView* splashScreenView = self.splashScreenView;
  if (splashScreenView == nil) {
    return;
  }
  splashScreenView.frame = self.view.bounds;
  [self.view addSubview:splashScreenView];
}

◆ invalidateKeyboardAnimationVSyncClient

- (void) invalidateKeyboardAnimationVSyncClient

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                               {
  [_keyboardAnimationVSyncClient invalidate];
  [_keyboardAnimationVSyncClient release];
  _keyboardAnimationVSyncClient = nil;
}

◆ invalidateTouchRateCorrectionVSyncClient

- (void) invalidateTouchRateCorrectionVSyncClient

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                                 {
  [_touchRateCorrectionVSyncClient invalidate];
  [_touchRateCorrectionVSyncClient release];
  _touchRateCorrectionVSyncClient = nil;
}

◆ ios

- ios

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                                                                      {
  flutter::PointerData pointer_data;
  pointer_data.Clear();
  pointer_data.time_stamp = [[NSProcessInfo processInfo] systemUptime] * kMicrosecondsPerSecond;
  pointer_data.physical_x = _mouseState.location.x;
  pointer_data.physical_y = _mouseState.location.y;
  return pointer_data;
}

◆ isAlwaysUse24HourFormat

- (BOOL) isAlwaysUse24HourFormat

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                {
  // iOS does not report its "24-Hour Time" user setting in the API. Instead, it applies
  // it automatically to NSDateFormatter when used with [NSLocale currentLocale]. It is
  // essential that [NSLocale currentLocale] is used. Any custom locale, even the one
  // that's the same as [NSLocale currentLocale] will ignore the 24-hour option (there
  // must be some internal field that's not exposed to developers).
  //
  // Therefore this option behaves differently across Android and iOS. On Android this
  // setting is exposed standalone, and can therefore be applied to all locales, whether
  // the "current system locale" or a custom one. On iOS it only applies to the current
  // system locale. Widget implementors must take this into account in order to provide
  // platform-idiomatic behavior in their widgets.
  NSString* dateFormat = [NSDateFormatter dateFormatFromTemplate:@"j"
                                                         options:0
                                                          locale:[NSLocale currentLocale]];
  return [dateFormat rangeOfString:@"a"].location == NSNotFound;
}

◆ isDispatchingKeyEvent:

- (BOOL) isDispatchingKeyEvent: (NSEvent*) event

implementation

Definition at line 338 of file FlutterViewController.mm.

                             :(NSEvent*)event {
  return [_keyboardManager isDispatchingKeyEvent:event];
}

◆ isKeyboardNotificationForDifferentView:

- (BOOL) isKeyboardNotificationForDifferentView: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                              :(NSNotification*)notification {
  NSDictionary* info = notification.userInfo;
  // Keyboard notifications related to other apps.
  // If the UIKeyboardIsLocalUserInfoKey key doesn't exist (this should not happen after iOS 8),
  // proceed as if it was local so that the notification is not ignored.
  id isLocal = info[UIKeyboardIsLocalUserInfoKey];
  if (isLocal && ![isLocal boolValue]) {
    return YES;
  }
  // Engine’s viewController is not current viewController.
  if ([_engine.get() viewController] != self) {
    return YES;
  }
  return NO;
}

◆ isPresentingViewController

- (BOOL) isPresentingViewController

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                   {
  return self.presentedViewController != nil || self.isPresentingViewControllerAnimating;
}

◆ isUIAccessibilityIsVoiceOverRunning

+ (BOOL) isUIAccessibilityIsVoiceOverRunning

A wrapper around UIAccessibilityIsVoiceOverRunning().

As a C function, UIAccessibilityIsVoiceOverRunning() cannot be mocked in testing. Mock this class method to testing features depends on UIAccessibilityIsVoiceOverRunning().

Definition at line 1112 of file FlutterViewController.mm.

                                            {
  return UIAccessibilityIsVoiceOverRunning();
}

◆ isViewOpaque

- (BOOL) isViewOpaque

implementation

Definition at line 152 of file FlutterViewController.mm.

                     {
  return _viewOpaque;
}

◆ keyboardAnimationView

- (UIView *) keyboardAnimationView

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                 {
  return _keyboardAnimationView.get();
}

◆ keyboardSpringAnimation

- (SpringAnimation *) keyboardSpringAnimation

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                            {
  return _keyboardSpringAnimation.get();
}

◆ keyboardWillBeHidden:

- (void) keyboardWillBeHidden: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                            :(NSNotification*)notification {
  // When keyboard is hidden or undocked, this notification will be triggered.
  // This notification might not occur when the keyboard is changed from docked to floating, which
  // is why we also use UIKeyboardWillChangeFrameNotification.
  [self handleKeyboardNotification:notification];
}

◆ keyboardWillChangeFrame:

- (void) keyboardWillChangeFrame: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                               :(NSNotification*)notification {
  // Immediately prior to a change in keyboard frame, this notification is triggered.
  // Sometimes when the keyboard is being hidden or undocked, this notification's keyboard's end
  // frame is not yet entirely out of screen, which is why we also use
  // UIKeyboardWillHideNotification.
  [self handleKeyboardNotification:notification];
}

◆ keyboardWillShowNotification:

- (void) keyboardWillShowNotification: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                    :(NSNotification*)notification {
  // Immediately prior to a docked keyboard being shown or when a keyboard goes from
  // undocked/floating to docked, this notification is triggered. This notification also happens
  // when Minimized/Expanded Shortcuts bar is dropped after dragging (the keyboard's end frame will
  // be CGRectZero).
  [self handleKeyboardNotification:notification];
}

◆ keyDown:

- (void) keyDown: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

               :(NSEvent*)event {
  [_keyboardManager handleEvent:event];
}

◆ keyUp:

- (void) keyUp: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

             :(NSEvent*)event {
  [_keyboardManager handleEvent:event];
}

◆ launchEngine

- (BOOL) launchEngine

implementation

Starts running |engine|, including any initial setup.

Definition at line 338 of file FlutterViewController.mm.

                     {
  if (![_engine runWithEntrypoint:nil]) {
    return NO;
  }
  return YES;
}

◆ listenForMetaModifiedKeyUpEvents

- (void) listenForMetaModifiedKeyUpEvents

implementation

Definition at line 338 of file FlutterViewController.mm.

                                         {
  if (_keyUpMonitor != nil) {
    // It is possible for [NSViewController viewWillAppear] to be invoked multiple times
    // in a row. https://github.com/flutter/flutter/issues/105963
    return;
  }
  FlutterViewController* __weak weakSelf = self;
  _keyUpMonitor = [NSEvent
      addLocalMonitorForEventsMatchingMask:NSEventMaskKeyUp
                                   handler:^NSEvent*(NSEvent* event) {
                                     // Intercept keyUp only for events triggered on the current
                                     // view or textInputPlugin.
                                     NSResponder* firstResponder = [[event window] firstResponder];
                                     if (weakSelf.viewLoaded && weakSelf.flutterView &&
                                         (firstResponder == weakSelf.flutterView ||
                                          firstResponder == weakSelf.textInputPlugin) &&
                                         ([event modifierFlags] & NSEventModifierFlagCommand) &&
                                         ([event type] == NSEventTypeKeyUp)) {
                                       [weakSelf keyUp:event];
                                     }
                                     return event;
                                   }];
}

◆ loadDefaultSplashScreenView

- (BOOL) loadDefaultSplashScreenView

Attempts to set the splashScreenView property from the UILaunchStoryboardName from the main bundle's Info.plist file. This method will not change the value of splashScreenView if it cannot find a default one from a storyboard or nib.

Returns: YES if successful, NO otherwise.

Definition at line 527 of file FlutterViewController.mm.

                                    {
  NSString* launchscreenName =
      [[[NSBundle mainBundle] infoDictionary] objectForKey:@"UILaunchStoryboardName"];
  if (launchscreenName == nil) {
    return NO;
  }
  UIView* splashView = [self splashScreenFromStoryboard:launchscreenName];
  if (!splashView) {
    splashView = [self splashScreenFromXib:launchscreenName];
  }
  if (!splashView) {
    return NO;
  }
  self.splashScreenView = splashView;
  return YES;
}

◆ loadView

- (void) loadView

implementation

Definition at line 463 of file FlutterViewController.mm.

                 {
  self.view = GetViewOrPlaceholder(_flutterView.get());
  self.view.multipleTouchEnabled = YES;
  self.view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
 
  [self installSplashScreenViewIfNecessary];
  UIScrollView* scrollView = [[UIScrollView alloc] init];
  scrollView.autoresizingMask = UIViewAutoresizingFlexibleWidth;
  // The color shouldn't matter since it is offscreen.
  scrollView.backgroundColor = UIColor.whiteColor;
  scrollView.delegate = self;
  // This is an arbitrary small size.
  scrollView.contentSize = CGSizeMake(kScrollViewContentSize, kScrollViewContentSize);
  // This is an arbitrary offset that is not CGPointZero.
  scrollView.contentOffset = CGPointMake(kScrollViewContentSize, kScrollViewContentSize);
  [self.view addSubview:scrollView];
  _scrollView.reset(scrollView);
}

◆ lookupKeyForAsset: [1/2]

- (nonnull NSString *) lookupKeyForAsset: (nonnull NSString *) asset

Returns the file name for the given asset. The returned file name can be used to access the asset in the application's main bundle.

Parameters

asset The name of the asset. The name can be hierarchical.

Returns: The file name to be used for lookup in the main bundle.

◆ lookupKeyForAsset: [2/2]

- (NSString *) lookupKeyForAsset: (NSString*) asset

Returns the file name for the given asset. The returned file name can be used to access the asset in the application's main bundle.

Parameters

asset The name of the asset. The name can be hierarchical.

Returns: The file name to be used for lookup in the main bundle.

Definition at line 1112 of file FlutterViewController.mm.

                              :(NSString*)asset {
  return [FlutterDartProject lookupKeyForAsset:asset];
}

◆ lookupKeyForAsset:fromPackage: [1/2]

- (nonnull NSString *) lookupKeyForAsset:	(nonnull NSString *)	asset
fromPackage:	(nonnull NSString *)	package

Returns the file name for the given asset which originates from the specified package. The returned file name can be used to access the asset in the application's main bundle.

Parameters

asset	The name of the asset. The name can be hierarchical.
package	The name of the package from which the asset originates.

Returns: The file name to be used for lookup in the main bundle.

◆ lookupKeyForAsset:fromPackage: [2/2]

- (NSString *) lookupKeyForAsset:	(NSString*)	asset
fromPackage:	(NSString*)	package

Returns the file name for the given asset which originates from the specified package. The returned file name can be used to access the asset in the application's main bundle.

Parameters

asset	The name of the asset. The name can be hierarchical.
package	The name of the package from which the asset originates.

Returns: The file name to be used for lookup in the main bundle.

Definition at line 1112 of file FlutterViewController.mm.

                              :(NSString*)asset fromPackage:(NSString*)package {
  return [FlutterDartProject lookupKeyForAsset:asset fromPackage:package];
}

◆ lookUpLayoutForKeyCode:shift:

- (LayoutClue) lookUpLayoutForKeyCode:	(uint16_t)	keyCode
shift:	(BOOL)	shift

implementation

Querying the printable result of a key under the given modifier state.

Reimplemented from <FlutterKeyboardViewDelegate>.

Definition at line 891 of file FlutterViewController.mm.

                                    :(uint16_t)keyCode shift:(BOOL)shift {
  if (_keyboardLayoutData == nil) {
    _keyboardLayoutData = CurrentKeyboardLayoutData();
  }
  const UCKeyboardLayout* layout = reinterpret_cast<const UCKeyboardLayout*>(
      CFDataGetBytePtr((__bridge CFDataRef)_keyboardLayoutData));
 
  UInt32 deadKeyState = 0;
  UniCharCount stringLength = 0;
  UniChar resultChar;
 
  UInt32 modifierState = ((shift ? shiftKey : 0) >> 8) & 0xFF;
  UInt32 keyboardType = LMGetKbdLast();
 
  bool isDeadKey = false;
  OSStatus status =
      UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierState, keyboardType,
                     kUCKeyTranslateNoDeadKeysBit, &deadKeyState, 1, &stringLength, &resultChar);
  // For dead keys, press the same key again to get the printable representation of the key.
  if (status == noErr && stringLength == 0 && deadKeyState != 0) {
    isDeadKey = true;
    status =
        UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierState, keyboardType,
                       kUCKeyTranslateNoDeadKeysBit, &deadKeyState, 1, &stringLength, &resultChar);
  }
 
  if (status == noErr && stringLength == 1 && !std::iscntrl(resultChar)) {
    return LayoutClue{resultChar, isDeadKey};
  }
  return LayoutClue{0, false};
}

◆ magnifyWithEvent:

- (void) magnifyWithEvent: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                        :(NSEvent*)event {
  [self dispatchGestureEvent:event];
}

◆ makeBackgroundTaskQueue

- (NSObject< FlutterTaskQueue > *) makeBackgroundTaskQueue

implementation

TODO(gaaclarke): Remove optional when macos supports Background Platform Channels.

Reimplemented from <FlutterBinaryMessenger>.

Definition at line 1112 of file FlutterViewController.mm.

                                                       {
  return [_engine.get().binaryMessenger makeBackgroundTaskQueue];
}

◆ mouseDown:

- (void) mouseDown: (NSEvent*) event

implementation

Reimplemented in MouseEventFlutterViewController.

Definition at line 891 of file FlutterViewController.mm.

                 :(NSEvent*)event {
  _mouseState.buttons |= kFlutterPointerButtonMousePrimary;
  [self dispatchMouseEvent:event];
}

◆ mouseDragged:

- (void) mouseDragged: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                    :(NSEvent*)event {
  [self dispatchMouseEvent:event];
}

◆ mouseEntered:

- (void) mouseEntered: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                    :(NSEvent*)event {
  if (_mouseState.has_pending_exit) {
    _mouseState.has_pending_exit = false;
  } else {
    [self dispatchMouseEvent:event phase:kAdd];
  }
}

◆ mouseExited:

- (void) mouseExited: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                   :(NSEvent*)event {
  if (_mouseState.buttons != 0) {
    _mouseState.has_pending_exit = true;
    return;
  }
  [self dispatchMouseEvent:event phase:kRemove];
}

◆ mouseMoved:

- (void) mouseMoved: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                  :(NSEvent*)event {
  [self dispatchMouseEvent:event];
}

◆ mouseUp:

- (void) mouseUp: (NSEvent*) event

implementation

Reimplemented in MouseEventFlutterViewController.

Definition at line 891 of file FlutterViewController.mm.

               :(NSEvent*)event {
  _mouseState.buttons &= ~static_cast<uint64_t>(kFlutterPointerButtonMousePrimary);
  [self dispatchMouseEvent:event];
}

◆ notifySemanticsEnabledChanged

- (void) notifySemanticsEnabledChanged

implementation

Called by the associated FlutterEngine when FlutterEngine::semanticsEnabled has changed.

Definition at line 338 of file FlutterViewController.mm.

                                      {
  BOOL mySemanticsEnabled = !!_bridge;
  BOOL newSemanticsEnabled = _engine.semanticsEnabled;
  if (newSemanticsEnabled == mySemanticsEnabled) {
    return;
  }
  if (newSemanticsEnabled) {
    _bridge = [self createAccessibilityBridgeWithEngine:_engine];
  } else {
    // Remove the accessibility children from flutter view before resetting the bridge.
    _flutterView.accessibilityChildren = nil;
    _bridge.reset();
  }
  NSAssert(newSemanticsEnabled == !!_bridge, @"Failed to update semantics for the view.");
}

◆ onAccessibilityStatusChanged: [1/2]

- (void) onAccessibilityStatusChanged: (BOOL) enabled

implementation

Definition at line 338 of file FlutterViewController.mm.

                                    :(BOOL)enabled {
  if (!enabled && self.viewLoaded && [_textInputPlugin isFirstResponder]) {
    // Normally TextInputPlugin, when editing, is child of FlutterViewWrapper.
    // When accessiblity is enabled the TextInputPlugin gets added as an indirect
    // child to FlutterTextField. When disabling the plugin needs to be reparented
    // back.
    [self.view addSubview:_textInputPlugin];
  }
}

◆ onAccessibilityStatusChanged: [2/2]

- (void) onAccessibilityStatusChanged: (NSNotification*) notification

implementation

Provided by category FlutterViewController(TestMethods).

Definition at line 1112 of file FlutterViewController.mm.

                                    :(NSNotification*)notification {
  if (!_engine) {
    return;
  }
  auto platformView = [_engine.get() platformView];
  int32_t flags = [self accessibilityFlags];
#if TARGET_OS_SIMULATOR
  // There doesn't appear to be any way to determine whether the accessibility
  // inspector is enabled on the simulator. We conservatively always turn on the
  // accessibility bridge in the simulator, but never assistive technology.
  platformView->SetSemanticsEnabled(true);
  platformView->SetAccessibilityFeatures(flags);
#else
  _isVoiceOverRunning = UIAccessibilityIsVoiceOverRunning();
  bool enabled = _isVoiceOverRunning || UIAccessibilityIsSwitchControlRunning();
  if (enabled) {
    flags |= static_cast<int32_t>(flutter::AccessibilityFeatureFlag::kAccessibleNavigation);
  }
  platformView->SetSemanticsEnabled(enabled || UIAccessibilityIsSpeakScreenEnabled());
  platformView->SetAccessibilityFeatures(flags);
#endif
}

◆ onHideHomeIndicatorNotification:

- (void) onHideHomeIndicatorNotification: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                       :(NSNotification*)notification {
  self.isHomeIndicatorHidden = YES;
}

◆ onKeyboardLayoutChanged

- (void) onKeyboardLayoutChanged

implementation

Called when the active keyboard input source changes.

Input sources may be simple keyboard layouts, or more complex input methods involving an IME, such as Chinese, Japanese, and Korean.

Definition at line 338 of file FlutterViewController.mm.

                                {
  _keyboardLayoutData = nil;
  if (_keyboardLayoutNotifier != nil) {
    _keyboardLayoutNotifier();
  }
}

◆ onOrientationPreferencesUpdated:

- (void) onOrientationPreferencesUpdated: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                       :(NSNotification*)notification {
  // Notifications may not be on the iOS UI thread
  dispatch_async(dispatch_get_main_queue(), ^{
    NSDictionary* info = notification.userInfo;
 
    NSNumber* update = info[@(flutter::kOrientationUpdateNotificationKey)];
 
    if (update == nil) {
      return;
    }
    [self performOrientationUpdate:update.unsignedIntegerValue];
  });
}

◆ onPreEngineRestart

- (void) onPreEngineRestart

Invoked by the engine right before the engine is restarted.

This should reset states to as if the application has just started. It usually indicates a hot restart (Shift-R in Flutter CLI.)

Definition at line 338 of file FlutterViewController.mm.

                           {
  [self initializeKeyboard];
}

◆ onPreferredStatusBarStyleUpdated:

- (void) onPreferredStatusBarStyleUpdated: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                        :(NSNotification*)notification {
  // Notifications may not be on the iOS UI thread
  dispatch_async(dispatch_get_main_queue(), ^{
    NSDictionary* info = notification.userInfo;
 
    NSNumber* update = info[@(flutter::kOverlayStyleUpdateNotificationKey)];
 
    if (update == nil) {
      return;
    }
 
    NSInteger style = update.integerValue;
 
    if (style != _statusBarStyle) {
      _statusBarStyle = static_cast<UIStatusBarStyle>(style);
      [self setNeedsStatusBarAppearanceUpdate];
    }
  });
}

◆ onShowHomeIndicatorNotification:

- (void) onShowHomeIndicatorNotification: (NSNotification*) notification

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                       :(NSNotification*)notification {
  self.isHomeIndicatorHidden = NO;
}

◆ onTextInputKeyEvent:

- (BOOL) onTextInputKeyEvent: (nonnull NSEvent *) event

implementation

Dispatch events that are not handled by the keyboard event handlers to the text input handler.

This method typically forwards events to |TextInputPlugin.handleKeyEvent|.

Reimplemented from <FlutterKeyboardViewDelegate>.

Definition at line 891 of file FlutterViewController.mm.

                           :(nonnull NSEvent*)event {
  return [_textInputPlugin handleKeyEvent:event];
}

◆ onUserSettingsChanged:

- (void) onUserSettingsChanged: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                             :(NSNotification*)notification {
  [[_engine.get() settingsChannel] sendMessage:@{
    @"textScaleFactor" : @([self textScaleFactor]),
    @"alwaysUse24HourFormat" : @([self isAlwaysUse24HourFormat]),
    @"platformBrightness" : [self brightnessMode],
    @"platformContrast" : [self contrastMode],
    @"nativeSpellCheckServiceDefined" : @true,
    @"supportsShowingSystemContextMenu" : @([self supportsShowingSystemContextMenu])
  }];
}

◆ otherMouseDown:

- (void) otherMouseDown: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                      :(NSEvent*)event {
  _mouseState.buttons |= (1 << event.buttonNumber);
  [self dispatchMouseEvent:event];
}

◆ otherMouseDragged:

- (void) otherMouseDragged: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                         :(NSEvent*)event {
  [self dispatchMouseEvent:event];
}

◆ otherMouseUp:

- (void) otherMouseUp: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                    :(NSEvent*)event {
  _mouseState.buttons &= ~static_cast<uint64_t>(1 << event.buttonNumber);
  [self dispatchMouseEvent:event];
}

◆ performCommonViewControllerInitialization

- (void) performCommonViewControllerInitialization

implementation

Definition at line 152 of file FlutterViewController.mm.

                                                  {
  if (_initialized) {
    return;
  }
 
  _initialized = YES;
 
  _orientationPreferences = UIInterfaceOrientationMaskAll;
  _statusBarStyle = UIStatusBarStyleDefault;
 
  [self setUpNotificationCenterObservers];
}

◆ performOrientationUpdate:

- (void) performOrientationUpdate: (UIInterfaceOrientationMask) new_preferences

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                :(UIInterfaceOrientationMask)new_preferences {
  if (new_preferences != _orientationPreferences) {
    _orientationPreferences = new_preferences;
 
    if (@available(iOS 16.0, *)) {
      NSSet<UIScene*>* scenes =
#if APPLICATION_EXTENSION_API_ONLY
          self.flutterWindowSceneIfViewLoaded
              ? [NSSet setWithObject:self.flutterWindowSceneIfViewLoaded]
              : [NSSet set];
#else
          [UIApplication.sharedApplication.connectedScenes
              filteredSetUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(
                                                         id scene, NSDictionary* bindings) {
                return [scene isKindOfClass:[UIWindowScene class]];
              }]];
#endif
      [self requestGeometryUpdateForWindowScenes:scenes];
    } else {
      UIInterfaceOrientationMask currentInterfaceOrientation = 0;
      if (@available(iOS 13.0, *)) {
        UIWindowScene* windowScene = [self flutterWindowSceneIfViewLoaded];
        if (!windowScene) {
          FML_LOG(WARNING)
              << "Accessing the interface orientation when the window scene is unavailable.";
          return;
        }
        currentInterfaceOrientation = 1 << windowScene.interfaceOrientation;
      } else {
#if APPLICATION_EXTENSION_API_ONLY
        FML_LOG(ERROR) << "Application based status bar orentiation update is not supported in "
                          "app extension. Orientation: "
                       << currentInterfaceOrientation;
#else
        currentInterfaceOrientation = 1 << [[UIApplication sharedApplication] statusBarOrientation];
#endif
      }
      if (!(_orientationPreferences & currentInterfaceOrientation)) {
        [UIViewController attemptRotationToDeviceOrientation];
        // Force orientation switch if the current orientation is not allowed
        if (_orientationPreferences & UIInterfaceOrientationMaskPortrait) {
          // This is no official API but more like a workaround / hack (using
          // key-value coding on a read-only property). This might break in
          // the future, but currently it´s the only way to force an orientation change
          [[UIDevice currentDevice] setValue:@(UIInterfaceOrientationPortrait)
                                      forKey:@"orientation"];
        } else if (_orientationPreferences & UIInterfaceOrientationMaskPortraitUpsideDown) {
          [[UIDevice currentDevice] setValue:@(UIInterfaceOrientationPortraitUpsideDown)
                                      forKey:@"orientation"];
        } else if (_orientationPreferences & UIInterfaceOrientationMaskLandscapeLeft) {
          [[UIDevice currentDevice] setValue:@(UIInterfaceOrientationLandscapeLeft)
                                      forKey:@"orientation"];
        } else if (_orientationPreferences & UIInterfaceOrientationMaskLandscapeRight) {
          [[UIDevice currentDevice] setValue:@(UIInterfaceOrientationLandscapeRight)
                                      forKey:@"orientation"];
        }
      }
    }
  }
}

◆ pinchEvent:

- (void) pinchEvent: (ios(13.4)) API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                  :(UIPinchGestureRecognizer*)recognizer API_AVAILABLE(ios(13.4)) {
  flutter::PointerData pointer_data = [self generatePointerDataAtLastMouseLocation];
  pointer_data.device = reinterpret_cast<int64_t>(recognizer);
  pointer_data.kind = flutter::PointerData::DeviceKind::kTrackpad;
  pointer_data.view_id = self.viewIdentifier;
  switch (recognizer.state) {
    case UIGestureRecognizerStateBegan:
      pointer_data.change = flutter::PointerData::Change::kPanZoomStart;
      break;
    case UIGestureRecognizerStateChanged:
      pointer_data.change = flutter::PointerData::Change::kPanZoomUpdate;
      pointer_data.scale = recognizer.scale;
      pointer_data.rotation = _rotationGestureRecognizer.rotation;
      break;
    case UIGestureRecognizerStateEnded:
    case UIGestureRecognizerStateCancelled:
      pointer_data.change = flutter::PointerData::Change::kPanZoomEnd;
      break;
    default:
      // pinchEvent: should only ever be triggered with the above phases
      NSAssert(false, @"Trackpad pinch event occured with unexpected phase 0x%lx",
               (long)recognizer.state);
      break;
  }
 
  auto packet = std::make_unique<flutter::PointerDataPacket>(1);
  packet->SetPointerData(/*i=*/0, pointer_data);
  [_engine.get() dispatchPointerDataPacket:std::move(packet)];
}

◆ platformViewsController

- (shared_ptr<) flutter:

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                                                                 {
  return [_engine.get() platformViewsController];
}

◆ pluginRegistry

- (id< FlutterPluginRegistry >) pluginRegistry

The FlutterPluginRegistry used by this FlutterViewController.

Definition at line 1112 of file FlutterViewController.mm.

                                            {
  return _engine;
}

◆ PointerDataChangeFromUITouchPhase

+ (static) PointerData: (UITouchPhase) phase

implementation

Definition at line 1090 of file FlutterViewController.mm.

                                                                                      {
  switch (phase) {
    case UITouchPhaseBegan:
      return flutter::PointerData::Change::kDown;
    case UITouchPhaseMoved:
    case UITouchPhaseStationary:
      // There is no EVENT_TYPE_POINTER_STATIONARY. So we just pass a move type
      // with the same coordinates
      return flutter::PointerData::Change::kMove;
    case UITouchPhaseEnded:
      return flutter::PointerData::Change::kUp;
    case UITouchPhaseCancelled:
      return flutter::PointerData::Change::kCancel;
    default:
      // TODO(53695): Handle the `UITouchPhaseRegion`... enum values.
      FML_DLOG(INFO) << "Unhandled touch phase: " << phase;
      break;
  }
 
  return flutter::PointerData::Change::kCancel;
}

◆ popRoute

- (void) popRoute

Instructs the Flutter Navigator (if any) to go back.

Definition at line 152 of file FlutterViewController.mm.

                 {
  [[_engine.get() navigationChannel] invokeMethod:@"popRoute" arguments:nil];
}

◆ preferredStatusBarStyle

- (UIStatusBarStyle) preferredStatusBarStyle

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                            {
  return _statusBarStyle;
}

◆ prefersHomeIndicatorAutoHidden

- (BOOL) prefersHomeIndicatorAutoHidden

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                       {
  return self.isHomeIndicatorHidden;
}

◆ prefersStatusBarHidden

- (BOOL) prefersStatusBarHidden

implementation

Whether the status bar is preferred hidden.

   This overrides the |UIViewController:prefersStatusBarHidden|.
   This is ignored when `UIViewControllerBasedStatusBarAppearance` in info.plist
   of the app project is `false`.

Reimplemented in NoStatusBarFlutterViewController.

Definition at line 1112 of file FlutterViewController.mm.

                               {
  return _flutterPrefersStatusBarHidden;
}

◆ presentViewController:animated:completion:

- (void) presentViewController:	(UIViewController*)	viewControllerToPresent
animated:	(BOOL)	flag
completion:	(void(^)(void))	completion

implementation

Definition at line 1112 of file FlutterViewController.mm.

                             :(UIViewController*)viewControllerToPresent
                     animated:(BOOL)flag
                   completion:(void (^)(void))completion {
  self.isPresentingViewControllerAnimating = YES;
  [super presentViewController:viewControllerToPresent
                      animated:flag
                    completion:^{
                      self.isPresentingViewControllerAnimating = NO;
                      if (completion) {
                        completion();
                      }
                    }];
}

◆ pressesBegan:withEvent:

- (void) pressesBegan:	(NSSet<UIPress>)	presses
withEvent:	(ios(9.0))	API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                    :(NSSet<UIPress*>*)presses
           withEvent:(UIPressesEvent*)event API_AVAILABLE(ios(9.0)) {
  if (@available(iOS 13.4, *)) {
    for (UIPress* press in presses) {
      [self handlePressEvent:[[[FlutterUIPressProxy alloc] initWithPress:press
                                                               withEvent:event] autorelease]
                  nextAction:^() {
                    [super pressesBegan:[NSSet setWithObject:press] withEvent:event];
                  }];
    }
  } else {
    [super pressesBegan:presses withEvent:event];
  }
}

◆ pressesCancelled:withEvent:

- (void) pressesCancelled:	(NSSet<UIPress>)	presses
withEvent:	(ios(9.0))	API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                        :(NSSet<UIPress*>*)presses
               withEvent:(UIPressesEvent*)event API_AVAILABLE(ios(9.0)) {
  if (@available(iOS 13.4, *)) {
    for (UIPress* press in presses) {
      [self handlePressEvent:[[[FlutterUIPressProxy alloc] initWithPress:press
                                                               withEvent:event] autorelease]
                  nextAction:^() {
                    [super pressesCancelled:[NSSet setWithObject:press] withEvent:event];
                  }];
    }
  } else {
    [super pressesCancelled:presses withEvent:event];
  }
}

◆ pressesChanged:withEvent:

- (void) pressesChanged:	(NSSet<UIPress>)	presses
withEvent:	(ios(9.0))	API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                      :(NSSet<UIPress*>*)presses
             withEvent:(UIPressesEvent*)event API_AVAILABLE(ios(9.0)) {
  if (@available(iOS 13.4, *)) {
    for (UIPress* press in presses) {
      [self handlePressEvent:[[[FlutterUIPressProxy alloc] initWithPress:press
                                                               withEvent:event] autorelease]
                  nextAction:^() {
                    [super pressesChanged:[NSSet setWithObject:press] withEvent:event];
                  }];
    }
  } else {
    [super pressesChanged:presses withEvent:event];
  }
}

◆ pressesEnded:withEvent:

- (void) pressesEnded:	(NSSet<UIPress>)	presses
withEvent:	(ios(9.0))	API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                    :(NSSet<UIPress*>*)presses
           withEvent:(UIPressesEvent*)event API_AVAILABLE(ios(9.0)) {
  if (@available(iOS 13.4, *)) {
    for (UIPress* press in presses) {
      [self handlePressEvent:[[[FlutterUIPressProxy alloc] initWithPress:press
                                                               withEvent:event] autorelease]
                  nextAction:^() {
                    [super pressesEnded:[NSSet setWithObject:press] withEvent:event];
                  }];
    }
  } else {
    [super pressesEnded:presses withEvent:event];
  }
}

◆ pushRoute:

- (void) pushRoute: (NSString*) route

Instructs the Flutter Navigator (if any) to push a route on to the navigation stack.

Parameters

route The name of the route to push to the navigation stack.

Definition at line 152 of file FlutterViewController.mm.

                 :(NSString*)route {
  [[_engine.get() navigationChannel] invokeMethod:@"pushRoute" arguments:route];
}

◆ registerTexture:

- (int64_t) registerTexture: (NSObject< FlutterTexture > *) texture

implementation

Registers a FlutterTexture for usage in Flutter and returns an id that can be used to reference that texture when calling into Flutter with channels. Textures must be registered on the platform thread. On success returns the pointer to the registered texture, else returns 0.

Reimplemented from <FlutterTextureRegistry>.

Definition at line 1112 of file FlutterViewController.mm.

                          :(NSObject<FlutterTexture>*)texture {
  return [_engine.get().textureRegistry registerTexture:texture];
}

◆ registrarForPlugin:

- (id< FlutterPluginRegistrar >) registrarForPlugin: (NSString *) pluginKey

implementation

Returns a registrar for registering a plugin.

Parameters

pluginKey The unique key identifying the plugin.

Reimplemented from <FlutterPluginRegistry>.

Definition at line 1112 of file FlutterViewController.mm.

                                                       :(NSString*)pluginKey {
  return [_engine.get() registrarForPlugin:pluginKey];
}

◆ removeInternalPlugins

- (void) removeInternalPlugins

implementation

Definition at line 527 of file FlutterViewController.mm.

                              {
  self.keyboardManager = nil;
}

◆ removeKeyboardAnimationView

- (void) removeKeyboardAnimationView

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                    {
  if ([self keyboardAnimationView].superview != nil) {
    [[self keyboardAnimationView] removeFromSuperview];
  }
}

◆ removeSplashScreenView:

- (void) removeSplashScreenView: (dispatch_block_t _Nullable) onComplete

implementation

Definition at line 527 of file FlutterViewController.mm.

                              :(dispatch_block_t _Nullable)onComplete {
  NSAssert(_splashScreenView, @"The splash screen view must not be null");
  UIView* splashScreen = [_splashScreenView.get() retain];
  _splashScreenView.reset();
  [UIView animateWithDuration:0.2
      animations:^{
        splashScreen.alpha = 0;
      }
      completion:^(BOOL finished) {
        [splashScreen removeFromSuperview];
        [splashScreen release];
        if (onComplete) {
          onComplete();
        }
      }];
}

◆ requestGeometryUpdateForWindowScenes:

- (void) requestGeometryUpdateForWindowScenes: (ios(16.0)) API_AVAILABLE

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                            :(NSSet<UIScene*>*)windowScenes
    API_AVAILABLE(ios(16.0)) {
  for (UIScene* windowScene in windowScenes) {
    FML_DCHECK([windowScene isKindOfClass:[UIWindowScene class]]);
    UIWindowSceneGeometryPreferencesIOS* preference = [[[UIWindowSceneGeometryPreferencesIOS alloc]
        initWithInterfaceOrientations:_orientationPreferences] autorelease];
    [(UIWindowScene*)windowScene
        requestGeometryUpdateWithPreferences:preference
                                errorHandler:^(NSError* error) {
                                  os_log_error(OS_LOG_DEFAULT,
                                               "Failed to change device orientation: %@", error);
                                }];
    [self setNeedsUpdateOfSupportedInterfaceOrientations];
  }
}

◆ restorationPlugin

- (FlutterRestorationPlugin *) restorationPlugin

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                               {
  return [_engine.get() restorationPlugin];
}

◆ rightMouseDown:

- (void) rightMouseDown: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                      :(NSEvent*)event {
  _mouseState.buttons |= kFlutterPointerButtonMouseSecondary;
  [self dispatchMouseEvent:event];
}

◆ rightMouseDragged:

- (void) rightMouseDragged: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                         :(NSEvent*)event {
  [self dispatchMouseEvent:event];
}

◆ rightMouseUp:

- (void) rightMouseUp: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                    :(NSEvent*)event {
  _mouseState.buttons &= ~static_cast<uint64_t>(kFlutterPointerButtonMouseSecondary);
  [self dispatchMouseEvent:event];
}

◆ rotateWithEvent:

- (void) rotateWithEvent: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                       :(NSEvent*)event {
  [self dispatchGestureEvent:event];
}

◆ sceneBecameActive:

- (void) sceneBecameActive: (ios(13.0)) API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                         :(NSNotification*)notification API_AVAILABLE(ios(13.0)) {
  TRACE_EVENT0("flutter", "sceneBecameActive");
  [self appOrSceneBecameActive];
}

◆ sceneDidEnterBackground:

- (void) sceneDidEnterBackground: (ios(13.0)) API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                               :(NSNotification*)notification API_AVAILABLE(ios(13.0)) {
  TRACE_EVENT0("flutter", "sceneDidEnterBackground");
  [self appOrSceneDidEnterBackground];
}

◆ sceneWillDisconnect:

- (void) sceneWillDisconnect: (ios(13.0)) API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                           :(NSNotification*)notification API_AVAILABLE(ios(13.0)) {
  [self appOrSceneWillTerminate];
}

◆ sceneWillEnterForeground:

- (void) sceneWillEnterForeground: (ios(13.0)) API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                                :(NSNotification*)notification API_AVAILABLE(ios(13.0)) {
  TRACE_EVENT0("flutter", "sceneWillEnterForeground");
  [self appOrSceneWillEnterForeground];
}

◆ sceneWillResignActive:

- (void) sceneWillResignActive: (ios(13.0)) API_AVAILABLE

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                             :(NSNotification*)notification API_AVAILABLE(ios(13.0)) {
  TRACE_EVENT0("flutter", "sceneWillResignActive");
  [self appOrSceneWillResignActive];
}

◆ scrollViewShouldScrollToTop:

- (BOOL) scrollViewShouldScrollToTop: (UIScrollView*) scrollView

implementation

Definition at line 527 of file FlutterViewController.mm.

                                   :(UIScrollView*)scrollView {
  if (!_engine) {
    return NO;
  }
  CGPoint statusBarPoint = CGPointZero;
  UIScreen* screen = [self flutterScreenIfViewLoaded];
  if (screen) {
    SendFakeTouchEvent(screen, _engine.get(), statusBarPoint, flutter::PointerData::Change::kDown);
    SendFakeTouchEvent(screen, _engine.get(), statusBarPoint, flutter::PointerData::Change::kUp);
  }
  return NO;
}

◆ scrollWheel:

- (void) scrollWheel: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                   :(NSEvent*)event {
  [self dispatchGestureEvent:event];
}

◆ SendFakeTouchEvent

+ (static void) SendFakeTouchEvent	(UIScreen *)	screen
	(FlutterEngine *)	engine
	(CGPoint)	location
	(flutter::PointerData::Change)	change

implementation

Definition at line 527 of file FlutterViewController.mm.

                                                                {
  const CGFloat scale = screen.scale;
  flutter::PointerData pointer_data = [[engine viewController] generatePointerDataForFake];
  pointer_data.physical_x = location.x * scale;
  pointer_data.physical_y = location.y * scale;
  auto packet = std::make_unique<flutter::PointerDataPacket>(/*count=*/1);
  pointer_data.change = change;
  packet->SetPointerData(0, pointer_data);
  [engine dispatchPointerDataPacket:std::move(packet)];
}

◆ sendKeyEvent:callback:userData:

- (void) sendKeyEvent:	(const FlutterKeyEvent &)	event
callback:	(nullable FlutterKeyEventCallback)	callback
userData:	(nullable void *)	userData

implementation

Dispatch events to the framework to be processed by |HardwareKeyboard|.

This method typically forwards events to |FlutterEngine.sendKeyEvent:callback:userData:|.

Reimplemented from <FlutterKeyboardViewDelegate>.

Definition at line 891 of file FlutterViewController.mm.

                    :(const FlutterKeyEvent&)event
            callback:(nullable FlutterKeyEventCallback)callback
            userData:(nullable void*)userData {
  [_engine sendKeyEvent:event callback:callback userData:userData];
}

◆ sendOnChannel:message:

- (void) sendOnChannel:	(NSString*)	channel
message:	(NSData*)	message

implementation

Definition at line 1112 of file FlutterViewController.mm.

                     :(NSString*)channel message:(NSData*)message {
  [_engine.get().binaryMessenger sendOnChannel:channel message:message];
}

◆ sendOnChannel:message:binaryReply:

- (void) sendOnChannel:	(NSString*)	channel
message:	(NSData*)	message
binaryReply:	(FlutterBinaryReply)	callback

implementation

Definition at line 1112 of file FlutterViewController.mm.

                     :(NSString*)channel
              message:(NSData*)message
          binaryReply:(FlutterBinaryReply)callback {
  NSAssert(channel, @"The channel must not be null");
  [_engine.get().binaryMessenger sendOnChannel:channel message:message binaryReply:callback];
}

◆ setBackgroundColor:

- (void) setBackgroundColor: (NSColor*) color

implementation

Definition at line 338 of file FlutterViewController.mm.

                          :(NSColor*)color {
  _backgroundColor = color;
  [_flutterView setBackgroundColor:_backgroundColor];
}

◆ setDisplayingFlutterUI:

- (void) setDisplayingFlutterUI: (BOOL) displayingFlutterUI

implementation

Definition at line 527 of file FlutterViewController.mm.

                              :(BOOL)displayingFlutterUI {
  if (_displayingFlutterUI != displayingFlutterUI) {
    if (displayingFlutterUI == YES) {
      if (!self.viewIfLoaded.window) {
        return;
      }
    }
    [self willChangeValueForKey:@"displayingFlutterUI"];
    _displayingFlutterUI = displayingFlutterUI;
    [self didChangeValueForKey:@"displayingFlutterUI"];
  }
}

◆ setFlutterViewDidRenderCallback:

- (void) setFlutterViewDidRenderCallback: (void(^)(void)) callback

Registers a callback that will be invoked when the Flutter view has been rendered. The callback will be fired only once.

Replaces an existing callback. Use a nil callback to unregister the existing one.

Definition at line 527 of file FlutterViewController.mm.

                                       :(void (^)(void))callback {
  _flutterViewRenderedCallback.reset(callback, fml::scoped_policy::OwnershipPolicy::kRetain);
}

◆ setInitialRoute: [1/2]

- (void) setInitialRoute: ("Use FlutterViewController initializer to specify initial route") FLUTTER_DEPRECATED

Deprecated API to set initial route.

Attempts to set the first route that the Flutter app shows if the Flutter runtime hasn't yet started. The default is "/".

This method must be called immediately after initWithProject and has no effect when using initWithEngine if the FlutterEngine has already been run.

Setting this after the Flutter started running has no effect. See pushRoute and popRoute to change the route after Flutter started running.

This is deprecated because it needs to be called at the time of initialization and thus should just be in the initWithProject initializer. If using initWithEngine, the initial route should be set on the engine's initializer.

Parameters

route The name of the first route to show.

◆ setInitialRoute: [2/2]

- (void) setInitialRoute: (NSString*) route

implementation

Definition at line 152 of file FlutterViewController.mm.

                       :(NSString*)route {
  [[_engine.get() navigationChannel] invokeMethod:@"setInitialRoute" arguments:route];
}

◆ setIsHomeIndicatorHidden:

- (void) setIsHomeIndicatorHidden: (BOOL) hideHomeIndicator

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                :(BOOL)hideHomeIndicator {
  if (hideHomeIndicator != _isHomeIndicatorHidden) {
    _isHomeIndicatorHidden = hideHomeIndicator;
    [self setNeedsUpdateOfHomeIndicatorAutoHidden];
  }
}

◆ setMessageHandlerOnChannel:binaryMessageHandler:

- (FlutterBinaryMessengerConnection) setMessageHandlerOnChannel:	(NSString*)	channel
binaryMessageHandler:	(FlutterBinaryMessageHandler)	handler

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                                              :(NSString*)channel
                                          binaryMessageHandler:
                                              (FlutterBinaryMessageHandler)handler {
  return [self setMessageHandlerOnChannel:channel binaryMessageHandler:handler taskQueue:nil];
}

◆ setMessageHandlerOnChannel:binaryMessageHandler:taskQueue:

- (FlutterBinaryMessengerConnection) setMessageHandlerOnChannel:	(NSString*)	channel
binaryMessageHandler:	(FlutterBinaryMessageHandler _Nullable)	handler
taskQueue:	(NSObject<FlutterTaskQueue>* _Nullable)	taskQueue

implementation

Reimplemented from <FlutterBinaryMessenger>.

Definition at line 1112 of file FlutterViewController.mm.

                              :(NSString*)channel
          binaryMessageHandler:(FlutterBinaryMessageHandler _Nullable)handler
                     taskQueue:(NSObject<FlutterTaskQueue>* _Nullable)taskQueue {
  NSAssert(channel, @"The channel must not be null");
  return [_engine.get().binaryMessenger setMessageHandlerOnChannel:channel
                                              binaryMessageHandler:handler
                                                         taskQueue:taskQueue];
}

◆ setMouseTrackingMode:

- (void) setMouseTrackingMode: (FlutterMouseTrackingMode) mode

implementation

Definition at line 338 of file FlutterViewController.mm.

                            :(FlutterMouseTrackingMode)mode {
  if (_mouseTrackingMode == mode) {
    return;
  }
  _mouseTrackingMode = mode;
  [self configureTrackingArea];
}

◆ setPrefersStatusBarHidden:

- (void) setPrefersStatusBarHidden: (BOOL) hidden

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                 :(BOOL)hidden {
  if (hidden != _flutterPrefersStatusBarHidden) {
    _flutterPrefersStatusBarHidden = hidden;
    [self setNeedsStatusBarAppearanceUpdate];
  }
}

◆ setSplashScreenView:

- (void) setSplashScreenView: (UIView*) view

implementation

Definition at line 527 of file FlutterViewController.mm.

                           :(UIView*)view {
  if (!view) {
    // Special case: user wants to remove the splash screen view.
    if (_splashScreenView) {
      [self removeSplashScreenView:nil];
    }
    return;
  }
 
  _splashScreenView.reset([view retain]);
  _splashScreenView.get().autoresizingMask =
      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
}

◆ setUpApplicationLifecycleNotifications:

- (void) setUpApplicationLifecycleNotifications: (NSNotificationCenter*) center

implementation

Definition at line 152 of file FlutterViewController.mm.

                                              :(NSNotificationCenter*)center {
  [center addObserver:self
             selector:@selector(applicationBecameActive:)
                 name:UIApplicationDidBecomeActiveNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(applicationWillResignActive:)
                 name:UIApplicationWillResignActiveNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(applicationWillTerminate:)
                 name:UIApplicationWillTerminateNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(applicationDidEnterBackground:)
                 name:UIApplicationDidEnterBackgroundNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(applicationWillEnterForeground:)
                 name:UIApplicationWillEnterForegroundNotification
               object:nil];
}

◆ setUpKeyboardAnimationVsyncClient:

- (void) setUpKeyboardAnimationVsyncClient: (FlutterKeyboardAnimationCallback) keyboardAnimationCallback

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                         :
    (FlutterKeyboardAnimationCallback)keyboardAnimationCallback {
  if (!keyboardAnimationCallback) {
    return;
  }
  NSAssert(_keyboardAnimationVSyncClient == nil,
           @"_keyboardAnimationVSyncClient must be nil when setting up.");
 
  // Make sure the new viewport metrics get sent after the begin frame event has processed.
  fml::scoped_nsprotocol<FlutterKeyboardAnimationCallback> animationCallback(
      [keyboardAnimationCallback copy]);
  auto uiCallback = [animationCallback](std::unique_ptr<flutter::FrameTimingsRecorder> recorder) {
    fml::TimeDelta frameInterval = recorder->GetVsyncTargetTime() - recorder->GetVsyncStartTime();
    fml::TimePoint keyboardAnimationTargetTime = recorder->GetVsyncTargetTime() + frameInterval;
    dispatch_async(dispatch_get_main_queue(), ^(void) {
      animationCallback.get()(keyboardAnimationTargetTime);
    });
  };
 
  _keyboardAnimationVSyncClient = [[VSyncClient alloc] initWithTaskRunner:[_engine uiTaskRunner]
                                                                 callback:uiCallback];
  _keyboardAnimationVSyncClient.allowPauseAfterVsync = NO;
  [_keyboardAnimationVSyncClient await];
}

◆ setUpKeyboardSpringAnimationIfNeeded:

- (void) setUpKeyboardSpringAnimationIfNeeded: (CAAnimation*) keyboardAnimation

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                            :(CAAnimation*)keyboardAnimation {
  // If keyboard animation is null or not a spring animation, fallback to DisplayLink tracking.
  if (keyboardAnimation == nil || ![keyboardAnimation isKindOfClass:[CASpringAnimation class]]) {
    _keyboardSpringAnimation.reset();
    return;
  }
 
  // Setup keyboard spring animation details for spring curve animation calculation.
  CASpringAnimation* keyboardCASpringAnimation = (CASpringAnimation*)keyboardAnimation;
  _keyboardSpringAnimation.reset([[SpringAnimation alloc]
      initWithStiffness:keyboardCASpringAnimation.stiffness
                damping:keyboardCASpringAnimation.damping
                   mass:keyboardCASpringAnimation.mass
        initialVelocity:keyboardCASpringAnimation.initialVelocity
              fromValue:self.originalViewInsetBottom
                toValue:self.targetViewInsetBottom]);
}

◆ setUpNotificationCenterObservers

- (void) setUpNotificationCenterObservers

implementation

Definition at line 152 of file FlutterViewController.mm.

                                         {
  NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
  [center addObserver:self
             selector:@selector(onOrientationPreferencesUpdated:)
                 name:@(flutter::kOrientationUpdateNotificationName)
               object:nil];
 
  [center addObserver:self
             selector:@selector(onPreferredStatusBarStyleUpdated:)
                 name:@(flutter::kOverlayStyleUpdateNotificationName)
               object:nil];
 
#if APPLICATION_EXTENSION_API_ONLY
  if (@available(iOS 13.0, *)) {
    [self setUpSceneLifecycleNotifications:center];
  } else {
    [self setUpApplicationLifecycleNotifications:center];
  }
#else
  [self setUpApplicationLifecycleNotifications:center];
#endif
 
  [center addObserver:self
             selector:@selector(keyboardWillChangeFrame:)
                 name:UIKeyboardWillChangeFrameNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(keyboardWillShowNotification:)
                 name:UIKeyboardWillShowNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(keyboardWillBeHidden:)
                 name:UIKeyboardWillHideNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilityVoiceOverStatusDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilitySwitchControlStatusDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilitySpeakScreenStatusDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilityInvertColorsStatusDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilityReduceMotionStatusDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilityBoldTextStatusDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onAccessibilityStatusChanged:)
                 name:UIAccessibilityDarkerSystemColorsStatusDidChangeNotification
               object:nil];
 
  if (@available(iOS 13.0, *)) {
    [center addObserver:self
               selector:@selector(onAccessibilityStatusChanged:)
                   name:UIAccessibilityOnOffSwitchLabelsDidChangeNotification
                 object:nil];
  }
 
  [center addObserver:self
             selector:@selector(onUserSettingsChanged:)
                 name:UIContentSizeCategoryDidChangeNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(onHideHomeIndicatorNotification:)
                 name:FlutterViewControllerHideHomeIndicator
               object:nil];
 
  [center addObserver:self
             selector:@selector(onShowHomeIndicatorNotification:)
                 name:FlutterViewControllerShowHomeIndicator
               object:nil];
}

◆ setUpSceneLifecycleNotifications:

- (void) setUpSceneLifecycleNotifications: (ios(13.0)) API_AVAILABLE

implementation

Definition at line 152 of file FlutterViewController.mm.

                                        :(NSNotificationCenter*)center API_AVAILABLE(ios(13.0)) {
  [center addObserver:self
             selector:@selector(sceneBecameActive:)
                 name:UISceneDidActivateNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(sceneWillResignActive:)
                 name:UISceneWillDeactivateNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(sceneWillDisconnect:)
                 name:UISceneDidDisconnectNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(sceneDidEnterBackground:)
                 name:UISceneDidEnterBackgroundNotification
               object:nil];
 
  [center addObserver:self
             selector:@selector(sceneWillEnterForeground:)
                 name:UISceneWillEnterForegroundNotification
               object:nil];
}

◆ setUpWithEngine:viewIdentifier:threadSynchronizer:

- (void) setUpWithEngine:	(FlutterEngine*)	engine
viewIdentifier:	(FlutterViewIdentifier)	viewIdentifier
threadSynchronizer:	(FlutterThreadSynchronizer*)	threadSynchronizer

implementation

Definition at line 338 of file FlutterViewController.mm.

                       :(FlutterEngine*)engine
         viewIdentifier:(FlutterViewIdentifier)viewIdentifier
     threadSynchronizer:(FlutterThreadSynchronizer*)threadSynchronizer {
  NSAssert(_engine == nil, @"Already attached to an engine %@.", _engine);
  _engine = engine;
  _viewIdentifier = viewIdentifier;
  _threadSynchronizer = threadSynchronizer;
  [_threadSynchronizer registerView:_viewIdentifier];
}

◆ setViewOpaque:

- (void) setViewOpaque: (BOOL) value

implementation

Definition at line 152 of file FlutterViewController.mm.

                     :(BOOL)value {
  _viewOpaque = value;
  if (_flutterView.get().layer.opaque != value) {
    _flutterView.get().layer.opaque = value;
    [_flutterView.get().layer setNeedsLayout];
  }
}

◆ setViewportMetricsPaddings

- (void) setViewportMetricsPaddings

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                   {
  UIScreen* screen = [self flutterScreenIfViewLoaded];
  if (!screen) {
    return;
  }
 
  CGFloat scale = screen.scale;
  _viewportMetrics.physical_padding_top = self.view.safeAreaInsets.top * scale;
  _viewportMetrics.physical_padding_left = self.view.safeAreaInsets.left * scale;
  _viewportMetrics.physical_padding_right = self.view.safeAreaInsets.right * scale;
  _viewportMetrics.physical_padding_bottom = self.view.safeAreaInsets.bottom * scale;
}

◆ setViewportMetricsSize

- (void) setViewportMetricsSize

implementation

Definition at line 1112 of file FlutterViewController.mm.

                               {
  UIScreen* screen = [self flutterScreenIfViewLoaded];
  if (!screen) {
    return;
  }
 
  CGFloat scale = screen.scale;
  _viewportMetrics.physical_width = self.view.bounds.size.width * scale;
  _viewportMetrics.physical_height = self.view.bounds.size.height * scale;
}

◆ sharedSetupWithProject:initialRoute:

- (void) sharedSetupWithProject:	(nullable FlutterDartProject*)	project
initialRoute:	(nullable NSString*)	initialRoute

implementation

Provided by category FlutterViewController(Tests).

Definition at line 152 of file FlutterViewController.mm.

                              :(nullable FlutterDartProject*)project
                  initialRoute:(nullable NSString*)initialRoute {
  // Need the project to get settings for the view. Initializing it here means
  // the Engine class won't initialize it later.
  if (!project) {
    project = [[[FlutterDartProject alloc] init] autorelease];
  }
  FlutterView.forceSoftwareRendering = project.settings.enable_software_rendering;
  _weakFactory = std::make_unique<fml::WeakNSObjectFactory<FlutterViewController>>(self);
  auto engine = fml::scoped_nsobject<FlutterEngine>{[[FlutterEngine alloc]
                initWithName:@"io.flutter"
                     project:project
      allowHeadlessExecution:self.engineAllowHeadlessExecution
          restorationEnabled:[self restorationIdentifier] != nil]};
 
  if (!engine) {
    return;
  }
 
  _viewOpaque = YES;
  _engine = engine;
  _flutterView.reset([[FlutterView alloc] initWithDelegate:_engine
                                                    opaque:self.isViewOpaque
                                           enableWideGamut:project.isWideGamutEnabled]);
  [_engine.get() createShell:nil libraryURI:nil initialRoute:initialRoute];
  _engineNeedsLaunch = YES;
  _ongoingTouches.reset([[NSMutableSet alloc] init]);
  [self loadDefaultSplashScreenView];
  [self performCommonViewControllerInitialization];
}

◆ shouldAutorotate

- (BOOL) shouldAutorotate

implementation

Definition at line 1112 of file FlutterViewController.mm.

                         {
  return YES;
}

◆ shouldIgnoreKeyboardNotification:

- (BOOL) shouldIgnoreKeyboardNotification: (NSNotification*) notification

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                        :(NSNotification*)notification {
  // Don't ignore UIKeyboardWillHideNotification notifications.
  // Even if the notification is triggered in the background or by a different app/view controller,
  // we want to always handle this notification to avoid inaccurate inset when in a mulitasking mode
  // or when switching between apps.
  if (notification.name == UIKeyboardWillHideNotification) {
    return NO;
  }
 
  // Ignore notification when keyboard's dimensions and position are all zeroes for
  // UIKeyboardWillChangeFrameNotification. This happens when keyboard is dragged. Do not ignore if
  // the notification is UIKeyboardWillShowNotification, as CGRectZero for that notfication only
  // occurs when Minimized/Expanded Shortcuts Bar is dropped after dragging, which we later use to
  // categorize it as floating.
  NSDictionary* info = notification.userInfo;
  CGRect keyboardFrame = [info[UIKeyboardFrameEndUserInfoKey] CGRectValue];
  if (notification.name == UIKeyboardWillChangeFrameNotification &&
      CGRectEqualToRect(keyboardFrame, CGRectZero)) {
    return YES;
  }
 
  // When keyboard's height or width is set to 0, don't ignore. This does not happen
  // often but can happen sometimes when switching between multitasking modes.
  if (CGRectIsEmpty(keyboardFrame)) {
    return NO;
  }
 
  // Ignore keyboard notifications related to other apps or view controllers.
  if ([self isKeyboardNotificationForDifferentView:notification]) {
    return YES;
  }
 
  if (@available(iOS 13.0, *)) {
    // noop
  } else {
    // If OS version is less than 13, ignore notification if the app is in the background
    // or is transitioning from the background. In older versions, when switching between
    // apps with the keyboard open in the secondary app, notifications are sent when
    // the app is in the background/transitioning from background as if they belong
    // to the app and as if the keyboard is showing even though it is not.
    if (self.isKeyboardInOrTransitioningFromBackground) {
      return YES;
    }
  }
 
  return NO;
}

◆ splashScreenFromStoryboard:

- (UIView *) splashScreenFromStoryboard: (NSString*) name

implementation

Definition at line 527 of file FlutterViewController.mm.

                                     :(NSString*)name {
  UIStoryboard* storyboard = nil;
  @try {
    storyboard = [UIStoryboard storyboardWithName:name bundle:nil];
  } @catch (NSException* exception) {
    return nil;
  }
  if (storyboard) {
    UIViewController* splashScreenViewController = [storyboard instantiateInitialViewController];
    return splashScreenViewController.view;
  }
  return nil;
}

◆ splashScreenFromXib:

- (UIView *) splashScreenFromXib: (NSString*) name

implementation

Definition at line 527 of file FlutterViewController.mm.

                              :(NSString*)name {
  NSArray* objects = nil;
  @try {
    objects = [[NSBundle mainBundle] loadNibNamed:name owner:self options:nil];
  } @catch (NSException* exception) {
    return nil;
  }
  if ([objects count] != 0) {
    UIView* view = [objects objectAtIndex:0];
    return view;
  }
  return nil;
}

◆ startKeyBoardAnimation:

- (void) startKeyBoardAnimation: (NSTimeInterval) duration

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                              :(NSTimeInterval)duration {
  // If current physical_view_inset_bottom == targetViewInsetBottom, do nothing.
  if (_viewportMetrics.physical_view_inset_bottom == self.targetViewInsetBottom) {
    return;
  }
 
  // When this method is called for the first time,
  // initialize the keyboardAnimationView to get animation interpolation during animation.
  if ([self keyboardAnimationView] == nil) {
    UIView* keyboardAnimationView = [[UIView alloc] init];
    [keyboardAnimationView setHidden:YES];
    _keyboardAnimationView.reset(keyboardAnimationView);
  }
 
  if ([self keyboardAnimationView].superview == nil) {
    [self.view addSubview:[self keyboardAnimationView]];
  }
 
  // Remove running animation when start another animation.
  [[self keyboardAnimationView].layer removeAllAnimations];
 
  // Set animation begin value and DisplayLink tracking values.
  [self keyboardAnimationView].frame =
      CGRectMake(0, _viewportMetrics.physical_view_inset_bottom, 0, 0);
  self.keyboardAnimationStartTime = fml::TimePoint().Now();
  self.originalViewInsetBottom = _viewportMetrics.physical_view_inset_bottom;
 
  // Invalidate old vsync client if old animation is not completed.
  [self invalidateKeyboardAnimationVSyncClient];
 
  fml::WeakNSObject<FlutterViewController> weakSelf = [self getWeakNSObject];
  FlutterKeyboardAnimationCallback keyboardAnimationCallback = ^(
      fml::TimePoint keyboardAnimationTargetTime) {
    if (!weakSelf) {
      return;
    }
    fml::scoped_nsobject<FlutterViewController> flutterViewController(
        [(FlutterViewController*)weakSelf.get() retain]);
    if (!flutterViewController) {
      return;
    }
 
    // If the view controller's view is not loaded, bail out.
    if (!flutterViewController.get().isViewLoaded) {
      return;
    }
    // If the view for tracking keyboard animation is nil, means it is not
    // created, bail out.
    if ([flutterViewController keyboardAnimationView] == nil) {
      return;
    }
    // If keyboardAnimationVSyncClient is nil, means the animation ends.
    // And should bail out.
    if (flutterViewController.get().keyboardAnimationVSyncClient == nil) {
      return;
    }
 
    if ([flutterViewController keyboardAnimationView].superview == nil) {
      // Ensure the keyboardAnimationView is in view hierarchy when animation running.
      [flutterViewController.get().view addSubview:[flutterViewController keyboardAnimationView]];
    }
 
    if ([flutterViewController keyboardSpringAnimation] == nil) {
      if (flutterViewController.get().keyboardAnimationView.layer.presentationLayer) {
        flutterViewController.get()->_viewportMetrics.physical_view_inset_bottom =
            flutterViewController.get()
                .keyboardAnimationView.layer.presentationLayer.frame.origin.y;
        [flutterViewController updateViewportMetricsIfNeeded];
      }
    } else {
      fml::TimeDelta timeElapsed =
          keyboardAnimationTargetTime - flutterViewController.get().keyboardAnimationStartTime;
      flutterViewController.get()->_viewportMetrics.physical_view_inset_bottom =
          [[flutterViewController keyboardSpringAnimation] curveFunction:timeElapsed.ToSecondsF()];
      [flutterViewController updateViewportMetricsIfNeeded];
    }
  };
  [self setUpKeyboardAnimationVsyncClient:keyboardAnimationCallback];
  VSyncClient* currentVsyncClient = _keyboardAnimationVSyncClient;
 
  [UIView animateWithDuration:duration
      animations:^{
        // Set end value.
        [self keyboardAnimationView].frame = CGRectMake(0, self.targetViewInsetBottom, 0, 0);
 
        // Setup keyboard animation interpolation.
        CAAnimation* keyboardAnimation =
            [[self keyboardAnimationView].layer animationForKey:@"position"];
        [self setUpKeyboardSpringAnimationIfNeeded:keyboardAnimation];
      }
      completion:^(BOOL finished) {
        if (_keyboardAnimationVSyncClient == currentVsyncClient) {
          // Indicates the vsync client captured by this block is the original one, which also
          // indicates the animation has not been interrupted from its beginning. Moreover,
          // indicates the animation is over and there is no more to execute.
          [self invalidateKeyboardAnimationVSyncClient];
          [self removeKeyboardAnimationView];
          [self ensureViewportMetricsIsCorrect];
        }
      }];
}

◆ subscribeToKeyboardLayoutChange:

- (void) subscribeToKeyboardLayoutChange: (nullable KeyboardLayoutNotifier) callback

implementation

Definition at line 891 of file FlutterViewController.mm.

                                       :(nullable KeyboardLayoutNotifier)callback {
  _keyboardLayoutNotifier = callback;
}

◆ supportedInterfaceOrientations

- (NSUInteger) supportedInterfaceOrientations

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                             {
  return _orientationPreferences;
}

◆ supportsShowingSystemContextMenu

- (BOOL) supportsShowingSystemContextMenu

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                         {
  if (@available(iOS 16.0, *)) {
    return YES;
  } else {
    return NO;
  }
}

◆ surfaceUpdated:

- (void) surfaceUpdated: (BOOL) appeared

implementation

Provided by category FlutterViewController(Tests).

Definition at line 527 of file FlutterViewController.mm.

                      :(BOOL)appeared {
  if (!_engine) {
    return;
  }
 
  // NotifyCreated/NotifyDestroyed are synchronous and require hops between the UI and raster
  // thread.
  if (appeared) {
    [self installFirstFrameCallback];
    [_engine.get() platformViewsController]->SetFlutterView(_flutterView.get());
    [_engine.get() platformViewsController]->SetFlutterViewController(self);
    [_engine.get() iosPlatformView]->NotifyCreated();
  } else {
    self.displayingFlutterUI = NO;
    [_engine.get() iosPlatformView]->NotifyDestroyed();
    [_engine.get() platformViewsController]->SetFlutterView(nullptr);
    [_engine.get() platformViewsController]->SetFlutterViewController(nullptr);
  }
}

◆ swipeWithEvent:

- (void) swipeWithEvent: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                      :(NSEvent*)event {
  // Not needed, it's handled by scrollWheel.
}

◆ textScaleFactor

- (CGFloat) textScaleFactor

implementation

Definition at line 1112 of file FlutterViewController.mm.

                           {
#if APPLICATION_EXTENSION_API_ONLY
  FML_LOG(WARNING) << "Dynamic content size update is not supported in app extension.";
  return 1.0;
#else
  UIContentSizeCategory category = [UIApplication sharedApplication].preferredContentSizeCategory;
  // The delta is computed by approximating Apple's typography guidelines:
  // https://developer.apple.com/ios/human-interface-guidelines/visual-design/typography/
  //
  // Specifically:
  // Non-accessibility sizes for "body" text are:
  const CGFloat xs = 14;
  const CGFloat s = 15;
  const CGFloat m = 16;
  const CGFloat l = 17;
  const CGFloat xl = 19;
  const CGFloat xxl = 21;
  const CGFloat xxxl = 23;
 
  // Accessibility sizes for "body" text are:
  const CGFloat ax1 = 28;
  const CGFloat ax2 = 33;
  const CGFloat ax3 = 40;
  const CGFloat ax4 = 47;
  const CGFloat ax5 = 53;
 
  // We compute the scale as relative difference from size L (large, the default size), where
  // L is assumed to have scale 1.0.
  if ([category isEqualToString:UIContentSizeCategoryExtraSmall]) {
    return xs / l;
  } else if ([category isEqualToString:UIContentSizeCategorySmall]) {
    return s / l;
  } else if ([category isEqualToString:UIContentSizeCategoryMedium]) {
    return m / l;
  } else if ([category isEqualToString:UIContentSizeCategoryLarge]) {
    return 1.0;
  } else if ([category isEqualToString:UIContentSizeCategoryExtraLarge]) {
    return xl / l;
  } else if ([category isEqualToString:UIContentSizeCategoryExtraExtraLarge]) {
    return xxl / l;
  } else if ([category isEqualToString:UIContentSizeCategoryExtraExtraExtraLarge]) {
    return xxxl / l;
  } else if ([category isEqualToString:UIContentSizeCategoryAccessibilityMedium]) {
    return ax1 / l;
  } else if ([category isEqualToString:UIContentSizeCategoryAccessibilityLarge]) {
    return ax2 / l;
  } else if ([category isEqualToString:UIContentSizeCategoryAccessibilityExtraLarge]) {
    return ax3 / l;
  } else if ([category isEqualToString:UIContentSizeCategoryAccessibilityExtraExtraLarge]) {
    return ax4 / l;
  } else if ([category isEqualToString:UIContentSizeCategoryAccessibilityExtraExtraExtraLarge]) {
    return ax5 / l;
  } else {
    return 1.0;
  }
#endif
}

◆ textureFrameAvailable:

- (void) textureFrameAvailable: (int64_t) textureId

implementation

Notifies Flutter that the content of the previously registered texture has been updated.

This will trigger a call to -[FlutterTexture copyPixelBuffer] on the raster thread.

Reimplemented from <FlutterTextureRegistry>.

Definition at line 1112 of file FlutterViewController.mm.

                             :(int64_t)textureId {
  [_engine.get().textureRegistry textureFrameAvailable:textureId];
}

◆ touchesBegan:withEvent:

- (void) touchesBegan:	(NSSet *)	touches
withEvent:	(UIEvent *)	event

implementation

See -[UIResponder touchesBegan:withEvent:]

Reimplemented from <FlutterViewResponder>.

Definition at line 1112 of file FlutterViewController.mm.

                    :(NSSet*)touches withEvent:(UIEvent*)event {
  [self dispatchTouches:touches pointerDataChangeOverride:nullptr event:event];
}

◆ touchesBeganWithEvent:

- (void) touchesBeganWithEvent: (NSEvent*) event

implementation

Definition at line 891 of file FlutterViewController.mm.

                             :(NSEvent*)event {
  NSTouch* touch = event.allTouches.anyObject;
  if (touch != nil) {
    if ((event.timestamp - _mouseState.last_scroll_momentum_changed_time) <
        kTrackpadTouchInertiaCancelWindowMs) {
      // The trackpad has been touched following a scroll momentum event.
      // A scroll inertia cancel message should be sent to the framework.
      NSPoint locationInView = [self.flutterView convertPoint:event.locationInWindow fromView:nil];
      NSPoint locationInBackingCoordinates =
          [self.flutterView convertPointToBacking:locationInView];
      FlutterPointerEvent flutterEvent = {
          .struct_size = sizeof(flutterEvent),
          .timestamp = static_cast<size_t>(event.timestamp * USEC_PER_SEC),
          .x = locationInBackingCoordinates.x,
          .y = -locationInBackingCoordinates.y,  // convertPointToBacking makes this negative.
          .device = kPointerPanZoomDeviceId,
          .signal_kind = kFlutterPointerSignalKindScrollInertiaCancel,
          .device_kind = kFlutterPointerDeviceKindTrackpad,
          .view_id = static_cast<FlutterViewIdentifier>(_viewIdentifier),
      };
 
      [_engine sendPointerEvent:flutterEvent];
      // Ensure no further scroll inertia cancel event will be sent.
      _mouseState.last_scroll_momentum_changed_time = 0;
    }
  }
}

◆ touchesCancelled:withEvent:

- (void) touchesCancelled:	(NSSet *)	touches
withEvent:	(UIEvent *)	event

implementation

See -[UIResponder touchesCancelled:withEvent:]

Reimplemented from <FlutterViewResponder>.

Definition at line 1112 of file FlutterViewController.mm.

                        :(NSSet*)touches withEvent:(UIEvent*)event {
  [self dispatchTouches:touches pointerDataChangeOverride:nullptr event:event];
}

◆ touchesEnded:withEvent:

- (void) touchesEnded:	(NSSet *)	touches
withEvent:	(UIEvent *)	event

implementation

See -[UIResponder touchesEnded:withEvent:]

Reimplemented from <FlutterViewResponder>.

Definition at line 1112 of file FlutterViewController.mm.

                    :(NSSet*)touches withEvent:(UIEvent*)event {
  [self dispatchTouches:touches pointerDataChangeOverride:nullptr event:event];
}

◆ touchesMoved:withEvent:

- (void) touchesMoved:	(NSSet *)	touches
withEvent:	(UIEvent *)	event

implementation

See -[UIResponder touchesMoved:withEvent:]

Reimplemented from <FlutterViewResponder>.

Definition at line 1112 of file FlutterViewController.mm.

                    :(NSSet*)touches withEvent:(UIEvent*)event {
  [self dispatchTouches:touches pointerDataChangeOverride:nullptr event:event];
}

◆ traitCollectionDidChange:

- (void) traitCollectionDidChange: (UITraitCollection*) previousTraitCollection

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                :(UITraitCollection*)previousTraitCollection {
  [super traitCollectionDidChange:previousTraitCollection];
  [self onUserSettingsChanged:nil];
}

◆ triggerTouchRateCorrectionIfNeeded:

- (void) triggerTouchRateCorrectionIfNeeded: (NSSet*) touches

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                          :(NSSet*)touches {
  if (_touchRateCorrectionVSyncClient == nil) {
    // If the _touchRateCorrectionVSyncClient is not created, means current devices doesn't
    // need to correct the touch rate. So just return.
    return;
  }
 
  // As long as there is a touch's phase is UITouchPhaseBegan or UITouchPhaseMoved,
  // activate the correction. Otherwise pause the correction.
  BOOL isUserInteracting = NO;
  for (UITouch* touch in touches) {
    if (touch.phase == UITouchPhaseBegan || touch.phase == UITouchPhaseMoved) {
      isUserInteracting = YES;
      break;
    }
  }
 
  if (isUserInteracting && [_engine.get() viewController] == self) {
    [_touchRateCorrectionVSyncClient await];
  } else {
    [_touchRateCorrectionVSyncClient pause];
  }
}

◆ unregisterTexture:

- (void) unregisterTexture: (int64_t) textureId

implementation

Unregisters a FlutterTexture that has previously regeistered with registerTexture:. Textures must be unregistered on the platform thread.

Parameters

textureId The result that was previously returned from registerTexture:.

Reimplemented from <FlutterTextureRegistry>.

Definition at line 1112 of file FlutterViewController.mm.

                         :(int64_t)textureId {
  [_engine.get().textureRegistry unregisterTexture:textureId];
}

◆ updateSemantics:

- (void) updateSemantics: (const FlutterSemanticsUpdate2*) update

implementation

Definition at line 338 of file FlutterViewController.mm.

                       :(const FlutterSemanticsUpdate2*)update {
  NSAssert(_engine.semanticsEnabled, @"Semantics must be enabled.");
  if (!_engine.semanticsEnabled) {
    return;
  }
  for (size_t i = 0; i < update->node_count; i++) {
    const FlutterSemanticsNode2* node = update->nodes[i];
    _bridge->AddFlutterSemanticsNodeUpdate(*node);
  }
 
  for (size_t i = 0; i < update->custom_action_count; i++) {
    const FlutterSemanticsCustomAction2* action = update->custom_actions[i];
    _bridge->AddFlutterSemanticsCustomActionUpdate(*action);
  }
 
  _bridge->CommitUpdates();
 
  // Accessibility tree can only be used when the view is loaded.
  if (!self.viewLoaded) {
    return;
  }
  // Attaches the accessibility root to the flutter view.
  auto root = _bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  if (root) {
    if ([self.flutterView.accessibilityChildren count] == 0) {
      NSAccessibilityElement* native_root = root->GetNativeViewAccessible();
      self.flutterView.accessibilityChildren = @[ native_root ];
    }
  } else {
    self.flutterView.accessibilityChildren = nil;
  }
}

◆ updateViewportMetricsIfNeeded

- (void) updateViewportMetricsIfNeeded

implementation

Provided by category FlutterViewController(Tests).

Definition at line 1112 of file FlutterViewController.mm.

                                      {
  if (_shouldIgnoreViewportMetricsUpdatesDuringRotation) {
    return;
  }
  if ([_engine.get() viewController] == self) {
    [_engine.get() updateViewportMetrics:_viewportMetrics];
  }
}

◆ valuePublishedByPlugin:

- (NSObject *) valuePublishedByPlugin: (NSString *) pluginKey

implementation

Returns a value published by the specified plugin.

Parameters

pluginKey The unique key identifying the plugin.

Returns: An object published by the plugin, if any. Will be NSNull if nothing has been published. Will be nil if the plugin has not been registered.

Reimplemented from <FlutterPluginRegistry>.

Definition at line 1112 of file FlutterViewController.mm.

                                   :(NSString*)pluginKey {
  return [_engine.get() valuePublishedByPlugin:pluginKey];
}

◆ viewDidAppear:

- (void) viewDidAppear: (BOOL) animated

implementation

Definition at line 527 of file FlutterViewController.mm.

                     :(BOOL)animated {
  TRACE_EVENT0("flutter", "viewDidAppear");
  if ([_engine.get() viewController] == self) {
    [self onUserSettingsChanged:nil];
    [self onAccessibilityStatusChanged:nil];
    BOOL stateIsActive = YES;
#if APPLICATION_EXTENSION_API_ONLY
    if (@available(iOS 13.0, *)) {
      stateIsActive = self.flutterWindowSceneIfViewLoaded.activationState ==
                      UISceneActivationStateForegroundActive;
    }
#else
    stateIsActive = UIApplication.sharedApplication.applicationState == UIApplicationStateActive;
#endif
    if (stateIsActive) {
      [[_engine.get() lifecycleChannel] sendMessage:@"AppLifecycleState.resumed"];
    }
  }
  [super viewDidAppear:animated];
}

◆ viewDidDisappear:

- (void) viewDidDisappear: (BOOL) animated

implementation

Definition at line 527 of file FlutterViewController.mm.

                        :(BOOL)animated {
  TRACE_EVENT0("flutter", "viewDidDisappear");
  if ([_engine.get() viewController] == self) {
    [self invalidateKeyboardAnimationVSyncClient];
    [self ensureViewportMetricsIsCorrect];
    [self surfaceUpdated:NO];
    [[_engine.get() lifecycleChannel] sendMessage:@"AppLifecycleState.paused"];
    [self flushOngoingTouches];
    [_engine.get() notifyLowMemory];
  }
 
  [super viewDidDisappear:animated];
}

◆ viewDidLayoutSubviews

- (void) viewDidLayoutSubviews

implementation

Definition at line 1112 of file FlutterViewController.mm.

                              {
  CGRect viewBounds = self.view.bounds;
  CGFloat scale = [self flutterScreenIfViewLoaded].scale;
 
  // Purposefully place this not visible.
  _scrollView.get().frame = CGRectMake(0.0, 0.0, viewBounds.size.width, 0.0);
  _scrollView.get().contentOffset = CGPointMake(kScrollViewContentSize, kScrollViewContentSize);
 
  // First time since creation that the dimensions of its view is known.
  bool firstViewBoundsUpdate = !_viewportMetrics.physical_width;
  _viewportMetrics.device_pixel_ratio = scale;
  [self setViewportMetricsSize];
  [self setViewportMetricsPaddings];
  [self updateViewportMetricsIfNeeded];
 
  // There is no guarantee that UIKit will layout subviews when the application/scene is active.
  // Creating the surface when inactive will cause GPU accesses from the background. Only wait for
  // the first frame to render when the application/scene is actually active.
  bool applicationOrSceneIsActive = YES;
#if APPLICATION_EXTENSION_API_ONLY
  if (@available(iOS 13.0, *)) {
    applicationOrSceneIsActive = self.flutterWindowSceneIfViewLoaded.activationState ==
                                 UISceneActivationStateForegroundActive;
  }
#else
  applicationOrSceneIsActive =
      [UIApplication sharedApplication].applicationState == UIApplicationStateActive;
#endif
 
  // This must run after updateViewportMetrics so that the surface creation tasks are queued after
  // the viewport metrics update tasks.
  if (firstViewBoundsUpdate && applicationOrSceneIsActive && _engine) {
    [self surfaceUpdated:YES];
 
    flutter::Shell& shell = [_engine.get() shell];
    fml::TimeDelta waitTime =
#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
        fml::TimeDelta::FromMilliseconds(200);
#else
        fml::TimeDelta::FromMilliseconds(100);
#endif
    if (shell.WaitForFirstFrame(waitTime).code() == fml::StatusCode::kDeadlineExceeded) {
      FML_LOG(INFO) << "Timeout waiting for the first frame to render.  This may happen in "
                    << "unoptimized builds.  If this is a release build, you should load a less "
                    << "complex frame to avoid the timeout.";
    }
  }
}

◆ viewDidLoad

- (void) viewDidLoad

implementation

Definition at line 527 of file FlutterViewController.mm.

                    {
  TRACE_EVENT0("flutter", "viewDidLoad");
 
  if (_engine && _engineNeedsLaunch) {
    [_engine.get() launchEngine:nil libraryURI:nil entrypointArgs:nil];
    [_engine.get() setViewController:self];
    _engineNeedsLaunch = NO;
  } else if ([_engine.get() viewController] == self) {
    [_engine.get() attachView];
  }
 
  // Register internal plugins.
  [self addInternalPlugins];
 
  // Create a vsync client to correct delivery frame rate of touch events if needed.
  [self createTouchRateCorrectionVSyncClientIfNeeded];
 
  if (@available(iOS 13.4, *)) {
    _hoverGestureRecognizer =
        [[UIHoverGestureRecognizer alloc] initWithTarget:self action:@selector(hoverEvent:)];
    _hoverGestureRecognizer.delegate = self;
    [_flutterView.get() addGestureRecognizer:_hoverGestureRecognizer];
 
    _discreteScrollingPanGestureRecognizer =
        [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(discreteScrollEvent:)];
    _discreteScrollingPanGestureRecognizer.allowedScrollTypesMask = UIScrollTypeMaskDiscrete;
    // Disallowing all touch types. If touch events are allowed here, touches to the screen will be
    // consumed by the UIGestureRecognizer instead of being passed through to flutter via
    // touchesBegan. Trackpad and mouse scrolls are sent by the platform as scroll events rather
    // than touch events, so they will still be received.
    _discreteScrollingPanGestureRecognizer.allowedTouchTypes = @[];
    _discreteScrollingPanGestureRecognizer.delegate = self;
    [_flutterView.get() addGestureRecognizer:_discreteScrollingPanGestureRecognizer];
    _continuousScrollingPanGestureRecognizer =
        [[UIPanGestureRecognizer alloc] initWithTarget:self
                                                action:@selector(continuousScrollEvent:)];
    _continuousScrollingPanGestureRecognizer.allowedScrollTypesMask = UIScrollTypeMaskContinuous;
    _continuousScrollingPanGestureRecognizer.allowedTouchTypes = @[];
    _continuousScrollingPanGestureRecognizer.delegate = self;
    [_flutterView.get() addGestureRecognizer:_continuousScrollingPanGestureRecognizer];
    _pinchGestureRecognizer =
        [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(pinchEvent:)];
    _pinchGestureRecognizer.allowedTouchTypes = @[];
    _pinchGestureRecognizer.delegate = self;
    [_flutterView.get() addGestureRecognizer:_pinchGestureRecognizer];
    _rotationGestureRecognizer = [[UIRotationGestureRecognizer alloc] init];
    _rotationGestureRecognizer.allowedTouchTypes = @[];
    _rotationGestureRecognizer.delegate = self;
    [_flutterView.get() addGestureRecognizer:_rotationGestureRecognizer];
  }
 
  [super viewDidLoad];
}

◆ viewDidReshape:

- (void) viewDidReshape: (NSView*) view

implementation

Responds to view reshape by notifying the engine of the change in dimensions.

Definition at line 338 of file FlutterViewController.mm.

                      :(NSView*)view {
  FML_DCHECK(view == _flutterView);
  [_engine updateWindowMetricsForViewController:self];
}

◆ viewSafeAreaInsetsDidChange

- (void) viewSafeAreaInsetsDidChange

implementation

Definition at line 1112 of file FlutterViewController.mm.

                                    {
  [self setViewportMetricsPaddings];
  [self updateViewportMetricsIfNeeded];
  [super viewSafeAreaInsetsDidChange];
}

◆ viewShouldAcceptFirstResponder:

- (BOOL) viewShouldAcceptFirstResponder: (NSView*) view

implementation

Definition at line 338 of file FlutterViewController.mm.

                                      :(NSView*)view {
  FML_DCHECK(view == _flutterView);
  // Only allow FlutterView to become first responder if TextInputPlugin is
  // not active. Otherwise a mouse event inside FlutterView would cause the
  // TextInputPlugin to lose first responder status.
  return !_textInputPlugin.isFirstResponder;
}

◆ viewWillAppear

- (void) viewWillAppear

implementation

Definition at line 338 of file FlutterViewController.mm.

                       {
  [super viewWillAppear];
  if (!_engine.running) {
    [self launchEngine];
  }
  [self listenForMetaModifiedKeyUpEvents];
}

◆ viewWillAppear:

- (void) viewWillAppear: (BOOL) animated

implementation

Definition at line 527 of file FlutterViewController.mm.

                      :(BOOL)animated {
  TRACE_EVENT0("flutter", "viewWillAppear");
  if ([_engine.get() viewController] == self) {
    // Send platform settings to Flutter, e.g., platform brightness.
    [self onUserSettingsChanged:nil];
 
    // Only recreate surface on subsequent appearances when viewport metrics are known.
    // First time surface creation is done on viewDidLayoutSubviews.
    if (_viewportMetrics.physical_width) {
      [self surfaceUpdated:YES];
    }
    [[_engine.get() lifecycleChannel] sendMessage:@"AppLifecycleState.inactive"];
    [[_engine.get() restorationPlugin] markRestorationComplete];
  }
 
  [super viewWillAppear:animated];
}

◆ viewWillDisappear

- (void) viewWillDisappear

implementation

Definition at line 338 of file FlutterViewController.mm.

                          {
  // Per Apple's documentation, it is discouraged to call removeMonitor: in dealloc, and it's
  // recommended to be called earlier in the lifecycle.
  [NSEvent removeMonitor:_keyUpMonitor];
  _keyUpMonitor = nil;
}

◆ viewWillDisappear:

- (void) viewWillDisappear: (BOOL) animated

implementation

Definition at line 527 of file FlutterViewController.mm.

                         :(BOOL)animated {
  TRACE_EVENT0("flutter", "viewWillDisappear");
  if ([_engine.get() viewController] == self) {
    [[_engine.get() lifecycleChannel] sendMessage:@"AppLifecycleState.inactive"];
  }
  [super viewWillDisappear:animated];
}

◆ viewWillTransitionToSize:withTransitionCoordinator:

- (void) viewWillTransitionToSize:	(CGSize)	size
withTransitionCoordinator:	(id<UIViewControllerTransitionCoordinator>)	coordinator

implementation

Definition at line 527 of file FlutterViewController.mm.

                                :(CGSize)size
       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
  [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
 
  // We delay the viewport metrics update for half of rotation transition duration, to address
  // a bug with distorted aspect ratio.
  // See: https://github.com/flutter/flutter/issues/16322
  //
  // This approach does not fully resolve all distortion problem. But instead, it reduces the
  // rotation distortion roughly from 4x to 2x. The most distorted frames occur in the middle
  // of the transition when it is rotating the fastest, making it hard to notice.
 
  NSTimeInterval transitionDuration = coordinator.transitionDuration;
  // Do not delay viewport metrics update if zero transition duration.
  if (transitionDuration == 0) {
    return;
  }
 
  _shouldIgnoreViewportMetricsUpdatesDuringRotation = YES;
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
                               static_cast<int64_t>(transitionDuration / 2.0 * NSEC_PER_SEC)),
                 dispatch_get_main_queue(), ^{
                   // `viewWillTransitionToSize` is only called after the previous rotation is
                   // complete. So there won't be race condition for this flag.
                   _shouldIgnoreViewportMetricsUpdatesDuringRotation = NO;
                   [self updateViewportMetricsIfNeeded];
                 });
}

Property Documentation

◆ backgroundColor

- (NSColor*) backgroundColor

readwritenonatomiccopy

The contentView (FlutterView)'s background color is set to black during its instantiation.

The containing layer's color can be set to the NSColor provided to this method.

For example, the background may be set after the FlutterViewController is instantiated in MainFlutterWindow.swift in the Flutter project.

import Cocoa
import FlutterMacOS
 
class MainFlutterWindow: NSWindow {
  override func awakeFromNib() {
    let flutterViewController = FlutterViewController()
 
    // The background color of the window and `FlutterViewController`
    // are retained separately.
    //
    // In this example, both the MainFlutterWindow and FlutterViewController's
    // FlutterView's backgroundColor are set to clear to achieve a fully
    // transparent effect.
    //
    // If the window's background color is not set, it will use the system
    // default.
    //
    // If the `FlutterView`'s color is not set via `FlutterViewController.setBackgroundColor`
    // it's default will be black.
    self.backgroundColor = NSColor.clear
    flutterViewController.backgroundColor = NSColor.clear
 
    let windowFrame = self.frame
    self.contentViewController = flutterViewController
    self.setFrame(windowFrame, display: true)
 
    RegisterGeneratedPlugins(registry: flutterViewController)
 
    super.awakeFromNib()
  }
}

Definition at line 210 of file FlutterViewController.h.

◆ binaryMessenger

- (NSObject< FlutterBinaryMessenger > *) binaryMessenger

readnonatomicassign

The FlutterBinaryMessenger associated with this FlutterViewController (used for communicating with channels).

This is just a convenient way to get the |FlutterEngine|'s binary messenger.

Definition at line 243 of file FlutterViewController.h.

◆ displayingFlutterUI

- (BOOL) displayingFlutterUI

readnonatomicassign

True if at least one frame has rendered and the ViewController has appeared.

This property is reset to false when the ViewController disappears. It is guaranteed to only alternate between true and false for observers.

Definition at line 197 of file FlutterViewController.h.

◆ engine

- (FlutterEngine *) engine

readnonatomicassign

The FlutterEngine instance for this view controller. This could be the engine this FlutterViewController is initialized with or a new FlutterEngine implicitly created if no engine was supplied during initialization.

The Flutter engine associated with this view controller.

Definition at line 235 of file FlutterViewController.h.

◆ engineAllowHeadlessExecution

- (BOOL) engineAllowHeadlessExecution

readnonatomicassign

If the FlutterViewController creates a FlutterEngine, this property determines if that FlutterEngine has allowHeadlessExecution set.

The intention is that this is used with the XIB. Otherwise, a FlutterEngine can just be sent to the init methods.

See also: -[FlutterEngine initWithName:project:allowHeadlessExecution:]

Definition at line 254 of file FlutterViewController.h.

◆ flutterView

- (FlutterView*) flutterView

readnonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 20 of file FlutterViewController_Internal.h.

◆ isHomeIndicatorHidden

- (BOOL) isHomeIndicatorHidden

readwritenonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 68 of file FlutterViewController.mm.

◆ isKeyboardInOrTransitioningFromBackground

- (BOOL) isKeyboardInOrTransitioningFromBackground

readwritenonatomicassignimplementation

Provided by category FlutterViewController(Tests).

Definition at line 84 of file FlutterViewController.mm.

◆ isPresentingViewControllerAnimating

- (BOOL) isPresentingViewControllerAnimating

readwritenonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 69 of file FlutterViewController.mm.

◆ isVoiceOverRunning

- (BOOL) isVoiceOverRunning

readnonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 48 of file FlutterViewController_Internal.h.

◆ keyboardAnimationIsShowing

- (BOOL) keyboardAnimationIsShowing

readwritenonatomicassignimplementation

Provided by category FlutterViewController(Tests).

Definition at line 82 of file FlutterViewController.mm.

◆ keyboardAnimationStartTime

- (TimePoint FlutterViewController()):

readwritenonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 83 of file FlutterViewController.mm.

◆ keyboardAnimationVSyncClient

- (VSyncClient*) keyboardAnimationVSyncClient

readwritenonatomicretainimplementation

Provided by category FlutterViewController(Tests).

Definition at line 81 of file FlutterViewController.mm.

◆ keyboardLayoutData

- (NSData*) keyboardLayoutData

readwritenonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 189 of file FlutterViewController.mm.

◆ keyboardLayoutNotifier

- (KeyboardLayoutNotifier) keyboardLayoutNotifier

readwritenonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 187 of file FlutterViewController.mm.

◆ keyboardManager

- (FlutterKeyboardManager*) keyboardManager

readwritenonatomicassignimplementation

Pointer to a keyboard manager, a hub that manages how key events are dispatched to various Flutter key responders, and whether the event is propagated to the next NSResponder.

Provided by category FlutterViewController().

Definition at line 49 of file FlutterViewController_Internal.h.

◆ keyUpMonitor

- (id) keyUpMonitor

readwritenonatomicassignimplementation

Event monitor for keyUp events.

Provided by category FlutterViewController().

Definition at line 178 of file FlutterViewController.mm.

◆ mouseState

- (MouseState) mouseState

readwritenonatomicassignimplementation

The current state of the mouse and the sent mouse events.

Provided by category FlutterViewController().

Definition at line 173 of file FlutterViewController.mm.

◆ mouseTrackingMode

- (FlutterMouseTrackingMode) mouseTrackingMode

readwritenonatomicassign

The style of mouse tracking to use for the view. Defaults to FlutterMouseTrackingModeInKeyWindow.

Definition at line 84 of file FlutterViewController.h.

◆ originalViewInsetBottom

- (CGFloat) originalViewInsetBottom

readwritenonatomicassignimplementation

Provided by category FlutterViewController().

Definition at line 80 of file FlutterViewController.mm.

◆ shouldIgnoreViewportMetricsUpdatesDuringRotation

- (BOOL) shouldIgnoreViewportMetricsUpdatesDuringRotation

readwritenonatomicassignimplementation

Whether we should ignore viewport metrics updates during rotation transition.

Provided by category FlutterViewController().

Definition at line 74 of file FlutterViewController.mm.

◆ splashScreenView

- (UIView *) splashScreenView

readwritenonatomicstrong

Specifies the view to use as a splash screen. Flutter's rendering is asynchronous, so the first frame rendered by the Flutter application might not immediately appear when the Flutter view is initially placed in the view hierarchy. The splash screen view will be used as a replacement until the first frame is rendered.

The view used should be appropriate for multiple sizes; an autoresizing mask to have a flexible width and height will be applied automatically.

Set to nil to remove the splash screen view.

Definition at line 210 of file FlutterViewController.h.

◆ targetViewInsetBottom

- (CGFloat) targetViewInsetBottom

readwritenonatomicassignimplementation

Keyboard animation properties

Provided by category FlutterViewController(Tests).

Definition at line 79 of file FlutterViewController.mm.

◆ textInputPlugin

- (FlutterTextInputPlugin*) textInputPlugin

readnonatomicassignimplementation

The text input plugin that handles text editing state for text fields.

Provided by category FlutterViewController().

Definition at line 25 of file FlutterViewController_Internal.h.

◆ touchRateCorrectionVSyncClient

- (VSyncClient*) touchRateCorrectionVSyncClient

readwritenonatomicretainimplementation

VSyncClient for touch events delivery frame rate correction.

On promotion devices(eg: iPhone13 Pro), the delivery frame rate of touch events is 60HZ but the frame rate of rendering is 120HZ, which is different and will leads jitter and laggy. With this VSyncClient, it can correct the delivery frame rate of touch events to let it keep the same with frame rate of rendering.

Provided by category FlutterViewController(Tests).

Definition at line 92 of file FlutterViewController.mm.

◆ trackingArea

- (NSTrackingArea*) trackingArea

readwritenonatomicassignimplementation

The tracking area used to generate hover events, if enabled.

Provided by category FlutterViewController().

Definition at line 168 of file FlutterViewController.mm.

◆ viewIdentifier

- (FlutterViewIdentifier) viewIdentifier

readnonatomicassign

The identifier for this view controller, if it is attached.

The identifier is assigned when the view controller is attached to a FlutterEngine.

If the view controller is detached (see FlutterViewController#attached), reading this property throws an assertion.

Definition at line 130 of file FlutterViewController.h.

◆ viewOpaque

- (BOOL) viewOpaque

readwritenonatomicassign

Controls whether the created view will be opaque or not.

Default is YES. Note that setting this to NO may negatively impact performance when using hardware acceleration, and toggling this will trigger a re-layout of the view.

Definition at line 228 of file FlutterViewController.h.

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

shell/platform/darwin/ios/framework/Headers/FlutterViewController.h
shell/platform/darwin/macos/framework/Headers/FlutterViewController.h
shell/platform/darwin/ios/framework/Source/FlutterViewController.mm
shell/platform/darwin/macos/framework/Source/FlutterViewController.mm

Instance Methods

Class Methods

Properties

Detailed Description

Method Documentation

◆ acceptsFirstResponder

◆ accessibilityBridge

◆ accessibilityFlags

◆ accessibilityIsOnOffSwitchLabelsEnabled

◆ accessibilityPerformEscape

◆ addInternalPlugins

◆ API_AVAILABLE [1/5]

◆ API_AVAILABLE [2/5]

◆ API_AVAILABLE [3/5]

◆ API_AVAILABLE [4/5]

◆ API_AVAILABLE [5/5]

◆ applicationBecameActive:

◆ applicationDidEnterBackground:

◆ applicationWillEnterForeground:

◆ applicationWillResignActive:

◆ applicationWillTerminate:

◆ appOrSceneBecameActive

◆ appOrSceneDidEnterBackground

◆ appOrSceneWillEnterForeground

◆ appOrSceneWillResignActive

◆ appOrSceneWillTerminate

◆ attached

◆ automaticallyNotifiesObserversOfDisplayingFlutterUI

◆ awakeFromNib

◆ brightnessMode

◆ calculateKeyboardAttachMode:

◆ calculateKeyboardInset:keyboardMode:

◆ calculateMultitaskingAdjustment:keyboardFrame:

◆ callViewRenderedCallback

◆ cleanUpConnection:

◆ CommonInit

◆ configureTrackingArea

◆ continuousScrollEvent:

◆ contrastMode

◆ createAccessibilityBridgeWithEngine:

◆ createFlutterViewWithMTLDevice:commandQueue:

◆ createTouchRateCorrectionVSyncClientIfNeeded

◆ CurrentKeyboardLayoutData

◆ dealloc

◆ decodeRestorableStateWithCoder:

◆ deregisterNotifications

◆ detachFromEngine

◆ DeviceKindFromTouchType

◆ discreteScrollEvent:

◆ dispatchGestureEvent:

◆ dispatchMouseEvent:

◆ dispatchMouseEvent:phase:

◆ dispatchTouches:pointerDataChangeOverride:event:

◆ encodeRestorableStateWithCoder:

◆ ensureViewportMetricsIsCorrect

◆ flagsChanged:

◆ flushOngoingTouches

◆ forceTouchesCancelled:

◆ generatePointerDataForFake

◆ gestureRecognizer:shouldReceiveEvent:

◆ gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:

◆ getBinaryMessenger

◆ getPressedState

◆ GetViewOrPlaceholder

◆ getWeakNSObject

◆ goToApplicationLifecycle:

◆ handleKeyboardNotification:

◆ handlePressEvent:nextAction:

◆ hasPlugin:

◆ hoverEvent:

◆ init

◆ initializeKeyboard

◆ initWithCoder: [1/2]

◆ initWithCoder: [2/2]

◆ initWithEngine:nibName:bundle: [1/2]

◆ initWithEngine:nibName:bundle: [2/2]

◆ initWithNibName:bundle: [1/2]

◆ initWithNibName:bundle: [2/2]

◆ initWithProject:

◆ initWithProject:initialRoute:nibName:bundle: [1/2]