io.flutter.embedding.android.FlutterView Class Reference

Inheritance diagram for io.flutter.embedding.android.FlutterView:

Public Member Functions
	FlutterView (@NonNull Context context)
	FlutterView (@NonNull Context context, @NonNull RenderMode renderMode)
	FlutterView (@NonNull Context context, @NonNull TransparencyMode transparencyMode)
	FlutterView (@NonNull Context context, @NonNull FlutterSurfaceView flutterSurfaceView)
	FlutterView (@NonNull Context context, @NonNull FlutterTextureView flutterTextureView)
	FlutterView (@NonNull Context context, @NonNull FlutterImageView flutterImageView)
	FlutterView (@NonNull Context context, @Nullable AttributeSet attrs)
	FlutterView ( @NonNull Context context, @NonNull RenderMode renderMode, @NonNull TransparencyMode transparencyMode)
boolean	hasRenderedFirstFrame ()
void	addOnFirstFrameRenderedListener (@NonNull FlutterUiDisplayListener listener)
void	removeOnFirstFrameRenderedListener (@NonNull FlutterUiDisplayListener listener)
final WindowInsets	onApplyWindowInsets (@NonNull WindowInsets insets)
InputConnection	onCreateInputConnection (@NonNull EditorInfo outAttrs)
boolean	checkInputConnectionProxy (View view)
boolean	dispatchKeyEvent (@NonNull KeyEvent event)
boolean	onTouchEvent (@NonNull MotionEvent event)
boolean	onGenericMotionEvent (@NonNull MotionEvent event)
boolean	onHoverEvent (@NonNull MotionEvent event)
AccessibilityNodeProvider	getAccessibilityNodeProvider ()
View	findViewByAccessibilityIdTraversal (int accessibilityId)
PointerIcon	getSystemPointerIcon (int type)
BinaryMessenger	getBinaryMessenger ()
boolean	onTextInputKeyEvent (@NonNull KeyEvent keyEvent)
void	redispatch (@NonNull KeyEvent keyEvent)
void	attachToFlutterEngine (@NonNull FlutterEngine flutterEngine)
void	detachFromFlutterEngine ()
FlutterImageView	createImageView ()
FlutterImageView	getCurrentImageSurface ()
void	convertToImageView ()
void	revertImageView (@NonNull Runnable onDone)
void	attachOverlaySurfaceToRender (@NonNull FlutterImageView view)
boolean	acquireLatestImageViewFrame ()

Protected Member Functions
void	onConfigurationChanged (@NonNull Configuration newConfig)
void	onSizeChanged (int width, int height, int oldWidth, int oldHeight)
WindowInfoRepositoryCallbackAdapterWrapper	createWindowInfoRepo ()
void	onAttachedToWindow ()
void	onDetachedFromWindow ()
void	setWindowInfoListenerDisplayFeatures (WindowLayoutInfo layoutInfo)

Package Attributes
RenderSurface	renderSurface

Detailed Description

Displays a Flutter UI on an Android device.

A FlutterView's UI is painted by a corresponding io.flutter.embedding.engine.FlutterEngine.

A FlutterView can operate in 2 different io.flutter.embedding.android.RenderModes:

1. io.flutter.embedding.android.RenderMode#surface, which paints a Flutter UI to a android.view.SurfaceView. This mode has the best performance, but a
FlutterView in this mode cannot be positioned between 2 other Android Views in the z-index, nor can it be animated/transformed. Unless the special capabilities of a android.graphics.SurfaceTexture are required, developers should strongly prefer this render mode.
2. io.flutter.embedding.android.RenderMode#texture, which paints a Flutter UI to a android.graphics.SurfaceTexture. This mode is not as performant as io.flutter.embedding.android.RenderMode#surface, but a FlutterView in this mode can be animated and transformed, as well as positioned in the z-index between 2+ other Android Views. Unless the special capabilities of a android.graphics.SurfaceTexture are required, developers should strongly prefer the io.flutter.embedding.android.RenderMode#surface render mode.

See https://source.android.com/devices/graphics/arch-tv#surface_or_texture for more information comparing android.view.SurfaceView and android.view.TextureView.

Definition at line 107 of file FlutterView.java.

Constructor & Destructor Documentation

FlutterView() [1/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context )

inline

Constructs a FlutterView programmatically, without any XML attributes.

• A FlutterSurfaceView is used to render the Flutter UI.
• transparencyMode defaults to TransparencyMode#opaque.

FlutterView requires an Activity instead of a generic Context to be compatible with PlatformViewsController.

Definition at line 217 of file FlutterView.java.

                                               {
    this(context, null, new FlutterSurfaceView(context));
  }

FlutterView() [2/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @NonNull RenderMode  renderMode  )

inline

Deprecated - use FlutterView(Context, FlutterSurfaceView) or FlutterView(Context, FlutterTextureView) or FlutterView(Context, FlutterImageView) instead.

Definition at line 227 of file FlutterView.java.

                                                                               {
    super(context, null);
 
    if (renderMode == RenderMode.surface) {
      flutterSurfaceView = new FlutterSurfaceView(context);
      renderSurface = flutterSurfaceView;
    } else if (renderMode == RenderMode.texture) {
      flutterTextureView = new FlutterTextureView(context);
      renderSurface = flutterTextureView;
    } else {
      throw new IllegalArgumentException(
          "RenderMode not supported with this constructor: " + renderMode);
    }
 
    init();
  }

FlutterView() [3/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @NonNull TransparencyMode  transparencyMode  )

inline

