io.flutter.embedding.engine.renderer.FlutterRenderer Class Reference

Inheritance diagram for io.flutter.embedding.engine.renderer.FlutterRenderer:

Classes
class	DisplayFeature
enum	DisplayFeatureState
enum	DisplayFeatureType
class	ImageReaderSurfaceProducer
class	ImageTextureRegistryEntry
class	SurfaceTextureRegistryEntry
class	TextureFinalizerRunnable
class	ViewportMetrics

Public Member Functions
	FlutterRenderer (@NonNull FlutterJNI flutterJNI)
boolean	isDisplayingFlutterUi ()
void	addIsDisplayingFlutterUiListener (@NonNull FlutterUiDisplayListener listener)
void	removeIsDisplayingFlutterUiListener (@NonNull FlutterUiDisplayListener listener)
SurfaceProducer	createSurfaceProducer ()
SurfaceTextureEntry	createSurfaceTexture ()
SurfaceTextureEntry	registerSurfaceTexture (@NonNull SurfaceTexture surfaceTexture)

Static Public Attributes
static boolean	debugForceSurfaceProducerGlTextures = false
static boolean	debugDisableSurfaceClear = false

Package Functions
void	addOnTrimMemoryListener (@NonNull OnTrimMemoryListener listener)
void	removeOnTrimMemoryListener (@NonNull OnTrimMemoryListener listener)
ImageTextureEntry	createImageTexture ()
void	onTrimMemory (int level)
void	startRenderingToSurface (@NonNull Surface surface, boolean onlySwap)
void	swapSurface (@NonNull Surface surface)
void	surfaceChanged (int width, int height)
void	stopRenderingToSurface ()
void	setViewportMetrics (@NonNull ViewportMetrics viewportMetrics)
Bitmap	getBitmap ()
void	dispatchPointerDataPacket (@NonNull ByteBuffer buffer, int position)
boolean	isSoftwareRenderingEnabled ()
void	setAccessibilityFeatures (int flags)
void	setSemanticsEnabled (boolean enabled)
void	dispatchSemanticsAction (int nodeId, int action, @Nullable ByteBuffer args, int argsPosition)

Detailed Description

Represents the rendering responsibilities of a FlutterEngine.

FlutterRenderer works in tandem with a provided RenderSurface to paint Flutter pixels to an Android View hierarchy.

FlutterRenderer manages textures for rendering, and forwards some Java calls to native Flutter code via JNI. The corresponding RenderSurface provides the Android Surface that this renderer paints.

io.flutter.embedding.android.FlutterSurfaceView and io.flutter.embedding.android.FlutterTextureView are implementations of RenderSurface.

Definition at line 54 of file FlutterRenderer.java.

Constructor & Destructor Documentation

FlutterRenderer()

io.flutter.embedding.engine.renderer.FlutterRenderer.FlutterRenderer ( @NonNull FlutterJNI  flutterJNI )

inline

Definition at line 94 of file FlutterRenderer.java.

                                                         {
    this.flutterJNI = flutterJNI;
    this.flutterJNI.addIsDisplayingFlutterUiListener(flutterUiDisplayListener);
  }

Member Function Documentation

addIsDisplayingFlutterUiListener()

void io.flutter.embedding.engine.renderer.FlutterRenderer.addIsDisplayingFlutterUiListener ( @NonNull FlutterUiDisplayListener  listener )

inline

Adds a listener that is invoked whenever this FlutterRenderer starts and stops painting pixels to an Android View hierarchy.

Definition at line 111 of file FlutterRenderer.java.

                                                                                           {
    flutterJNI.addIsDisplayingFlutterUiListener(listener);
 
    if (isDisplayingFlutterUi) {
      listener.onFlutterUiDisplayed();
    }
  }

addOnTrimMemoryListener()

void io.flutter.embedding.engine.renderer.FlutterRenderer.addOnTrimMemoryListener ( @NonNull OnTrimMemoryListener  listener )

inlinepackage

Adds a listener that is invoked when a memory pressure warning was forward.

