FlutterViewController(Tests) Category Reference

Instance Methods
(void)	- createTouchRateCorrectionVSyncClientIfNeeded
(void)	- surfaceUpdated:
(void)	- performOrientationUpdate:
(void)	- handlePressEvent:nextAction:
(void)	- discreteScrollEvent:
(void)	- updateViewportMetricsIfNeeded
(void)	- onUserSettingsChanged:
(void)	- applicationWillTerminate:
(void)	- goToApplicationLifecycle:
(void)	- handleKeyboardNotification:
(CGFloat)	- calculateKeyboardInset:keyboardMode:
(BOOL)	- shouldIgnoreKeyboardNotification:
(FlutterKeyboardMode)	- calculateKeyboardAttachMode:
(CGFloat)	- calculateMultitaskingAdjustment:keyboardFrame:
(void)	- startKeyBoardAnimation:
(UIView *)	- keyboardAnimationView
(SpringAnimation *)	- keyboardSpringAnimation
(void)	- setUpKeyboardSpringAnimationIfNeeded:
(void)	- setUpKeyboardAnimationVsyncClient:
(void)	- ensureViewportMetricsIsCorrect
(void)	- invalidateKeyboardAnimationVSyncClient
(void)	- addInternalPlugins
(flutter::PointerData)	- generatePointerDataForFake
(void)	- sharedSetupWithProject:initialRoute:
(void)	- applicationBecameActive:
(void)	- applicationWillResignActive:
(void)	- applicationWillTerminate:
(void)	- applicationDidEnterBackground:
(void)	- applicationWillEnterForeground:
(void)	- sceneBecameActive:
(void)	- sceneWillResignActive:
(void)	- sceneWillDisconnect:
(void)	- sceneDidEnterBackground:
(void)	- sceneWillEnterForeground:
(void)	- triggerTouchRateCorrectionIfNeeded:

Properties
double	targetViewInsetBottom
BOOL	isKeyboardInOrTransitioningFromBackground
BOOL	keyboardAnimationIsShowing
VSyncClient *	keyboardAnimationVSyncClient
VSyncClient *	touchRateCorrectionVSyncClient

Detailed Description

Definition at line 121 of file FlutterViewControllerTest.mm.

Method Documentation

addInternalPlugins

- (void) addInternalPlugins

Creates and registers plugins used by this view controller.

Extends class FlutterViewController.

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

applicationBecameActive:

- (void) applicationBecameActive:

(NSNotification *)

notification

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

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

applicationDidEnterBackground:

- (void) applicationDidEnterBackground:

(NSNotification *)

notification

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

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

applicationWillEnterForeground:

- (void) applicationWillEnterForeground:

(NSNotification *)

notification

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

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

applicationWillResignActive:

- (void) applicationWillResignActive:

(NSNotification *)

notification

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

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

applicationWillTerminate: [1/2]

- (void) applicationWillTerminate:

(NSNotification *)

notification

applicationWillTerminate: [2/2]

- (void) applicationWillTerminate:

(NSNotification *)

notification

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

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

calculateKeyboardAttachMode:

- (FlutterKeyboardMode) calculateKeyboardAttachMode:

(NSNotification *)

notification

Extends class FlutterViewController.

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:		(int)	keyboardMode

Extends class FlutterViewController.

calculateMultitaskingAdjustment:keyboardFrame:

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

Extends class FlutterViewController.

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

createTouchRateCorrectionVSyncClientIfNeeded

- (void) createTouchRateCorrectionVSyncClientIfNeeded

Extends class FlutterViewController.

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

discreteScrollEvent:

- (void) discreteScrollEvent:

(UIPanGestureRecognizer *)

recognizer

Extends class FlutterViewController.

ensureViewportMetricsIsCorrect

- (void) ensureViewportMetricsIsCorrect

Extends class FlutterViewController.

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

generatePointerDataForFake

- (PointerData FlutterViewController(Tests)):