Deprecated - use FlutterView(Context, FlutterSurfaceView) or FlutterView(Context, FlutterTextureView) instead, and configure the incoming
FlutterSurfaceView or FlutterTextureView for transparency as desired.

Constructs a FlutterView programmatically, without any XML attributes, uses a FlutterSurfaceView to render the Flutter UI, and allows selection of a
transparencyMode.

FlutterView requires an Activity instead of a generic Context to be compatible with PlatformViewsController.

Definition at line 257 of file FlutterView.java.

                                                                                           {
    this(
        context,
        null,
        new FlutterSurfaceView(context, transparencyMode == TransparencyMode.transparent));
  }

FlutterView() [4/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @NonNull FlutterSurfaceView  flutterSurfaceView  )

inline

Constructs a FlutterView programmatically, without any XML attributes, uses the given FlutterSurfaceView to render the Flutter UI, and allows selection of a
transparencyMode.

FlutterView requires an Activity instead of a generic Context to be compatible with PlatformViewsController.

Definition at line 272 of file FlutterView.java.

                                                                                               {
    this(context, null, flutterSurfaceView);
  }

FlutterView() [5/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @NonNull FlutterTextureView  flutterTextureView  )

inline

Constructs a FlutterView programmatically, without any XML attributes, uses the given FlutterTextureView to render the Flutter UI, and allows selection of a
transparencyMode.

FlutterView requires an Activity instead of a generic Context to be compatible with PlatformViewsController.

Definition at line 284 of file FlutterView.java.

                                                                                               {
    this(context, null, flutterTextureView);
  }

FlutterView() [6/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @NonNull FlutterImageView  flutterImageView  )

inline

Constructs a FlutterView programmatically, without any XML attributes, uses the given FlutterImageView to render the Flutter UI.

FlutterView requires an Activity instead of a generic Context to be compatible with PlatformViewsController.

Definition at line 295 of file FlutterView.java.

                                                                                           {
    this(context, null, flutterImageView);
  }

FlutterView() [7/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @Nullable AttributeSet  attrs  )

inline

Constructs a FlutterView in an XML-inflation-compliant manner.

FlutterView requires an Activity instead of a generic Context to be compatible with PlatformViewsController.

Definition at line 306 of file FlutterView.java.

                                                                             {
    this(context, attrs, new FlutterSurfaceView(context));
  }

FlutterView() [8/8]

io.flutter.embedding.android.FlutterView.FlutterView ( @NonNull Context  context, @NonNull RenderMode  renderMode, @NonNull TransparencyMode  transparencyMode  )

inline

Deprecated - use FlutterView(Context, FlutterSurfaceView) or FlutterView(Context, FlutterTextureView) instead, and configure the incoming
FlutterSurfaceView or FlutterTextureView for transparency as desired.

Definition at line 316 of file FlutterView.java.

                                                  {
    super(context, null);
 
    if (renderMode == RenderMode.surface) {
      flutterSurfaceView =
          new FlutterSurfaceView(context, transparencyMode == TransparencyMode.transparent);
      renderSurface = flutterSurfaceView;
    } else if (renderMode == RenderMode.texture) {
      flutterTextureView = new FlutterTextureView(context);
      renderSurface = flutterTextureView;
    } else {
      throw new IllegalArgumentException(
          "RenderMode not supported with this constructor: " + renderMode);
    }
 
    init();
  }

Member Function Documentation

acquireLatestImageViewFrame()

boolean io.flutter.embedding.android.FlutterView.acquireLatestImageViewFrame ( )

inline

Definition at line 1347 of file FlutterView.java.

                                               {
    if (flutterImageView != null) {
      return flutterImageView.acquireLatestImage();
    }
    return false;
  }

addOnFirstFrameRenderedListener()

void io.flutter.embedding.android.FlutterView.addOnFirstFrameRenderedListener ( @NonNull FlutterUiDisplayListener  listener )

inline

Adds the given listener to this FlutterView, to be notified upon Flutter's first rendered frame.

Definition at line 420 of file FlutterView.java.

                                                                                          {
    flutterUiDisplayListeners.add(listener);
  }

attachOverlaySurfaceToRender()

void io.flutter.embedding.android.FlutterView.attachOverlaySurfaceToRender ( @NonNull FlutterImageView  view )

inline

Definition at line 1341 of file FlutterView.java.

                                                                           {
    if (flutterEngine != null) {
      view.attachToRenderer(flutterEngine.getRenderer());
    }
  }

attachToFlutterEngine()

void io.flutter.embedding.android.FlutterView.attachToFlutterEngine ( @NonNull FlutterEngine  flutterEngine )

inline

Connects this FlutterView to the given io.flutter.embedding.engine.FlutterEngine.

This FlutterView will begin rendering the UI painted by the given FlutterEngine. This FlutterView will also begin forwarding interaction events from this FlutterView to the given io.flutter.embedding.engine.FlutterEngine, e.g., user touch events, accessibility events, keyboard events, and others.

See detachFromFlutterEngine() for information on how to detach from a FlutterEngine.