Definition at line 140 of file FlutterRenderer.java.

                                                                         {
    // Purge dead listener to avoid accumulating.
    clearDeadListeners();
    onTrimMemoryListeners.add(new WeakReference<>(listener));
  }

createImageTexture()

ImageTextureEntry io.flutter.embedding.engine.renderer.FlutterRenderer.createImageTexture ( )

inline

Definition at line 259 of file FlutterRenderer.java.

                                                {
    final ImageTextureRegistryEntry entry =
        new ImageTextureRegistryEntry(nextTextureId.getAndIncrement());
    Log.v(TAG, "New ImageTextureEntry ID: " + entry.id());
    registerImageTexture(entry.id(), entry);
    return entry;
  }

createSurfaceProducer()

SurfaceProducer io.flutter.embedding.engine.renderer.FlutterRenderer.createSurfaceProducer ( )

inline

Creates and returns a new external texture SurfaceProducer managed by the Flutter engine that is also made available to Flutter code.

Definition at line 168 of file FlutterRenderer.java.

                                                 {
    // Prior to Impeller, Flutter on Android *only* ran on OpenGLES (via Skia). That
    // meant that
    // plugins (i.e. end-users) either explicitly created a SurfaceTexture (via
    // createX/registerX) or an ImageTexture (via createX/registerX).
    //
    // In an Impeller world, which for the first time uses (if available) a Vulkan
    // rendering
    // backend, it is no longer possible (at least not trivially) to render an
    // OpenGLES-provided
    // texture (SurfaceTexture) in a Vulkan context.
    //
    // This function picks the "best" rendering surface based on the Android
    // runtime, and
    // provides a consumer-agnostic SurfaceProducer (which in turn vends a Surface),
    // and has
    // plugins (i.e. end-users) use the Surface instead, letting us "hide" the
    // consumer-side
    // of the implementation.
    //
    // tl;dr: If ImageTexture is available, we use it, otherwise we use a
    // SurfaceTexture.
    // Coincidentally, if ImageTexture is available, we are also on an Android
    // version that is
    // running Vulkan, so we don't have to worry about it not being supported.
    final SurfaceProducer entry;
    if (!debugForceSurfaceProducerGlTextures && Build.VERSION.SDK_INT >= API_LEVELS.API_29) {
      final long id = nextTextureId.getAndIncrement();
      final ImageReaderSurfaceProducer producer = new ImageReaderSurfaceProducer(id);
      registerImageTexture(id, producer);
      addOnTrimMemoryListener(producer);
      Log.v(TAG, "New ImageReaderSurfaceProducer ID: " + id);
      entry = producer;
    } else {
      // TODO(matanlurey): Actually have the class named "*Producer" to well, produce
      // something. This is a code smell, but does guarantee the paths for both
      // createSurfaceTexture and createSurfaceProducer doesn't diverge. As we get more
      // confident in this API and any possible bugs (and have tests to check we don't
      // regress), reconsider this pattern.
      final SurfaceTextureEntry texture = createSurfaceTexture();
      final SurfaceTextureSurfaceProducer producer =
          new SurfaceTextureSurfaceProducer(texture.id(), handler, flutterJNI, texture);
      Log.v(TAG, "New SurfaceTextureSurfaceProducer ID: " + texture.id());
      entry = producer;
    }
    return entry;
  }

createSurfaceTexture()

SurfaceTextureEntry io.flutter.embedding.engine.renderer.FlutterRenderer.createSurfaceTexture ( )

inline

Creates and returns a new SurfaceTexture managed by the Flutter engine that is also made available to Flutter code.

Definition at line 222 of file FlutterRenderer.java.

                                                    {
    Log.v(TAG, "Creating a SurfaceTexture.");
    final SurfaceTexture surfaceTexture = new SurfaceTexture(0);
    return registerSurfaceTexture(surfaceTexture);
  }

dispatchPointerDataPacket()

void io.flutter.embedding.engine.renderer.FlutterRenderer.dispatchPointerDataPacket ( @NonNull ByteBuffer  buffer, int  position  )

inline

Definition at line 1183 of file FlutterRenderer.java.

                                                                                  {
    flutterJNI.dispatchPointerDataPacket(buffer, position);
  }

