Public Member Functions
	CachedEngineFragmentBuilder ( @NonNull Class<? extends FlutterFragment > subclass, @NonNull String engineId)

CachedEngineFragmentBuilder	destroyEngineWithFragment (boolean destroyEngineWithFragment)

CachedEngineFragmentBuilder	renderMode (@NonNull RenderMode renderMode)

CachedEngineFragmentBuilder	transparencyMode ( @NonNull TransparencyMode transparencyMode)

CachedEngineFragmentBuilder	handleDeeplinking (@NonNull Boolean handleDeeplinking)

CachedEngineFragmentBuilder	shouldAttachEngineToActivity (boolean shouldAttachEngineToActivity)

CachedEngineFragmentBuilder	shouldAutomaticallyHandleOnBackPressed (boolean shouldAutomaticallyHandleOnBackPressed)

CachedEngineFragmentBuilder	shouldDelayFirstAndroidViewDraw ( @NonNull boolean shouldDelayFirstAndroidViewDraw)

Protected Member Functions
Bundle	createArgs ()

Package Functions
public< T extends FlutterFragment > T	build ()

Detailed Description

Builder that creates a new FlutterFragment that uses a cached io.flutter.embedding.engine.FlutterEngine with arguments that correspond to the values set on this Builder.

Subclasses of FlutterFragment that do not introduce any new arguments can use this Builder to construct instances of the subclass without subclassing this Builder. MyFlutterFragment f = new FlutterFragment.CachedEngineFragmentBuilder(MyFlutterFragment.class) .someProperty(...) .someOtherProperty(...) .build<MyFlutterFragment>();

Subclasses of FlutterFragment that introduce new arguments should subclass this CachedEngineFragmentBuilder to add the new properties:

Ensure the FlutterFragment subclass has a no-arg constructor.
Subclass this CachedEngineFragmentBuilder.
Override the new CachedEngineFragmentBuilder's no-arg constructor and invoke the super constructor to set the FlutterFragment subclass: public MyBuilder() { super(MyFlutterFragment.class); }
Add appropriate property methods for the new properties.
Override CachedEngineFragmentBuilder#createArgs(), call through to the super method, then add the new properties as arguments in the Bundle.

Once a CachedEngineFragmentBuilder subclass is defined, the FlutterFragment subclass can be instantiated as follows. MyFlutterFragment f = new MyBuilder() .someExistingProperty(...) .someNewProperty(...) .build<MyFlutterFragment>();

Definition at line 547 of file FlutterFragment.java.

Constructor & Destructor Documentation

◆ CachedEngineFragmentBuilder()

io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.CachedEngineFragmentBuilder	(	@NonNull Class<? extends FlutterFragment >	subclass,
		@NonNull String	engineId
	)

inline

Definition at line 562 of file FlutterFragment.java.

                                                                                      {
      this.fragmentClass = subclass;
      this.engineId = engineId;
    }

Member Function Documentation

◆ build()

public< T extends FlutterFragment > T io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.build ( )

inlinepackage

Constructs a new FlutterFragment (or a subclass) that is configured based on properties set on this CachedEngineFragmentBuilder.

Definition at line 724 of file FlutterFragment.java.

                                                 {
      try {
        @SuppressWarnings("unchecked")
        T frag = (T) fragmentClass.getDeclaredConstructor().newInstance();
        if (frag == null) {
          throw new RuntimeException(
              "The FlutterFragment subclass sent in the constructor ("
                  + fragmentClass.getCanonicalName()
                  + ") does not match the expected return type.");
        }
 
        Bundle args = createArgs();
        frag.setArguments(args);
 
        return frag;
      } catch (Exception e) {
        throw new RuntimeException(
            "Could not instantiate FlutterFragment subclass (" + fragmentClass.getName() + ")", e);
      }
    }

◆ createArgs()

Bundle io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.createArgs ( )

inlineprotected

Creates a Bundle of arguments that are assigned to the new FlutterFragment.

Subclasses should override this method to add new properties to the Bundle. Subclasses must call through to the super method to collect all existing property values.

Definition at line 701 of file FlutterFragment.java.

                                  {
      Bundle args = new Bundle();
      args.putString(ARG_CACHED_ENGINE_ID, engineId);
      args.putBoolean(ARG_DESTROY_ENGINE_WITH_FRAGMENT, destroyEngineWithFragment);
      args.putBoolean(ARG_HANDLE_DEEPLINKING, handleDeeplinking);
      args.putString(
          ARG_FLUTTERVIEW_RENDER_MODE,
          renderMode != null ? renderMode.name() : RenderMode.surface.name());
      args.putString(
          ARG_FLUTTERVIEW_TRANSPARENCY_MODE,
          transparencyMode != null ? transparencyMode.name() : TransparencyMode.transparent.name());
      args.putBoolean(ARG_SHOULD_ATTACH_ENGINE_TO_ACTIVITY, shouldAttachEngineToActivity);
      args.putBoolean(
          ARG_SHOULD_AUTOMATICALLY_HANDLE_ON_BACK_PRESSED, shouldAutomaticallyHandleOnBackPressed);
      args.putBoolean(ARG_SHOULD_DELAY_FIRST_ANDROID_VIEW_DRAW, shouldDelayFirstAndroidViewDraw);
      return args;
    }

◆ destroyEngineWithFragment()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.destroyEngineWithFragment ( boolean destroyEngineWithFragment )

inline

Pass true to destroy the cached io.flutter.embedding.engine.FlutterEngine when this FlutterFragment is destroyed, or false for the cached io.flutter.embedding.engine.FlutterEngine to outlive this FlutterFragment.

Definition at line 574 of file FlutterFragment.java.

                                           {
      this.destroyEngineWithFragment = destroyEngineWithFragment;
      return this;
    }