Definition at line 1076 of file FlutterView.java.

                                                                          {
    Log.v(TAG, "Attaching to a FlutterEngine: " + flutterEngine);
    if (isAttachedToFlutterEngine()) {
      if (flutterEngine == this.flutterEngine) {
        // We are already attached to this FlutterEngine
        Log.v(TAG, "Already attached to this engine. Doing nothing.");
        return;
      }
 
      // Detach from a previous FlutterEngine so we can attach to this new one.
      Log.v(
          TAG,
          "Currently attached to a different engine. Detaching and then attaching"
              + " to new engine.");
      detachFromFlutterEngine();
    }
 
    this.flutterEngine = flutterEngine;
 
    // Instruct our FlutterRenderer that we are now its designated RenderSurface.
    FlutterRenderer flutterRenderer = this.flutterEngine.getRenderer();
    isFlutterUiDisplayed = flutterRenderer.isDisplayingFlutterUi();
    renderSurface.attachToRenderer(flutterRenderer);
    flutterRenderer.addIsDisplayingFlutterUiListener(flutterUiDisplayListener);
 
    // Initialize various components that know how to process Android View I/O
    // in a way that Flutter understands.
    if (Build.VERSION.SDK_INT >= API_LEVELS.API_24) {
      mouseCursorPlugin = new MouseCursorPlugin(this, this.flutterEngine.getMouseCursorChannel());
    }
    textInputPlugin =
        new TextInputPlugin(
            this,
            this.flutterEngine.getTextInputChannel(),
            this.flutterEngine.getPlatformViewsController());
 
    try {
      textServicesManager =
          (TextServicesManager)
              getContext().getSystemService(Context.TEXT_SERVICES_MANAGER_SERVICE);
      spellCheckPlugin =
          new SpellCheckPlugin(textServicesManager, this.flutterEngine.getSpellCheckChannel());
    } catch (Exception e) {
      Log.e(TAG, "TextServicesManager not supported by device, spell check disabled.");
    }
 
    localizationPlugin = this.flutterEngine.getLocalizationPlugin();
 
    keyboardManager = new KeyboardManager(this);
    androidTouchProcessor =
        new AndroidTouchProcessor(this.flutterEngine.getRenderer(), /*trackMotionEvents=*/ false);
    accessibilityBridge =
        new AccessibilityBridge(
            this,
            flutterEngine.getAccessibilityChannel(),
            (AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE),
            getContext().getContentResolver(),
            this.flutterEngine.getPlatformViewsController());
    accessibilityBridge.setOnAccessibilityChangeListener(onAccessibilityChangeListener);
    resetWillNotDraw(
        accessibilityBridge.isAccessibilityEnabled(),
        accessibilityBridge.isTouchExplorationEnabled());
 
    // Connect AccessibilityBridge to the PlatformViewsController within the FlutterEngine.
    // This allows platform Views to hook into Flutter's overall accessibility system.
    this.flutterEngine.getPlatformViewsController().attachAccessibilityBridge(accessibilityBridge);
    this.flutterEngine
        .getPlatformViewsController()
        .attachToFlutterRenderer(this.flutterEngine.getRenderer());
 
    // Inform the Android framework that it should retrieve a new InputConnection
    // now that an engine is attached.
    // TODO(mattcarroll): once this is proven to work, move this line ot TextInputPlugin
    textInputPlugin.getInputMethodManager().restartInput(this);
 
    // Push View and Context related information from Android to Flutter.
    sendUserSettingsToFlutter();
    getContext()
        .getContentResolver()
        .registerContentObserver(
            Settings.System.getUriFor(Settings.System.TEXT_SHOW_PASSWORD),
            false,
            systemSettingsObserver);
 
    sendViewportMetricsToFlutter();
 
    flutterEngine.getPlatformViewsController().attachToView(this);
 
    // Notify engine attachment listeners of the attachment.
    for (FlutterEngineAttachmentListener listener : flutterEngineAttachmentListeners) {
      listener.onFlutterEngineAttachedToFlutterView(flutterEngine);
    }
 
    // If the first frame has already been rendered, notify all first frame listeners.
    // Do this after all other initialization so that listeners don't inadvertently interact
    // with a FlutterView that is only partially attached to a FlutterEngine.
    if (isFlutterUiDisplayed) {
      flutterUiDisplayListener.onFlutterUiDisplayed();
    }
  }

checkInputConnectionProxy()

boolean io.flutter.embedding.android.FlutterView.checkInputConnectionProxy ( View  view )

inline

Allows a View that is not currently the input connection target to invoke commands on the android.view.inputmethod.InputMethodManager, which is otherwise disallowed.

Returns true to allow non-input-connection-targets to invoke methods on
InputMethodManager, or false to exclusively allow the input connection target to invoke such methods.

Definition at line 838 of file FlutterView.java.

                                                      {
    return flutterEngine != null
        ? flutterEngine.getPlatformViewsController().checkInputConnectionProxy(view)
        : super.checkInputConnectionProxy(view);
  }

convertToImageView()

void io.flutter.embedding.android.FlutterView.convertToImageView ( )

inline

Converts the current render surface to a FlutterImageView if it's not one already. Otherwise, it resizes the FlutterImageView based on the current view size.

Definition at line 1272 of file FlutterView.java.

                                   {
    renderSurface.pause();
 
    if (flutterImageView == null) {
      flutterImageView = createImageView();
      addView(flutterImageView);
    } else {
      flutterImageView.resizeIfNeeded(getWidth(), getHeight());
    }
 
    previousRenderSurface = renderSurface;
    renderSurface = flutterImageView;
    if (flutterEngine != null) {
      renderSurface.attachToRenderer(flutterEngine.getRenderer());
    }
  }

createImageView()

FlutterImageView io.flutter.embedding.android.FlutterView.createImageView ( )

inline

Definition at line 1258 of file FlutterView.java.

                                            {
    return new FlutterImageView(
        getContext(), getWidth(), getHeight(), FlutterImageView.SurfaceKind.background);
  }

createWindowInfoRepo()

WindowInfoRepositoryCallbackAdapterWrapper io.flutter.embedding.android.FlutterView.createWindowInfoRepo ( )

inlineprotected