dispatchSemanticsAction()

void io.flutter.embedding.engine.renderer.FlutterRenderer.dispatchSemanticsAction ( int  nodeId, int  action, @Nullable ByteBuffer  args, int  argsPosition  )

inline

Definition at line 1227 of file FlutterRenderer.java.

                                                                           {
    flutterJNI.dispatchSemanticsAction(nodeId, action, args, argsPosition);
  }

getBitmap()

Bitmap io.flutter.embedding.engine.renderer.FlutterRenderer.getBitmap ( )

inline

Definition at line 1178 of file FlutterRenderer.java.

                            {
    return flutterJNI.getBitmap();
  }

isDisplayingFlutterUi()

boolean io.flutter.embedding.engine.renderer.FlutterRenderer.isDisplayingFlutterUi ( )

inline

Returns true if this FlutterRenderer is painting pixels to an Android View hierarchy, false otherwise.

Definition at line 103 of file FlutterRenderer.java.

                                         {
    return isDisplayingFlutterUi;
  }

isSoftwareRenderingEnabled()

boolean io.flutter.embedding.engine.renderer.FlutterRenderer.isSoftwareRenderingEnabled ( )

inline

Definition at line 1212 of file FlutterRenderer.java.

                                              {
    return flutterJNI.getIsSoftwareRenderingEnabled();
  }

onTrimMemory()

void io.flutter.embedding.engine.renderer.FlutterRenderer.onTrimMemory ( int  level )

inline

Definition at line 268 of file FlutterRenderer.java.

                                      {
    final Iterator<WeakReference<OnTrimMemoryListener>> iterator = onTrimMemoryListeners.iterator();
    while (iterator.hasNext()) {
      WeakReference<OnTrimMemoryListener> listenerRef = iterator.next();
      final OnTrimMemoryListener listener = listenerRef.get();
      if (listener != null) {
        listener.onTrimMemory(level);
      } else {
        // Purge cleared refs to avoid accumulating a lot of dead listener
        iterator.remove();
      }
    }
  }

registerSurfaceTexture()

SurfaceTextureEntry io.flutter.embedding.engine.renderer.FlutterRenderer.registerSurfaceTexture ( @NonNull SurfaceTexture  surfaceTexture )

inline

Registers and returns a SurfaceTexture managed by the Flutter engine that is also made available to Flutter code.

Definition at line 234 of file FlutterRenderer.java.

                                                                                            {
    return registerSurfaceTexture(nextTextureId.getAndIncrement(), surfaceTexture);
  }

removeIsDisplayingFlutterUiListener()

void io.flutter.embedding.engine.renderer.FlutterRenderer.removeIsDisplayingFlutterUiListener ( @NonNull FlutterUiDisplayListener  listener )

inline

Removes a listener added via addIsDisplayingFlutterUiListener(FlutterUiDisplayListener).

Definition at line 123 of file FlutterRenderer.java.

                                                                                              {
    flutterJNI.removeIsDisplayingFlutterUiListener(listener);
  }

removeOnTrimMemoryListener()

void io.flutter.embedding.engine.renderer.FlutterRenderer.removeOnTrimMemoryListener ( @NonNull OnTrimMemoryListener  listener )

inlinepackage

Removes a OnTrimMemoryListener that was added with addOnTrimMemoryListener(OnTrimMemoryListener).

Definition at line 151 of file FlutterRenderer.java.

                                                                            {
    for (WeakReference<OnTrimMemoryListener> listenerRef : onTrimMemoryListeners) {
      if (listenerRef.get() == listener) {
        onTrimMemoryListeners.remove(listenerRef);
        break;
      }
    }
  }

setAccessibilityFeatures()

void io.flutter.embedding.engine.renderer.FlutterRenderer.setAccessibilityFeatures ( int  flags )

inline

Definition at line 1217 of file FlutterRenderer.java.

                                                  {
    flutterJNI.setAccessibilityFeatures(flags);
  }

setSemanticsEnabled()

void io.flutter.embedding.engine.renderer.FlutterRenderer.setSemanticsEnabled ( boolean  enabled )

inline