◆ handleDeeplinking()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.handleDeeplinking ( @NonNull Boolean handleDeeplinking )

inline

Whether to handle the deeplinking from the Intent automatically if the getInitialRoute returns null.

Definition at line 611 of file FlutterFragment.java.

                                                                                             {
      this.handleDeeplinking = handleDeeplinking;
      return this;
    }

◆ renderMode()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.renderMode ( @NonNull RenderMode renderMode )

inline

Render Flutter either as a RenderMode#surface or a RenderMode#texture. You should use surface unless you have a specific reason to use texture. texture comes with a significant performance impact, but texture can be displayed beneath other Android Views and animated, whereas surface cannot.

Definition at line 587 of file FlutterFragment.java.

                                                                                  {
      this.renderMode = renderMode;
      return this;
    }

◆ shouldAttachEngineToActivity()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.shouldAttachEngineToActivity ( boolean shouldAttachEngineToActivity )

inline

Whether or not this FlutterFragment should automatically attach its Activity as a control surface for its io.flutter.embedding.engine.FlutterEngine.

Control surfaces are used to provide Android resources and lifecycle events to plugins that are attached to the io.flutter.embedding.engine.FlutterEngine. If shouldAttachEngineToActivity is true then this FlutterFragment will connect its io.flutter.embedding.engine.FlutterEngine to the surrounding Activity, along with any plugins that are registered with that FlutterEngine. This allows plugins to access the Activity, as well as receive Activity-specific calls, e.g., android.app.Activity#onNewIntent(Intent). If shouldAttachEngineToActivity is false, then this FlutterFragment will not automatically manage the connection between its io.flutter.embedding.engine.FlutterEngine and the surrounding Activity. The Activity will need to be manually connected to this FlutterFragment's io.flutter.embedding.engine.FlutterEngine by the app developer. See FlutterEngine#getActivityControlSurface().

One reason that a developer might choose to manually manage the relationship between the Activity and io.flutter.embedding.engine.FlutterEngine is if the developer wants to move the FlutterEngine somewhere else. For example, a developer might want the io.flutter.embedding.engine.FlutterEngine to outlive the surrounding Activity so that it can be used later in a different Activity. To accomplish this, the io.flutter.embedding.engine.FlutterEngine will need to be disconnected from the surrounding Activity at an unusual time, preventing this FlutterFragment from correctly managing the relationship between the io.flutter.embedding.engine.FlutterEngine and the surrounding Activity.

Another reason that a developer might choose to manually manage the relationship between the Activity and io.flutter.embedding.engine.FlutterEngine is if the developer wants to prevent, or explicitly control when the io.flutter.embedding.engine.FlutterEngine's plugins have access to the surrounding Activity. For example, imagine that this FlutterFragment only takes up part of the screen and the app developer wants to ensure that none of the Flutter plugins are able to manipulate the surrounding Activity. In this case, the developer would not want the io.flutter.embedding.engine.FlutterEngine to have access to the Activity, which can be accomplished by setting shouldAttachEngineToActivity to false.

Definition at line 654 of file FlutterFragment.java.

                                              {
      this.shouldAttachEngineToActivity = shouldAttachEngineToActivity;
      return this;
    }

◆ shouldAutomaticallyHandleOnBackPressed()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.shouldAutomaticallyHandleOnBackPressed ( boolean shouldAutomaticallyHandleOnBackPressed )

inline

Whether or not this FlutterFragment should automatically receive onBackPressed() events, rather than requiring an explicit activity call through. Disabled by default.

When enabled, the activity will automatically dispatch back-press events to the fragment's OnBackPressedCallback, instead of requiring the activity to manually call onBackPressed() in client code. If enabled, do not invoke onBackPressed() manually.

Enabling this behavior relies on explicit behavior in popSystemNavigator(). It's not recommended to override that method when enabling this attribute, but if you do, you should always fall back to calling super.popSystemNavigator() when not relying on custom behavior.

Definition at line 676 of file FlutterFragment.java.

                                                        {
      this.shouldAutomaticallyHandleOnBackPressed = shouldAutomaticallyHandleOnBackPressed;
      return this;
    }

◆ shouldDelayFirstAndroidViewDraw()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.shouldDelayFirstAndroidViewDraw ( @NonNull boolean shouldDelayFirstAndroidViewDraw )

inline

Whether to delay the Android drawing pass till after the Flutter UI has been displayed.

See {#link FlutterActivityAndFragmentDelegate::onCreateView} for more details.

Definition at line 688 of file FlutterFragment.java.

                                                          {
      this.shouldDelayFirstAndroidViewDraw = shouldDelayFirstAndroidViewDraw;
      return this;
    }

◆ transparencyMode()

CachedEngineFragmentBuilder io.flutter.embedding.android.FlutterFragment.CachedEngineFragmentBuilder.transparencyMode ( @NonNull TransparencyMode transparencyMode )

inline

Support a TransparencyMode#transparent background within io.flutter.embedding.android.FlutterView, or force an TransparencyMode#opaque background.

See TransparencyMode for implications of this selection.

Definition at line 600 of file FlutterFragment.java.

                                                    {
      this.transparencyMode = transparencyMode;
      return this;
    }

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

shell/platform/android/io/flutter/embedding/android/FlutterFragment.java

Public Member Functions

Protected Member Functions

Package Functions

Detailed Description

Constructor & Destructor Documentation

◆ CachedEngineFragmentBuilder()

Member Function Documentation

◆ build()

◆ createArgs()

◆ destroyEngineWithFragment()

◆ handleDeeplinking()

◆ renderMode()

◆ shouldAttachEngineToActivity()

◆ shouldAutomaticallyHandleOnBackPressed()

◆ shouldDelayFirstAndroidViewDraw()

◆ transparencyMode()