Definition at line 487 of file FlutterView.java.

                                                                              {
    try {
      return new WindowInfoRepositoryCallbackAdapterWrapper(
          new WindowInfoTrackerCallbackAdapter(
              WindowInfoTracker.Companion.getOrCreate(getContext())));
    } catch (NoClassDefFoundError noClassDefFoundError) {
      // Testing environment uses gn/javac, which does not work with aar files. This is why aar
      // are converted to jar files, losing resources and other android-specific files.
      // androidx.window does contain resources, which causes it to fail during testing, since the
      // class androidx.window.R is not found.
      // This method is mocked in the tests involving androidx.window, but this catch block is
      // needed for other tests, which would otherwise fail during onAttachedToWindow().
      return null;
    }
  }

detachFromFlutterEngine()

void io.flutter.embedding.android.FlutterView.detachFromFlutterEngine ( )

inline

Disconnects this FlutterView from a previously attached io.flutter.embedding.engine.FlutterEngine.

This FlutterView will clear its UI and stop forwarding all events to the previously-attached io.flutter.embedding.engine.FlutterEngine. This includes touch events, accessibility events, keyboard events, and others.

See attachToFlutterEngine(FlutterEngine) for information on how to attach a FlutterEngine.

Definition at line 1188 of file FlutterView.java.

                                        {
    Log.v(TAG, "Detaching from a FlutterEngine: " + flutterEngine);
    if (!isAttachedToFlutterEngine()) {
      Log.v(TAG, "FlutterView not attached to an engine. Not detaching.");
      return;
    }
 
    // Notify engine attachment listeners of the detachment.
    for (FlutterEngineAttachmentListener listener : flutterEngineAttachmentListeners) {
      listener.onFlutterEngineDetachedFromFlutterView();
    }
 
    getContext().getContentResolver().unregisterContentObserver(systemSettingsObserver);
 
    flutterEngine.getPlatformViewsController().detachFromView();
 
    // Disconnect the FlutterEngine's PlatformViewsController from the AccessibilityBridge.
    flutterEngine.getPlatformViewsController().detachAccessibilityBridge();
 
    // Disconnect and clean up the AccessibilityBridge.
    accessibilityBridge.release();
    accessibilityBridge = null;
 
    // Inform the Android framework that it should retrieve a new InputConnection
    // now that the engine is detached. The new InputConnection will be null, which
    // signifies that this View does not process input (until a new engine is attached).
    // TODO(mattcarroll): once this is proven to work, move this line ot TextInputPlugin
    textInputPlugin.getInputMethodManager().restartInput(this);
    textInputPlugin.destroy();
    keyboardManager.destroy();
    if (spellCheckPlugin != null) {
      spellCheckPlugin.destroy();
    }
 
    if (mouseCursorPlugin != null) {
      mouseCursorPlugin.destroy();
    }
 
    // Instruct our FlutterRenderer that we are no longer interested in being its RenderSurface.
    FlutterRenderer flutterRenderer = flutterEngine.getRenderer();
    isFlutterUiDisplayed = false;
    flutterRenderer.removeIsDisplayingFlutterUiListener(flutterUiDisplayListener);
    flutterRenderer.stopRenderingToSurface();
    flutterRenderer.setSemanticsEnabled(false);
 
    // Revert the image view to previous surface
    if (previousRenderSurface != null && renderSurface == flutterImageView) {
      renderSurface = previousRenderSurface;
    }
    renderSurface.detachFromRenderer();
 
    releaseImageView();
 
    previousRenderSurface = null;
    flutterEngine = null;
  }

dispatchKeyEvent()

boolean io.flutter.embedding.android.FlutterView.dispatchKeyEvent ( @NonNull KeyEvent  event )

inline

Invoked when a hardware key is pressed or released.

This method is typically invoked in response to the press of a physical keyboard key or a D-pad button. It is generally not invoked when a virtual software keyboard is used, though a software keyboard may choose to invoke this method in some situations.

KeyEvents are sent from Android to Flutter. KeyboardManager may do some additional work with the given KeyEvent, e.g., combine this keyCode with the previous keyCode to generate a unicode combined character.

Definition at line 856 of file FlutterView.java.

                                                           {
    if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
      // Tell Android to start tracking this event.
      getKeyDispatcherState().startTracking(event, this);
    } else if (event.getAction() == KeyEvent.ACTION_UP) {
      // Stop tracking the event.
      getKeyDispatcherState().handleUpEvent(event);
    }
    // If the key processor doesn't handle it, then send it on to the
    // superclass. The key processor will typically handle all events except
    // those where it has re-dispatched the event after receiving a reply from
    // the framework that the framework did not handle it.
    return (isAttachedToFlutterEngine() && keyboardManager.handleEvent(event))
        || super.dispatchKeyEvent(event);
  }

findViewByAccessibilityIdTraversal()

View io.flutter.embedding.android.FlutterView.findViewByAccessibilityIdTraversal ( int  accessibilityId )

inline

Prior to Android Q, it's impossible to add real views as descendants of virtual nodes. This breaks accessibility when an Android view is embedded in a Flutter app.

This method overrides a hidden method in ViewGroup to workaround this limitation. This solution is derivated from Jetpack Compose, and can be found in the Android source code as well.

This workaround finds the descendant View that matches the provided accessibility id.

Parameters

accessibilityId

The view accessibility id.

Returns

The view matching the accessibility id if any.