Definition at line 1222 of file FlutterRenderer.java.

                                                   {
    flutterJNI.setSemanticsEnabled(enabled);
  }

setViewportMetrics()

void io.flutter.embedding.engine.renderer.FlutterRenderer.setViewportMetrics ( @NonNull ViewportMetrics  viewportMetrics )

inline

Notifies Flutter that the viewport metrics, e.g. window height and width, have changed.

If the width, height, or devicePixelRatio are less than or equal to 0, this update is ignored.

Parameters

viewportMetrics

The metrics to send to the Dart application.

Definition at line 1097 of file FlutterRenderer.java.

                                                                           {
    // We might get called with just the DPR if width/height aren't available yet.
    // Just ignore, as it will get called again when width/height are set.
    if (!viewportMetrics.validate()) {
      return;
    }
    Log.v(
        TAG,
        "Setting viewport metrics\n"
            + "Size: "
            + viewportMetrics.width
            + " x "
            + viewportMetrics.height
            + "\n"
            + "Padding - L: "
            + viewportMetrics.viewPaddingLeft
            + ", T: "
            + viewportMetrics.viewPaddingTop
            + ", R: "
            + viewportMetrics.viewPaddingRight
            + ", B: "
            + viewportMetrics.viewPaddingBottom
            + "\n"
            + "Insets - L: "
            + viewportMetrics.viewInsetLeft
            + ", T: "
            + viewportMetrics.viewInsetTop
            + ", R: "
            + viewportMetrics.viewInsetRight
            + ", B: "
            + viewportMetrics.viewInsetBottom
            + "\n"
            + "System Gesture Insets - L: "
            + viewportMetrics.systemGestureInsetLeft
            + ", T: "
            + viewportMetrics.systemGestureInsetTop
            + ", R: "
            + viewportMetrics.systemGestureInsetRight
            + ", B: "
            + viewportMetrics.systemGestureInsetRight
            + "\n"
            + "Display Features: "
            + viewportMetrics.displayFeatures.size());
 
    int[] displayFeaturesBounds = new int[viewportMetrics.displayFeatures.size() * 4];
    int[] displayFeaturesType = new int[viewportMetrics.displayFeatures.size()];
    int[] displayFeaturesState = new int[viewportMetrics.displayFeatures.size()];
    for (int i = 0; i < viewportMetrics.displayFeatures.size(); i++) {
      DisplayFeature displayFeature = viewportMetrics.displayFeatures.get(i);
      displayFeaturesBounds[4 * i] = displayFeature.bounds.left;
      displayFeaturesBounds[4 * i + 1] = displayFeature.bounds.top;
      displayFeaturesBounds[4 * i + 2] = displayFeature.bounds.right;
      displayFeaturesBounds[4 * i + 3] = displayFeature.bounds.bottom;
      displayFeaturesType[i] = displayFeature.type.encodedValue;
      displayFeaturesState[i] = displayFeature.state.encodedValue;
    }
 
    flutterJNI.setViewportMetrics(
        viewportMetrics.devicePixelRatio,
        viewportMetrics.width,
        viewportMetrics.height,
        viewportMetrics.viewPaddingTop,
        viewportMetrics.viewPaddingRight,
        viewportMetrics.viewPaddingBottom,
        viewportMetrics.viewPaddingLeft,
        viewportMetrics.viewInsetTop,
        viewportMetrics.viewInsetRight,
        viewportMetrics.viewInsetBottom,
        viewportMetrics.viewInsetLeft,
        viewportMetrics.systemGestureInsetTop,
        viewportMetrics.systemGestureInsetRight,
        viewportMetrics.systemGestureInsetBottom,
        viewportMetrics.systemGestureInsetLeft,
        viewportMetrics.physicalTouchSlop,
        displayFeaturesBounds,
        displayFeaturesType,
        displayFeaturesState);
  }

startRenderingToSurface()

void io.flutter.embedding.engine.renderer.FlutterRenderer.startRenderingToSurface ( @NonNull Surface  surface, boolean  onlySwap  )

inline

Notifies Flutter that the given surface was created and is available for Flutter rendering.