Extends class FlutterViewController.

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

goToApplicationLifecycle:

- (void) goToApplicationLifecycle:

(nonnull NSString *)

state

Extends class FlutterViewController.

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

Extends class FlutterViewController.

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

Extends class FlutterViewController.

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

invalidateKeyboardAnimationVSyncClient

- (void) invalidateKeyboardAnimationVSyncClient

Extends class FlutterViewController.

Definition at line 1112 of file FlutterViewController.mm.

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

keyboardAnimationView

- (UIView *) keyboardAnimationView

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

                                 {
  return _keyboardAnimationView.get();
}

keyboardSpringAnimation

- (SpringAnimation *) keyboardSpringAnimation

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

                                            {
  return _keyboardSpringAnimation.get();
}

onUserSettingsChanged:

- (void) onUserSettingsChanged:

(NSNotification *)

notification

Extends class FlutterViewController.

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])
  }];
}

performOrientationUpdate:

- (void) performOrientationUpdate:

(UIInterfaceOrientationMask)

new_preferences

Extends class FlutterViewController.

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"];
        }
      }
    }
  }
}

sceneBecameActive:

- (void) sceneBecameActive:

(ios(13.0))

API_AVAILABLE

Extends class FlutterViewController.

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

Extends class FlutterViewController.

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

Extends class FlutterViewController.

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

Extends class FlutterViewController.

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

Extends class FlutterViewController.

Definition at line 527 of file FlutterViewController.mm.

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

setUpKeyboardAnimationVsyncClient:

- (void) setUpKeyboardAnimationVsyncClient:

(FlutterKeyboardAnimationCallback)

keyboardAnimationCallback

Extends class FlutterViewController.

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

Extends class FlutterViewController.

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]);
}

sharedSetupWithProject:initialRoute:

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

Extends class FlutterViewController.

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

shouldIgnoreKeyboardNotification:

- (BOOL) shouldIgnoreKeyboardNotification:

(NSNotification *)

notification

Extends class FlutterViewController.

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

startKeyBoardAnimation:

- (void) startKeyBoardAnimation:

(NSTimeInterval)

duration

Extends class FlutterViewController.

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

surfaceUpdated:

- (void) surfaceUpdated:

(BOOL)

appeared

Extends class FlutterViewController.

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

triggerTouchRateCorrectionIfNeeded:

- (void) triggerTouchRateCorrectionIfNeeded:

(NSSet *)

touches

Extends class FlutterViewController.

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

updateViewportMetricsIfNeeded

- (void) updateViewportMetricsIfNeeded

Extends class FlutterViewController.

Definition at line 1112 of file FlutterViewController.mm.

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

Property Documentation

isKeyboardInOrTransitioningFromBackground

- (BOOL) isKeyboardInOrTransitioningFromBackground

readwritenonatomicassign

Extends class FlutterViewController.

Definition at line 124 of file FlutterViewControllerTest.mm.

keyboardAnimationIsShowing

- (BOOL) keyboardAnimationIsShowing

readwritenonatomicassign

Extends class FlutterViewController.

Definition at line 125 of file FlutterViewControllerTest.mm.

keyboardAnimationVSyncClient

- (VSyncClient*) keyboardAnimationVSyncClient

readwritenonatomicstrong

Extends class FlutterViewController.

Definition at line 126 of file FlutterViewControllerTest.mm.

targetViewInsetBottom

- (double) targetViewInsetBottom

readwritenonatomicassign

Extends class FlutterViewController.

Definition at line 123 of file FlutterViewControllerTest.mm.

touchRateCorrectionVSyncClient

- (VSyncClient*) touchRateCorrectionVSyncClient

readwritenonatomicstrong

Extends class FlutterViewController.

Definition at line 127 of file FlutterViewControllerTest.mm.

---

The documentation for this category was generated from the following file:

• shell/platform/darwin/ios/framework/Source/FlutterViewControllerTest.mm