Definition at line 960 of file FlutterView.java.

                                                                      {
    if (Build.VERSION.SDK_INT < API_LEVELS.API_29) {
      return findViewByAccessibilityIdRootedAtCurrentView(accessibilityId, this);
    }
    // Android Q or later doesn't call this method.
    //
    // However, since this is implementation detail, a future version of Android might call
    // this method again, fallback to calling the This member is not intended for public use, and is
    // only visible for testing. method as expected by ViewGroup.
    Method findViewByAccessibilityIdTraversalMethod;
    try {
      findViewByAccessibilityIdTraversalMethod =
          View.class.getDeclaredMethod("findViewByAccessibilityIdTraversal", int.class);
    } catch (NoSuchMethodException exception) {
      return null;
    }
    findViewByAccessibilityIdTraversalMethod.setAccessible(true);
    try {
      return (View) findViewByAccessibilityIdTraversalMethod.invoke(this, accessibilityId);
    } catch (IllegalAccessException exception) {
      return null;
    } catch (InvocationTargetException exception) {
      return null;
    }
  }

getAccessibilityNodeProvider()

AccessibilityNodeProvider io.flutter.embedding.android.FlutterView.getAccessibilityNodeProvider ( )

inline

Definition at line 933 of file FlutterView.java.

                                                                  {
    if (accessibilityBridge != null && accessibilityBridge.isAccessibilityEnabled()) {
      return accessibilityBridge;
    } else {
      // TODO(goderbauer): when a11y is off this should return a one-off snapshot of
      // the a11y
      // tree.
      return null;
    }
  }

getBinaryMessenger()

BinaryMessenger io.flutter.embedding.android.FlutterView.getBinaryMessenger ( )

inline

Returns a BinaryMessenger to send platform messages with.

Implements io.flutter.embedding.android.KeyboardManager.ViewDelegate.

Definition at line 1048 of file FlutterView.java.

                                              {
    return flutterEngine.getDartExecutor();
  }

getCurrentImageSurface()

FlutterImageView io.flutter.embedding.android.FlutterView.getCurrentImageSurface ( )

inline

Definition at line 1264 of file FlutterView.java.

                                                   {
    return flutterImageView;
  }

getSystemPointerIcon()

PointerIcon io.flutter.embedding.android.FlutterView.getSystemPointerIcon ( int  type )

inline

Definition at line 1040 of file FlutterView.java.

                                                    {
    return PointerIcon.getSystemIcon(getContext(), type);
  }

hasRenderedFirstFrame()

boolean io.flutter.embedding.android.FlutterView.hasRenderedFirstFrame ( )

inline

Returns true if an attached io.flutter.embedding.engine.FlutterEngine has rendered at least 1 frame to this FlutterView.

Returns false if no io.flutter.embedding.engine.FlutterEngine is attached.

This flag is specific to a given io.flutter.embedding.engine.FlutterEngine. The following hypothetical timeline demonstrates how this flag changes over time.

1. flutterEngineA is attached to this FlutterView: returns false
2. flutterEngineA renders its first frame to this FlutterView: returns true
3. flutterEngineA is detached from this FlutterView: returns false
4. flutterEngineB is attached to this FlutterView: returns false
5. flutterEngineB renders its first frame to this FlutterView: returns true

Definition at line 412 of file FlutterView.java.

                                         {
    return isFlutterUiDisplayed;
  }

onApplyWindowInsets()

final WindowInsets io.flutter.embedding.android.FlutterView.onApplyWindowInsets ( @NonNull WindowInsets  insets )

inline

Invoked when Android's desired window insets change, i.e., padding.

Flutter does not use a standard View hierarchy and therefore Flutter is unaware of these insets. Therefore, this method calculates the viewport metrics that Flutter should use and then sends those metrics to Flutter.

This callback is not present in API < 20, which means lower API devices will see the wider than expected padding when the status and navigation bars are hidden.