If called more than once, the current native resources are released. This can be undesired if the Engine expects to reuse this surface later. For example, this is true when platform views are displayed in a frame, and then removed in the next frame.

To avoid releasing the current surface resources, set keepCurrentSurface to true.

See android.view.SurfaceHolder.Callback and android.view.TextureView.SurfaceTextureListener

Parameters

surface	The render surface.
onlySwap	True if the current active surface should not be detached.

Definition at line 1020 of file FlutterRenderer.java.

                                                                                  {
    if (!onlySwap) {
      // Stop rendering to the surface releases the associated native resources, which causes
      // a glitch when toggling between rendering to an image view (hybrid composition) and
      // rendering directly to a Surface or Texture view. For more,
      // https://github.com/flutter/flutter/issues/95343
      stopRenderingToSurface();
    }
 
    this.surface = surface;
 
    if (onlySwap) {
      // In the swap case we are just swapping the surface that we render to.
      flutterJNI.onSurfaceWindowChanged(surface);
    } else {
      // In the non-swap case we are creating a new surface to render to.
      flutterJNI.onSurfaceCreated(surface);
    }
  }

stopRenderingToSurface()

void io.flutter.embedding.engine.renderer.FlutterRenderer.stopRenderingToSurface ( )

inline

Notifies Flutter that a surface previously registered with startRenderingToSurface(Surface, boolean) has been destroyed and needs to be released and cleaned up on the Flutter side.

See android.view.SurfaceHolder.Callback and android.view.TextureView.SurfaceTextureListener

Definition at line 1072 of file FlutterRenderer.java.

                                       {
    if (surface != null) {
      flutterJNI.onSurfaceDestroyed();
 
      // TODO(mattcarroll): the source of truth for this call should be FlutterJNI, which is
      // where the call to onFlutterUiDisplayed() comes from. However, no such native callback
      // exists yet, so until the engine and FlutterJNI are configured to call us back when
      // rendering stops, we will manually monitor that change here.
      if (isDisplayingFlutterUi) {
        flutterUiDisplayListener.onFlutterUiNoLongerDisplayed();
      }
 
      isDisplayingFlutterUi = false;
      surface = null;
    }
  }

surfaceChanged()

void io.flutter.embedding.engine.renderer.FlutterRenderer.surfaceChanged ( int  width, int  height  )

inline

Notifies Flutter that a surface previously registered with startRenderingToSurface(Surface, boolean) has changed size to the given width and height.

See android.view.SurfaceHolder.Callback and android.view.TextureView.SurfaceTextureListener

Definition at line 1060 of file FlutterRenderer.java.

                                                    {
    flutterJNI.onSurfaceChanged(width, height);
  }

swapSurface()

void io.flutter.embedding.engine.renderer.FlutterRenderer.swapSurface ( @NonNull Surface  surface )

inline

Swaps the Surface used to render the current frame.

In hybrid composition, the root surfaces changes from android.view.SurfaceHolder#getSurface() to android.media.ImageReader#getSurface() when a platform view is in the current frame.

Definition at line 1047 of file FlutterRenderer.java.

                                                    {
    this.surface = surface;
    flutterJNI.onSurfaceWindowChanged(surface);
  }

Member Data Documentation

debugDisableSurfaceClear

boolean io.flutter.embedding.engine.renderer.FlutterRenderer.debugDisableSurfaceClear = false

static

Whether to disable clearing of the Surface used to render platform views.

Definition at line 66 of file FlutterRenderer.java.

debugForceSurfaceProducerGlTextures

boolean io.flutter.embedding.engine.renderer.FlutterRenderer.debugForceSurfaceProducerGlTextures = false

static

Whether to always use GL textures for FlutterRenderer#createSurfaceProducer().

This is a debug-only API intended for local development. For example, when using a newer Android device (that normally would use ImageReaderSurfaceProducer, but wanting to test the OpenGLES/SurfaceTextureSurfaceProducer code branch. This flag has undefined behavior if set to true while running in a Vulkan (Impeller) context.

Definition at line 63 of file FlutterRenderer.java.

---

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

• shell/platform/android/io/flutter/embedding/engine/renderer/FlutterRenderer.java