Definition at line 678 of file FlutterView.java.

                                                                              {
    WindowInsets newInsets = super.onApplyWindowInsets(insets);
 
    // getSystemGestureInsets() was introduced in API 29 and immediately deprecated in 30.
    if (Build.VERSION.SDK_INT == API_LEVELS.API_29) {
      Insets systemGestureInsets = insets.getSystemGestureInsets();
      viewportMetrics.systemGestureInsetTop = systemGestureInsets.top;
      viewportMetrics.systemGestureInsetRight = systemGestureInsets.right;
      viewportMetrics.systemGestureInsetBottom = systemGestureInsets.bottom;
      viewportMetrics.systemGestureInsetLeft = systemGestureInsets.left;
    }
 
    boolean statusBarVisible = (SYSTEM_UI_FLAG_FULLSCREEN & getWindowSystemUiVisibility()) == 0;
    boolean navigationBarVisible =
        (SYSTEM_UI_FLAG_HIDE_NAVIGATION & getWindowSystemUiVisibility()) == 0;
 
    if (Build.VERSION.SDK_INT >= API_LEVELS.API_30) {
      int mask = 0;
      if (navigationBarVisible) {
        mask = mask | android.view.WindowInsets.Type.navigationBars();
      }
      if (statusBarVisible) {
        mask = mask | android.view.WindowInsets.Type.statusBars();
      }
      Insets uiInsets = insets.getInsets(mask);
      viewportMetrics.viewPaddingTop = uiInsets.top;
      viewportMetrics.viewPaddingRight = uiInsets.right;
      viewportMetrics.viewPaddingBottom = uiInsets.bottom;
      viewportMetrics.viewPaddingLeft = uiInsets.left;
 
      Insets imeInsets = insets.getInsets(android.view.WindowInsets.Type.ime());
      viewportMetrics.viewInsetTop = imeInsets.top;
      viewportMetrics.viewInsetRight = imeInsets.right;
      viewportMetrics.viewInsetBottom = imeInsets.bottom; // Typically, only bottom is non-zero
      viewportMetrics.viewInsetLeft = imeInsets.left;
 
      Insets systemGestureInsets =
          insets.getInsets(android.view.WindowInsets.Type.systemGestures());
      viewportMetrics.systemGestureInsetTop = systemGestureInsets.top;
      viewportMetrics.systemGestureInsetRight = systemGestureInsets.right;
      viewportMetrics.systemGestureInsetBottom = systemGestureInsets.bottom;
      viewportMetrics.systemGestureInsetLeft = systemGestureInsets.left;
 
      // TODO(garyq): Expose the full rects of the display cutout.
 
      // Take the max of the display cutout insets and existing padding to merge them
      DisplayCutout cutout = insets.getDisplayCutout();
      if (cutout != null) {
        Insets waterfallInsets = cutout.getWaterfallInsets();
        viewportMetrics.viewPaddingTop =
            Math.max(
                Math.max(viewportMetrics.viewPaddingTop, waterfallInsets.top),
                cutout.getSafeInsetTop());
        viewportMetrics.viewPaddingRight =
            Math.max(
                Math.max(viewportMetrics.viewPaddingRight, waterfallInsets.right),
                cutout.getSafeInsetRight());
        viewportMetrics.viewPaddingBottom =
            Math.max(
                Math.max(viewportMetrics.viewPaddingBottom, waterfallInsets.bottom),
                cutout.getSafeInsetBottom());
        viewportMetrics.viewPaddingLeft =
            Math.max(
                Math.max(viewportMetrics.viewPaddingLeft, waterfallInsets.left),
                cutout.getSafeInsetLeft());
      }
    } else {
      // We zero the left and/or right sides to prevent the padding the
      // navigation bar would have caused.
      ZeroSides zeroSides = ZeroSides.NONE;
      if (!navigationBarVisible) {
        zeroSides = calculateShouldZeroSides();
      }
 
      // Status bar (top), navigation bar (bottom) and left/right system insets should
      // partially obscure the content (padding).
      viewportMetrics.viewPaddingTop = statusBarVisible ? insets.getSystemWindowInsetTop() : 0;
      viewportMetrics.viewPaddingRight =
          zeroSides == ZeroSides.RIGHT || zeroSides == ZeroSides.BOTH
              ? 0
              : insets.getSystemWindowInsetRight();
      viewportMetrics.viewPaddingBottom =
          navigationBarVisible && guessBottomKeyboardInset(insets) == 0
              ? insets.getSystemWindowInsetBottom()
              : 0;
      viewportMetrics.viewPaddingLeft =
          zeroSides == ZeroSides.LEFT || zeroSides == ZeroSides.BOTH
              ? 0
              : insets.getSystemWindowInsetLeft();
 
      // Bottom system inset (keyboard) should adjust scrollable bottom edge (inset).
      viewportMetrics.viewInsetTop = 0;
      viewportMetrics.viewInsetRight = 0;
      viewportMetrics.viewInsetBottom = guessBottomKeyboardInset(insets);
      viewportMetrics.viewInsetLeft = 0;
    }
 
    Log.v(
        TAG,
        "Updating window insets (onApplyWindowInsets()):\n"
            + "Status bar insets: Top: "
            + viewportMetrics.viewPaddingTop
            + ", Left: "
            + viewportMetrics.viewPaddingLeft
            + ", Right: "
            + viewportMetrics.viewPaddingRight
            + "\n"
            + "Keyboard insets: Bottom: "
            + viewportMetrics.viewInsetBottom
            + ", Left: "
            + viewportMetrics.viewInsetLeft
            + ", Right: "
            + viewportMetrics.viewInsetRight
            + "System Gesture Insets - Left: "
            + viewportMetrics.systemGestureInsetLeft
            + ", Top: "
            + viewportMetrics.systemGestureInsetTop
            + ", Right: "
            + viewportMetrics.systemGestureInsetRight
            + ", Bottom: "
            + viewportMetrics.viewInsetBottom);
 
    sendViewportMetricsToFlutter();
    return newInsets;
  }

onAttachedToWindow()

void io.flutter.embedding.android.FlutterView.onAttachedToWindow ( )

inlineprotected

Invoked when this is attached to the window.

We register for androidx.window.layout.WindowInfoTracker updates.

Definition at line 509 of file FlutterView.java.

                                      {
    super.onAttachedToWindow();
    this.windowInfoRepo = createWindowInfoRepo();
    Activity activity = ViewUtils.getActivity(getContext());
    if (windowInfoRepo != null && activity != null) {
      windowInfoRepo.addWindowLayoutInfoListener(
          activity, ContextCompat.getMainExecutor(getContext()), windowInfoListener);
    }
  }

onConfigurationChanged()

void io.flutter.embedding.android.FlutterView.onConfigurationChanged ( @NonNull Configuration  newConfig )

inlineprotected

Sends relevant configuration data from Android to Flutter when the Android Configuration changes.

The Android Configuration might change as a result of device orientation change, device language change, device text scale factor change, etc.

Definition at line 441 of file FlutterView.java.

                                                                          {
    super.onConfigurationChanged(newConfig);
    // We've observed on Android Q that going to the background, changing
    // orientation, and bringing the app back to foreground results in a sequence
    // of detatch from flutterEngine, onConfigurationChanged, followed by attach
    // to flutterEngine.
    // No-op here so that we avoid NPE; these channels will get notified once
    // the activity or fragment tell the view to attach to the Flutter engine
    // again (e.g. in onStart).
    if (flutterEngine != null) {
      Log.v(TAG, "Configuration changed. Sending locales and user settings to Flutter.");
      localizationPlugin.sendLocalesToFlutter(newConfig);
      sendUserSettingsToFlutter();
 
      ViewUtils.calculateMaximumDisplayMetrics(getContext(), flutterEngine);
    }
  }

onCreateInputConnection()

InputConnection io.flutter.embedding.android.FlutterView.onCreateInputConnection ( @NonNull EditorInfo  outAttrs )

inline

Creates an InputConnection to work with a android.view.inputmethod.InputMethodManager.

Any View that can take focus or process text input must implement this method by returning a non-null InputConnection. Flutter may render one or many focusable and text-input widgets, therefore FlutterView must support an InputConnection.

The InputConnection returned from this method comes from a TextInputPlugin, which is owned by this FlutterView. A TextInputPlugin exists to encapsulate the nuances of input communication, rather than spread that logic throughout this
FlutterView.

Definition at line 821 of file FlutterView.java.

                                                                               {
    if (!isAttachedToFlutterEngine()) {
      return super.onCreateInputConnection(outAttrs);
    }
 
    return textInputPlugin.createInputConnection(this, keyboardManager, outAttrs);
  }

onDetachedFromWindow()

void io.flutter.embedding.android.FlutterView.onDetachedFromWindow ( )

inlineprotected

Invoked when this is detached from the window.

We unregister from androidx.window.layout.WindowInfoTracker updates.

Definition at line 525 of file FlutterView.java.

                                        {
    if (windowInfoRepo != null) {
      windowInfoRepo.removeWindowLayoutInfoListener(windowInfoListener);
    }
    this.windowInfoRepo = null;
    super.onDetachedFromWindow();
  }

onGenericMotionEvent()

boolean io.flutter.embedding.android.FlutterView.onGenericMotionEvent ( @NonNull MotionEvent  event )

inline

Invoked by Android when a generic motion event occurs, e.g., joystick movement, mouse hover, track pad touches, scroll wheel movements, etc.

Flutter handles all of its own gesture detection and processing, therefore this method forwards all MotionEvent data from Android to Flutter.

Definition at line 897 of file FlutterView.java.

                                                                  {
    boolean handled =
        isAttachedToFlutterEngine()
            && androidTouchProcessor.onGenericMotionEvent(event, getContext());
    return handled ? true : super.onGenericMotionEvent(event);
  }

onHoverEvent()

boolean io.flutter.embedding.android.FlutterView.onHoverEvent ( @NonNull MotionEvent  event )

inline

Invoked by Android when a hover-compliant input system causes a hover event.

An example of hover events is a stylus sitting near an Android screen. As the stylus moves from outside a View to hover over a View, or move around within a View, or moves from over a View to outside a View, a corresponding MotionEvent is reported via this method.

Hover events can be used for accessibility touch exploration and therefore are processed here for accessibility purposes.

Definition at line 916 of file FlutterView.java.

                                                          {
    if (!isAttachedToFlutterEngine()) {
      return super.onHoverEvent(event);
    }
 
    boolean handled = accessibilityBridge.onAccessibilityHoverEvent(event);
    if (!handled) {
      // TODO(ianh): Expose hover events to the platform,
      // implementing ADD, REMOVE, etc.
    }
    return handled;
  }

onSizeChanged()

void io.flutter.embedding.android.FlutterView.onSizeChanged ( int  width, int  height, int  oldWidth, int  oldHeight  )

inlineprotected

Invoked when this FlutterView changes size, including upon initial measure.

The initial measure reports an oldWidth and oldHeight of zero.

Flutter cares about the width and height of the view that displays it on the host platform. Therefore, when this method is invoked, the new width and height are communicated to Flutter as the "physical size" of the view that displays Flutter's UI.

Definition at line 469 of file FlutterView.java.

                                                                                   {
    super.onSizeChanged(width, height, oldWidth, oldHeight);
    Log.v(
        TAG,
        "Size changed. Sending Flutter new viewport metrics. FlutterView was "
            + oldWidth
            + " x "
            + oldHeight
            + ", it is now "
            + width
            + " x "
            + height);
    viewportMetrics.width = width;
    viewportMetrics.height = height;
    sendViewportMetricsToFlutter();
  }

onTextInputKeyEvent()

boolean io.flutter.embedding.android.FlutterView.onTextInputKeyEvent ( @NonNull KeyEvent  keyEvent )

inline

Send a KeyEvent that is not handled by the keyboard responders to the text input system.

Parameters

keyEvent

the KeyEvent that should be processed by the text input system. It must not be null.

Returns

Whether the text input handles the key event.

Implements io.flutter.embedding.android.KeyboardManager.ViewDelegate.

Definition at line 1053 of file FlutterView.java.

                                                                 {
    return textInputPlugin.handleKeyEvent(keyEvent);
  }

onTouchEvent()

boolean io.flutter.embedding.android.FlutterView.onTouchEvent ( @NonNull MotionEvent  event )

inline

Invoked by Android when a user touch event occurs.

Flutter handles all of its own gesture detection and processing, therefore this method forwards all MotionEvent data from Android to Flutter.

Definition at line 879 of file FlutterView.java.

                                                          {
    if (!isAttachedToFlutterEngine()) {
      return super.onTouchEvent(event);
    }
 
    requestUnbufferedDispatch(event);
 
    return androidTouchProcessor.onTouchEvent(event);
  }

redispatch()

void io.flutter.embedding.android.FlutterView.redispatch ( @NonNull KeyEvent  keyEvent )

inline

Send a KeyEvent that is not handled by Flutter back to the platform.

Implements io.flutter.embedding.android.KeyboardManager.ViewDelegate.

Definition at line 1058 of file FlutterView.java.

                                                     {
    getRootView().dispatchKeyEvent(keyEvent);
  }

removeOnFirstFrameRenderedListener()

void io.flutter.embedding.android.FlutterView.removeOnFirstFrameRenderedListener ( @NonNull FlutterUiDisplayListener  listener )

inline

Removes the given listener, which was previously added with addOnFirstFrameRenderedListener(FlutterUiDisplayListener).

Definition at line 428 of file FlutterView.java.

                                                                                             {
    flutterUiDisplayListeners.remove(listener);
  }

revertImageView()

void io.flutter.embedding.android.FlutterView.revertImageView ( @NonNull Runnable  onDone )

inline

If the surface is rendered by a FlutterImageView, then calling this method will stop rendering to a FlutterImageView, and render on the previous surface instead.

Parameters

onDone

a callback called when Flutter UI is rendered on the previous surface. Use this callback to perform cleanups. For example, destroy overlay surfaces.

Definition at line 1296 of file FlutterView.java.

                                                        {
    if (flutterImageView == null) {
      Log.v(TAG, "Tried to revert the image view, but no image view is used.");
      return;
    }
    if (previousRenderSurface == null) {
      Log.v(TAG, "Tried to revert the image view, but no previous surface was used.");
      return;
    }
    renderSurface = previousRenderSurface;
    previousRenderSurface = null;
 
    final FlutterRenderer renderer = flutterEngine.getRenderer();
 
    if (flutterEngine == null || renderer == null) {
      flutterImageView.detachFromRenderer();
      releaseImageView();
      onDone.run();
      return;
    }
    // Resume rendering to the previous surface.
    // This surface is typically `FlutterSurfaceView` or `FlutterTextureView`.
    renderSurface.resume();
 
    // Install a Flutter UI listener to wait until the first frame is rendered
    // in the new surface to call the `onDone` callback.
    renderer.addIsDisplayingFlutterUiListener(
        new FlutterUiDisplayListener() {
          @Override
          public void onFlutterUiDisplayed() {
            renderer.removeIsDisplayingFlutterUiListener(this);
            onDone.run();
            if (!(renderSurface instanceof FlutterImageView) && flutterImageView != null) {
              flutterImageView.detachFromRenderer();
              releaseImageView();
            }
          }
 
          @Override
          public void onFlutterUiNoLongerDisplayed() {
            // no-op
          }
        });
  }

setWindowInfoListenerDisplayFeatures()

void io.flutter.embedding.android.FlutterView.setWindowInfoListenerDisplayFeatures ( WindowLayoutInfo  layoutInfo )

inlineprotected

Refresh androidx.window.layout.WindowInfoTracker and android.view.DisplayCutout display features. Fold, hinge and cutout areas are populated here.

Definition at line 538 of file FlutterView.java.

                                                                                   {
    List<DisplayFeature> displayFeatures = layoutInfo.getDisplayFeatures();
    List<FlutterRenderer.DisplayFeature> result = new ArrayList<>();
 
    // Data from WindowInfoTracker display features. Fold and hinge areas are
    // populated here.
    for (DisplayFeature displayFeature : displayFeatures) {
      Log.v(
          TAG,
          "WindowInfoTracker Display Feature reported with bounds = "
              + displayFeature.getBounds().toString()
              + " and type = "
              + displayFeature.getClass().getSimpleName());
      if (displayFeature instanceof FoldingFeature) {
        DisplayFeatureType type;
        DisplayFeatureState state;
        final FoldingFeature feature = (FoldingFeature) displayFeature;
        if (feature.getOcclusionType() == OcclusionType.FULL) {
          type = DisplayFeatureType.HINGE;
        } else {
          type = DisplayFeatureType.FOLD;
        }
        if (feature.getState() == State.FLAT) {
          state = DisplayFeatureState.POSTURE_FLAT;
        } else if (feature.getState() == State.HALF_OPENED) {
          state = DisplayFeatureState.POSTURE_HALF_OPENED;
        } else {
          state = DisplayFeatureState.UNKNOWN;
        }
        result.add(new FlutterRenderer.DisplayFeature(displayFeature.getBounds(), type, state));
      } else {
        result.add(
            new FlutterRenderer.DisplayFeature(
                displayFeature.getBounds(),
                DisplayFeatureType.UNKNOWN,
                DisplayFeatureState.UNKNOWN));
      }
    }
 
    // Data from the DisplayCutout bounds. Cutouts for cameras and other sensors are
    // populated here. DisplayCutout was introduced in API 28.
    if (Build.VERSION.SDK_INT >= API_LEVELS.API_28) {
      WindowInsets insets = getRootWindowInsets();
      if (insets != null) {
        DisplayCutout cutout = insets.getDisplayCutout();
        if (cutout != null) {
          for (Rect bounds : cutout.getBoundingRects()) {
            Log.v(TAG, "DisplayCutout area reported with bounds = " + bounds.toString());
            result.add(new FlutterRenderer.DisplayFeature(bounds, DisplayFeatureType.CUTOUT));
          }
        }
      }
    }
    viewportMetrics.displayFeatures = result;
    sendViewportMetricsToFlutter();
  }

Member Data Documentation

renderSurface

RenderSurface io.flutter.embedding.android.FlutterView.renderSurface

package

Definition at line 115 of file FlutterView.java.

---

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

• shell/platform/android/io/flutter/embedding/android/FlutterView.java