Package io.flutter.embedding.android

# Class FlutterFragment

java.lang.Object
androidx.fragment.app.Fragment
io.flutter.embedding.android.FlutterFragment

All Implemented Interfaces:
  `ComponentCallbacks`, `ComponentCallbacks2`, `View.OnCreateContextMenuListener`, `androidx.activity.result.ActivityResultCaller`, `androidx.lifecycle.HasDefaultViewModelProviderFactory`, `androidx.lifecycle.LifecycleOwner`, `androidx.lifecycle.ViewModelStoreOwner`, `androidx.savedstate.SavedStateRegistryOwner`, `io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.DelegateFactory`, `FlutterEngineConfigurator`, `FlutterEngineProvider`, `PlatformPlugin.PlatformPluginDelegate`

public class FlutterFragment extends androidx.fragment.app.Fragment implements ComponentCallbacks2, io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.DelegateFactory
`Fragment` which displays a Flutter UI that takes up all available `Fragment` space.

Using a `FlutterFragment` requires forwarding a number of calls from an `Activity` to ensure that the internal Flutter app behaves as expected:

1. `onPostResume()`
2. `onBackPressed()`
3. `onRequestPermissionsResult(int, String[], int[])`
4. `onNewIntent(Intent)`
5. `onUserLeaveHint()`

`onBackPressed()` does not need to be called through if the fragment is constructed by one of the builders with `shouldAutomaticallyHandleOnBackPressed(true)`.

Additionally, when starting an `Activity` for a result from this `Fragment`, be sure to invoke `Fragment.startActivityForResult(Intent, int)` rather than `Activity.startActivityForResult(Intent, int)`. If the `Activity` version of the method is invoked then this `Fragment` will never receive its `Fragment.onActivityResult(int, int, Intent)` callback.

If convenient, consider using a `FlutterActivity` instead of a `FlutterFragment` to avoid the work of forwarding calls.

`FlutterFragment` supports the use of an existing, cached `FlutterEngine`. To use a cached `FlutterEngine`, ensure that the `FlutterEngine` is stored in `FlutterEngineCache` and then use `withCachedEngine(String)` to build a `FlutterFragment` with the cached `FlutterEngine`'s ID.

It is generally recommended to use a cached `FlutterEngine` to avoid a momentary delay when initializing a new `FlutterEngine`. The two exceptions to using a cached `FlutterEngine` are:

- When `FlutterFragment` is in the first `Activity` displayed by the app, because pre-warming a `FlutterEngine` would have no impact in this situation.
- When you are unsure when/if you will need to display a Flutter experience.

The following illustrates how to pre-warm and cache a `FlutterEngine`:

     // Create and pre-warm a FlutterEngine.
     FlutterEngineGroup group = new FlutterEngineGroup(context);
     FlutterEngine flutterEngine = group.createAndRunDefaultEngine(context);
     flutterEngine
       .getDartExecutor()
       .executeDartEntrypoint(DartEntrypoint.createDefault());

     // Cache the pre-warmed FlutterEngine in the FlutterEngineCache.
     FlutterEngineCache.getInstance().put("my_engine", flutterEngine);

If Flutter is needed in a location that can only use a `View`, consider using a `FlutterView`. Using a `FlutterView` requires forwarding some calls from an `Activity`, as well as forwarding lifecycle calls from an `Activity` or a `Fragment`.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static class`
  `FlutterFragment.CachedEngineFragmentBuilder`
  Builder that creates a new `FlutterFragment` that uses a cached `FlutterEngine` with `arguments` that correspond to the values set on this `Builder`.
  `static class`
  `FlutterFragment.NewEngineFragmentBuilder`
  Builder that creates a new `FlutterFragment` with `arguments` that correspond to the values set on this `NewEngineFragmentBuilder`.
  `static class`
  `FlutterFragment.NewEngineInGroupFragmentBuilder`
  Builder that creates a new `FlutterFragment` that uses a cached `FlutterEngineGroup` to create a new `FlutterEngine` with `arguments` that correspond to the values set on this `Builder`.

  ## Nested classes/interfaces inherited from class androidx.fragment.app.Fragment

  `androidx.fragment.app.Fragment.InstantiationException, androidx.fragment.app.Fragment.SavedState`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected static final String`
  `ARG_APP_BUNDLE_PATH`
  Path to Flutter's Dart code.
  `protected static final String`
  `ARG_CACHED_ENGINE_GROUP_ID`
  `protected static final String`
  `ARG_CACHED_ENGINE_ID`
  The ID of a `FlutterEngine` cached in `FlutterEngineCache` that will be used within the created `FlutterFragment`.
  `protected static final String`
  `ARG_DART_ENTRYPOINT`
  The Dart entrypoint method name that is executed upon initialization.
  `protected static final String`
  `ARG_DART_ENTRYPOINT_ARGS`
  The Dart entrypoint arguments that is executed upon initialization.
  `protected static final String`
  `ARG_DART_ENTRYPOINT_URI`
  The Dart entrypoint method's URI that is executed upon initialization.
  `protected static final String`
  `ARG_DESTROY_ENGINE_WITH_FRAGMENT`
  True if the `FlutterEngine` in the created `FlutterFragment` should be destroyed when the `FlutterFragment` is destroyed, false if the `FlutterEngine` should outlive the `FlutterFragment`.
  `protected static final String`
  `ARG_ENABLE_STATE_RESTORATION`
  True if the framework state in the engine attached to this engine should be stored and restored when this fragment is created and destroyed.
  `protected static final String`
  `ARG_FLUTTER_INITIALIZATION_ARGS`
  Flutter shell arguments.
  `protected static final String`
  `ARG_FLUTTERVIEW_RENDER_MODE`
  `RenderMode` to be used for the `FlutterView` in this `FlutterFragment`
  `protected static final String`
  `ARG_FLUTTERVIEW_TRANSPARENCY_MODE`
  `TransparencyMode` to be used for the `FlutterView` in this `FlutterFragment`
  `protected static final String`
  `ARG_HANDLE_DEEPLINKING`
  Whether the activity delegate should handle the deeplinking request.
  `protected static final String`
  `ARG_INITIAL_ROUTE`
  Initial Flutter route that is rendered in a Navigator widget.
  `protected static final String`
  `ARG_SHOULD_ATTACH_ENGINE_TO_ACTIVITY`
  See `shouldAttachEngineToActivity()`.
  `protected static final String`
  `ARG_SHOULD_AUTOMATICALLY_HANDLE_ON_BACK_PRESSED`
  True if the fragment should receive `onBackPressed()` events automatically, without requiring an explicit activity call through.
  `protected static final String`
  `ARG_SHOULD_DELAY_FIRST_ANDROID_VIEW_DRAW`
  Whether to delay the Android drawing pass till after the Flutter UI has been displayed.
  `static final int`
  `FLUTTER_VIEW_ID`
  The ID of the `FlutterView` created by this activity.

  ### Fields inherited from class androidx.fragment.app.Fragment

  `mPreviousWho`

  ### Fields inherited from interface android.content.ComponentCallbacks2

  `TRIM_MEMORY_BACKGROUND, TRIM_MEMORY_COMPLETE, TRIM_MEMORY_MODERATE, TRIM_MEMORY_RUNNING_CRITICAL, TRIM_MEMORY_RUNNING_LOW, TRIM_MEMORY_RUNNING_MODERATE, TRIM_MEMORY_UI_HIDDEN`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `FlutterFragment()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `boolean`
  `attachToEngineAutomatically()`
  Whether to automatically attach the `FlutterView` to the engine.
  `void`
  `cancelBackGesture()`
  `void`
  `cleanUpFlutterEngine(FlutterEngine flutterEngine)`
  Hook for the host to cleanup references that were established in `configureFlutterEngine(FlutterEngine)` before the host is destroyed or detached.
  `void`
  `commitBackGesture()`
  `void`
  `configureFlutterEngine(FlutterEngine flutterEngine)`
  Configures a `FlutterEngine` after its creation.
  `static FlutterFragment`
  `createDefault()`
  Creates a `FlutterFragment` with a default configuration.
  `io.flutter.embedding.android.FlutterActivityAndFragmentDelegate`
  `createDelegate(io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.Host host)`
  Default delegate factory that creates a simple FlutterActivityAndFragmentDelegate instance.
  `void`
  `detachFromFlutterEngine()`
  `Activity`
  `getActivity()`
  Returns the host `Activity` or the `Activity` that is currently attached to the host `Fragment`.
  `String`
  `getAppBundlePath()`
  A custom path to the bundle that contains this Flutter app's resources, e.g., Dart code snapshots.
  `boolean`
  `getBackCallbackState()`
  `String`
  `getCachedEngineGroupId()`
  Returns the ID of a statically cached `FlutterEngineGroup` to use within this `FlutterFragment`, or `null` if this `FlutterFragment` does not want to use a cached `FlutterEngineGroup`.
  `String`
  `getCachedEngineId()`
  Returns the ID of a statically cached `FlutterEngine` to use within this `FlutterFragment`, or `null` if this `FlutterFragment` does not want to use a cached `FlutterEngine`.
  `Context`
  `getContext()`
  Returns the `Context` that backs the host `Activity` or `Fragment`.
  `List<String>`
  `getDartEntrypointArgs()`
  The Dart entrypoint arguments will be passed as a list of string to Dart's entrypoint function.
  `String`
  `getDartEntrypointFunctionName()`
  Returns the name of the Dart method that this `FlutterFragment` should execute to start a Flutter app.
  `String`
  `getDartEntrypointLibraryUri()`
  Returns the library URI of the Dart method that this `FlutterFragment` should execute to start a Flutter app.
  `ExclusiveAppComponent<Activity>`
  `getExclusiveAppComponent()`
  Returns the Android App Component exclusively attached to `FlutterEngine`.
  `FlutterEngine`
  `getFlutterEngine()`
  Hook for subclasses to obtain a reference to the `FlutterEngine` that is owned by this `FlutterActivity`.
  `FlutterShellArgs`
  `getFlutterShellArgs()`
  `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain Flutter shell arguments when initializing Flutter.
  `String`
  `getInitialRoute()`
  Returns the initial route that should be rendered within Flutter, once the Flutter app starts.
  `androidx.lifecycle.Lifecycle`
  `getLifecycle()`
  Returns the `Lifecycle` that backs the host `Activity` or `Fragment`.
  `RenderMode`
  `getRenderMode()`
  Returns the desired `RenderMode` for the `FlutterView` displayed in this `FlutterFragment`.
  `TransparencyMode`
  `getTransparencyMode()`
  Returns the desired `TransparencyMode` for the `FlutterView` displayed in this `FlutterFragment`.
  `void`
  `onActivityResult(int requestCode, int resultCode, Intent data)`
  A result has been returned after an invocation of `Fragment.startActivityForResult(Intent, int)`.
  `void`
  `onAttach(Context context)`
  `void`
  `onBackPressed()`
  The hardware back button was pressed.
  `void`
  `onCreate(Bundle savedInstanceState)`
  `View`
  `onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)`
  `void`
  `onDestroyView()`
  `void`
  `onDetach()`
  `void`
  `onFlutterSurfaceViewCreated(FlutterSurfaceView flutterSurfaceView)`
  `void`
  `onFlutterTextureViewCreated(FlutterTextureView flutterTextureView)`
  `void`
  `onFlutterUiDisplayed()`
  Invoked after the `FlutterView` within this `FlutterFragment` starts rendering pixels to the screen.
  `void`
  `onFlutterUiNoLongerDisplayed()`
  Invoked after the `FlutterView` within this `FlutterFragment` stops rendering pixels to the screen.
  `void`
  `onNewIntent(Intent intent)`
  A new Intent was received by the `Activity` that currently owns this `Fragment`.
  `void`
  `onPause()`
  `void`
  `onPostResume()`
  `void`
  `onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults)`
  The result of a permission request has been received.
  `void`
  `onResume()`
  `void`
  `onSaveInstanceState(Bundle outState)`
  `void`
  `onStart()`
  `void`
  `onStop()`
  `void`
  `onTrimMemory(int level)`
  Callback invoked when memory is low.
  `void`
  `onUserLeaveHint()`
  The `Activity` that owns this `Fragment` is about to go to the background as the result of a user's choice/action, i.e., not as the result of an OS decision.
  `void`
  `onViewCreated(View view, Bundle savedInstanceState)`
  `boolean`
  `popSystemNavigator()`
  Allow implementer to customize the behavior needed when the Flutter framework calls to pop the Android-side navigation stack.
  `FlutterEngine`
  `provideFlutterEngine(Context context)`
  Hook for subclasses to return a `FlutterEngine` with whatever configuration is desired.
  `PlatformPlugin`
  `providePlatformPlugin(Activity activity, FlutterEngine flutterEngine)`
  `io.flutter.plugin.view.SensitiveContentPlugin`
  `provideSensitiveContentPlugin(Activity activity, FlutterEngine flutterEngine)`
  `void`
  `setFrameworkHandlesBack(boolean frameworkHandlesBack)`
  The Flutter application would or would not like to handle navigation pop events itself.
  `boolean`
  `shouldAttachEngineToActivity()`
  See `shouldAttachEngineToActivity()` and `shouldAttachEngineToActivity()`.
  `boolean`
  `shouldDestroyEngineWithHost()`
  Returns false if the `FlutterEngine` within this `FlutterFragment` should outlive the `FlutterFragment`, itself.
  `boolean`
  `shouldDispatchAppLifecycleState()`
  Give the host application a chance to take control of the app lifecycle events.
  `boolean`
  `shouldHandleDeeplinking()`
  Whether to handle the deeplinking from the `Intent` automatically if the `getInitialRoute` returns null.
  `boolean`
  `shouldRestoreAndSaveState()`
  `void`
  `startBackGesture(androidx.activity.BackEventCompat backEvent)`
  `void`
  `updateBackGestureProgress(androidx.activity.BackEventCompat backEvent)`
  `void`
  `updateSystemUiOverlays()`
  `static FlutterFragment.CachedEngineFragmentBuilder`
  `withCachedEngine(String engineId)`
  Returns a `FlutterFragment.CachedEngineFragmentBuilder` to create a `FlutterFragment` with a cached `FlutterEngine` in `FlutterEngineCache`.
  `static FlutterFragment.NewEngineFragmentBuilder`
  `withNewEngine()`
  Returns a `FlutterFragment.NewEngineFragmentBuilder` to create a `FlutterFragment` with a new `FlutterEngine` and a desired engine configuration.
  `static FlutterFragment.NewEngineInGroupFragmentBuilder`
  `withNewEngineInGroup(String engineGroupId)`
  Returns a `FlutterFragment.NewEngineInGroupFragmentBuilder` to create a `FlutterFragment` with a cached `FlutterEngineGroup` in `FlutterEngineGroupCache`.

  ### Methods inherited from class androidx.fragment.app.Fragment

  `dump, equals, getActivity, getAllowEnterTransitionOverlap, getAllowReturnTransitionOverlap, getArguments, getChildFragmentManager, getContext, getDefaultViewModelCreationExtras, getDefaultViewModelProviderFactory, getEnterTransition, getExitTransition, getFragmentManager, getHost, getId, getLayoutInflater, getLayoutInflater, getLifecycle, getLoaderManager, getParentFragment, getParentFragmentManager, getReenterTransition, getResources, getRetainInstance, getReturnTransition, getSavedStateRegistry, getSharedElementEnterTransition, getSharedElementReturnTransition, getString, getString, getTag, getTargetFragment, getTargetRequestCode, getText, getUserVisibleHint, getView, getViewLifecycleOwner, getViewLifecycleOwnerLiveData, getViewModelStore, hashCode, hasOptionsMenu, instantiate, instantiate, isAdded, isDetached, isHidden, isInLayout, isMenuVisible, isRemoving, isResumed, isStateSaved, isVisible, onActivityCreated, onAttach, onAttachFragment, onConfigurationChanged, onContextItemSelected, onCreateAnimation, onCreateAnimator, onCreateContextMenu, onCreateOptionsMenu, onDestroy, onDestroyOptionsMenu, onGetLayoutInflater, onHiddenChanged, onInflate, onInflate, onLowMemory, onMultiWindowModeChanged, onOptionsItemSelected, onOptionsMenuClosed, onPictureInPictureModeChanged, onPrepareOptionsMenu, onPrimaryNavigationFragmentChanged, onViewStateRestored, postponeEnterTransition, postponeEnterTransition, registerForActivityResult, registerForActivityResult, registerForContextMenu, requestPermissions, requireActivity, requireArguments, requireContext, requireFragmentManager, requireHost, requireParentFragment, requireView, setAllowEnterTransitionOverlap, setAllowReturnTransitionOverlap, setArguments, setEnterSharedElementCallback, setEnterTransition, setExitSharedElementCallback, setExitTransition, setHasOptionsMenu, setInitialSavedState, setMenuVisibility, setReenterTransition, setRetainInstance, setReturnTransition, setSharedElementEnterTransition, setSharedElementReturnTransition, setTargetFragment, setUserVisibleHint, shouldShowRequestPermissionRationale, startActivity, startActivity, startActivityForResult, startActivityForResult, startIntentSenderForResult, startPostponedEnterTransition, toString, unregisterForContextMenu`

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

  ### Methods inherited from interface android.content.ComponentCallbacks

  `onConfigurationChanged, onLowMemory`

- ## Field Details

  - ### FLUTTER_VIEW_ID

    public static final int FLUTTER_VIEW_ID
    The ID of the `FlutterView` created by this activity.

    This ID can be used to lookup `FlutterView` in the Android view hierarchy. For more, see `View.findViewById(int)`.

  - ### ARG_DART_ENTRYPOINT

    protected static final String ARG_DART_ENTRYPOINT
    The Dart entrypoint method name that is executed upon initialization.
    See Also:
      - Constant Field Values

  - ### ARG_DART_ENTRYPOINT_URI

    protected static final String ARG_DART_ENTRYPOINT_URI
    The Dart entrypoint method's URI that is executed upon initialization.
    See Also:
      - Constant Field Values

  - ### ARG_DART_ENTRYPOINT_ARGS

    protected static final String ARG_DART_ENTRYPOINT_ARGS
    The Dart entrypoint arguments that is executed upon initialization.
    See Also:
      - Constant Field Values

  - ### ARG_INITIAL_ROUTE

    protected static final String ARG_INITIAL_ROUTE
    Initial Flutter route that is rendered in a Navigator widget.
    See Also:
      - Constant Field Values

  - ### ARG_HANDLE_DEEPLINKING

    protected static final String ARG_HANDLE_DEEPLINKING
    Whether the activity delegate should handle the deeplinking request.
    See Also:
      - Constant Field Values

  - ### ARG_APP_BUNDLE_PATH

    protected static final String ARG_APP_BUNDLE_PATH
    Path to Flutter's Dart code.
    See Also:
      - Constant Field Values

  - ### ARG_SHOULD_DELAY_FIRST_ANDROID_VIEW_DRAW

    protected static final String ARG_SHOULD_DELAY_FIRST_ANDROID_VIEW_DRAW
    Whether to delay the Android drawing pass till after the Flutter UI has been displayed.
    See Also:
      - Constant Field Values

  - ### ARG_FLUTTER_INITIALIZATION_ARGS

    protected static final String ARG_FLUTTER_INITIALIZATION_ARGS
    Flutter shell arguments.
    See Also:
      - Constant Field Values

  - ### ARG_FLUTTERVIEW_RENDER_MODE

    protected static final String ARG_FLUTTERVIEW_RENDER_MODE
    `RenderMode` to be used for the `FlutterView` in this `FlutterFragment`
    See Also:
      - Constant Field Values

  - ### ARG_FLUTTERVIEW_TRANSPARENCY_MODE

    protected static final String ARG_FLUTTERVIEW_TRANSPARENCY_MODE
    `TransparencyMode` to be used for the `FlutterView` in this `FlutterFragment`
    See Also:
      - Constant Field Values

  - ### ARG_SHOULD_ATTACH_ENGINE_TO_ACTIVITY

    protected static final String ARG_SHOULD_ATTACH_ENGINE_TO_ACTIVITY
    See `shouldAttachEngineToActivity()`.
    See Also:
      - Constant Field Values

  - ### ARG_CACHED_ENGINE_ID

    protected static final String ARG_CACHED_ENGINE_ID
    The ID of a `FlutterEngine` cached in `FlutterEngineCache` that will be used within the created `FlutterFragment`.
    See Also:
      - Constant Field Values

  - ### ARG_CACHED_ENGINE_GROUP_ID

    protected static final String ARG_CACHED_ENGINE_GROUP_ID
    See Also:
      - Constant Field Values

  - ### ARG_DESTROY_ENGINE_WITH_FRAGMENT

    protected static final String ARG_DESTROY_ENGINE_WITH_FRAGMENT
    True if the `FlutterEngine` in the created `FlutterFragment` should be destroyed when the `FlutterFragment` is destroyed, false if the `FlutterEngine` should outlive the `FlutterFragment`.
    See Also:
      - Constant Field Values

  - ### ARG_ENABLE_STATE_RESTORATION

    protected static final String ARG_ENABLE_STATE_RESTORATION
    True if the framework state in the engine attached to this engine should be stored and restored when this fragment is created and destroyed.
    See Also:
      - Constant Field Values

  - ### ARG_SHOULD_AUTOMATICALLY_HANDLE_ON_BACK_PRESSED

    protected static final String ARG_SHOULD_AUTOMATICALLY_HANDLE_ON_BACK_PRESSED
    True if the fragment should receive `onBackPressed()` events automatically, without requiring an explicit activity call through.
    See Also:
      - Constant Field Values

- ## Constructor Details

  - ### FlutterFragment

    public FlutterFragment()

- ## Method Details

  - ### createDefault

    @NonNull public static FlutterFragment createDefault()
    Creates a `FlutterFragment` with a default configuration.

    `FlutterFragment`'s default configuration creates a new `FlutterEngine` within the `FlutterFragment` and uses the following settings:

    - Dart entrypoint: "main"
    - Initial route: "/"
    - Render mode: surface
    - Transparency mode: transparent

    To use a new `FlutterEngine` with different settings, use `withNewEngine()`.

    To use a cached `FlutterEngine` instead of creating a new one, use `withCachedEngine(String)`.

  - ### withNewEngine

    @NonNull public static FlutterFragment.NewEngineFragmentBuilder withNewEngine()
    Returns a `FlutterFragment.NewEngineFragmentBuilder` to create a `FlutterFragment` with a new `FlutterEngine` and a desired engine configuration.

  - ### withCachedEngine

    @NonNull public static FlutterFragment.CachedEngineFragmentBuilder withCachedEngine(@NonNull String engineId)
    Returns a `FlutterFragment.CachedEngineFragmentBuilder` to create a `FlutterFragment` with a cached `FlutterEngine` in `FlutterEngineCache`.

    An `IllegalStateException` will be thrown during the lifecycle of the `FlutterFragment` if a cached `FlutterEngine` is requested but does not exist in the cache.

    To create a `FlutterFragment` that uses a new `FlutterEngine`, use `createDefault()` or `withNewEngine()`.

  - ### withNewEngineInGroup

    @NonNull public static FlutterFragment.NewEngineInGroupFragmentBuilder withNewEngineInGroup(@NonNull String engineGroupId)
    Returns a `FlutterFragment.NewEngineInGroupFragmentBuilder` to create a `FlutterFragment` with a cached `FlutterEngineGroup` in `FlutterEngineGroupCache`.

    An `IllegalStateException` will be thrown during the lifecycle of the `FlutterFragment` if a cached `FlutterEngineGroup` is requested but does not exist in the `FlutterEngineGroupCache`.

  - ### createDelegate

    public io.flutter.embedding.android.FlutterActivityAndFragmentDelegate createDelegate(io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.Host host)
    Default delegate factory that creates a simple FlutterActivityAndFragmentDelegate instance.
    Specified by:
      `createDelegate` in interface `io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.DelegateFactory`

  - ### getExclusiveAppComponent

    public ExclusiveAppComponent<Activity> getExclusiveAppComponent()
    Returns the Android App Component exclusively attached to `FlutterEngine`.

  - ### onAttach

    public void onAttach(@NonNull Context context)
    Overrides:
      `onAttach` in class `androidx.fragment.app.Fragment`

  - ### onCreate

    public void onCreate(@Nullable Bundle savedInstanceState)
    Overrides:
      `onCreate` in class `androidx.fragment.app.Fragment`

  - ### onCreateView

    @Nullable public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState)
    Overrides:
      `onCreateView` in class `androidx.fragment.app.Fragment`

  - ### onStart

    public void onStart()
    Overrides:
      `onStart` in class `androidx.fragment.app.Fragment`

  - ### onResume

    public void onResume()
    Overrides:
      `onResume` in class `androidx.fragment.app.Fragment`

  - ### onPostResume

    public void onPostResume()

  - ### onPause

    public void onPause()
    Overrides:
      `onPause` in class `androidx.fragment.app.Fragment`

  - ### onStop

    public void onStop()
    Overrides:
      `onStop` in class `androidx.fragment.app.Fragment`

  - ### onViewCreated

    public void onViewCreated(View view, Bundle savedInstanceState)
    Overrides:
      `onViewCreated` in class `androidx.fragment.app.Fragment`

  - ### onDestroyView

    public void onDestroyView()
    Overrides:
      `onDestroyView` in class `androidx.fragment.app.Fragment`

  - ### onSaveInstanceState

    public void onSaveInstanceState(Bundle outState)
    Overrides:
      `onSaveInstanceState` in class `androidx.fragment.app.Fragment`

  - ### detachFromFlutterEngine

    public void detachFromFlutterEngine()

  - ### onDetach

    public void onDetach()
    Overrides:
      `onDetach` in class `androidx.fragment.app.Fragment`

  - ### onRequestPermissionsResult

    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
    The result of a permission request has been received.

    See `Activity.onRequestPermissionsResult(int, String[], int[])`

    Overrides:
      `onRequestPermissionsResult` in class `androidx.fragment.app.Fragment`
    Parameters:
      `requestCode` - identifier passed with the initial permission request
      `permissions` - permissions that were requested
      `grantResults` - permission grants or denials

  - ### onNewIntent

    public void onNewIntent(@NonNull Intent intent)
    A new Intent was received by the `Activity` that currently owns this `Fragment`.

    See `Activity.onNewIntent(Intent)`

    Parameters:
      `intent` - new Intent

  - ### onBackPressed

    public void onBackPressed()
    The hardware back button was pressed.

    If the fragment uses `shouldAutomaticallyHandleOnBackPressed(true)`, this method should not be called through. It will be called automatically instead.

    See `Activity.onBackPressed()`

  - ### startBackGesture

    @RequiresApi(34) public void startBackGesture(@NonNull androidx.activity.BackEventCompat backEvent)

  - ### updateBackGestureProgress

    @RequiresApi(34) public void updateBackGestureProgress(@NonNull androidx.activity.BackEventCompat backEvent)

  - ### commitBackGesture

    @RequiresApi(34) public void commitBackGesture()

  - ### cancelBackGesture

    @RequiresApi(34) public void cancelBackGesture()

  - ### onActivityResult

    public void onActivityResult(int requestCode, int resultCode, Intent data)
    A result has been returned after an invocation of `Fragment.startActivityForResult(Intent, int)`.

    Overrides:
      `onActivityResult` in class `androidx.fragment.app.Fragment`
    Parameters:
      `requestCode` - request code sent with `Fragment.startActivityForResult(Intent, int)`
      `resultCode` - code representing the result of the `Activity` that was launched
      `data` - any corresponding return data, held within an `Intent`

  - ### onUserLeaveHint

    public void onUserLeaveHint()
    The `Activity` that owns this `Fragment` is about to go to the background as the result of a user's choice/action, i.e., not as the result of an OS decision.

    See `Activity.onUserLeaveHint()`

  - ### onTrimMemory

    public void onTrimMemory(int level)
    Callback invoked when memory is low.

    This implementation forwards a memory pressure warning to the running Flutter app.

    Specified by:
      `onTrimMemory` in interface `ComponentCallbacks2`
    Parameters:
      `level` - level

  - ### getFlutterShellArgs

    @NonNull public FlutterShellArgs getFlutterShellArgs()
    `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain Flutter shell arguments when initializing Flutter.

  - ### getCachedEngineId

    @Nullable public String getCachedEngineId()
    Returns the ID of a statically cached `FlutterEngine` to use within this `FlutterFragment`, or `null` if this `FlutterFragment` does not want to use a cached `FlutterEngine`.

  - ### getCachedEngineGroupId

    @Nullable public String getCachedEngineGroupId()
    Returns the ID of a statically cached `FlutterEngineGroup` to use within this `FlutterFragment`, or `null` if this `FlutterFragment` does not want to use a cached `FlutterEngineGroup`.

  - ### shouldDestroyEngineWithHost

    public boolean shouldDestroyEngineWithHost()
    Returns false if the `FlutterEngine` within this `FlutterFragment` should outlive the `FlutterFragment`, itself.

    Defaults to true if no custom `is provided`, false if a custom `FlutterEngine` is provided.

  - ### getDartEntrypointFunctionName

    @NonNull public String getDartEntrypointFunctionName()
    Returns the name of the Dart method that this `FlutterFragment` should execute to start a Flutter app.

    Defaults to "main".

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### getDartEntrypointArgs

    @Nullable public List<String> getDartEntrypointArgs()
    The Dart entrypoint arguments will be passed as a list of string to Dart's entrypoint function.

    A value of null means do not pass any arguments to Dart's entrypoint function.

    Subclasses may override this method to directly control the Dart entrypoint arguments.

  - ### getDartEntrypointLibraryUri

    @Nullable public String getDartEntrypointLibraryUri()
    Returns the library URI of the Dart method that this `FlutterFragment` should execute to start a Flutter app.

    Defaults to null (example value: "package:foo/bar.dart").

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### getAppBundlePath

    @NonNull public String getAppBundlePath()
    A custom path to the bundle that contains this Flutter app's resources, e.g., Dart code snapshots.

    When unspecified, the value is null, which defaults to the app bundle path defined in `FlutterLoader.findAppBundlePath()`.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### getInitialRoute

    @Nullable public String getInitialRoute()
    Returns the initial route that should be rendered within Flutter, once the Flutter app starts.

    Defaults to `null`, which signifies a route of "/" in Flutter.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### getRenderMode

    @NonNull public RenderMode getRenderMode()
    Returns the desired `RenderMode` for the `FlutterView` displayed in this `FlutterFragment`.

    Defaults to `RenderMode.surface`.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### getTransparencyMode

    @NonNull public TransparencyMode getTransparencyMode()
    Returns the desired `TransparencyMode` for the `FlutterView` displayed in this `FlutterFragment`.

    Defaults to `TransparencyMode.transparent`.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### provideFlutterEngine

    @Nullable public FlutterEngine provideFlutterEngine(@NonNull Context context)
    Hook for subclasses to return a `FlutterEngine` with whatever configuration is desired.

    By default this method defers to this `FlutterFragment`'s surrounding `Activity`, if that `Activity` implements `FlutterEngineProvider`. If this method is overridden, the surrounding `Activity` will no longer be given an opportunity to provide a `FlutterEngine`, unless the subclass explicitly implements that behavior.

    Consider returning a cached `FlutterEngine` instance from this method to avoid the typical warm-up time that a new `FlutterEngine` instance requires.

    If null is returned then a new default `FlutterEngine` will be created to back this `FlutterFragment`.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

    Specified by:
      `provideFlutterEngine` in interface `FlutterEngineProvider`
    Parameters:
      `context` - The current context. e.g. An activity.
    Returns:
      The Flutter engine.

  - ### getFlutterEngine

    @Nullable public FlutterEngine getFlutterEngine()
    Hook for subclasses to obtain a reference to the `FlutterEngine` that is owned by this `FlutterActivity`.

  - ### providePlatformPlugin

    @Nullable public PlatformPlugin providePlatformPlugin(@Nullable Activity activity, @NonNull FlutterEngine flutterEngine)

  - ### provideSensitiveContentPlugin

    @Nullable public io.flutter.plugin.view.SensitiveContentPlugin provideSensitiveContentPlugin(@Nullable Activity activity, @NonNull FlutterEngine flutterEngine)

  - ### configureFlutterEngine

    public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine)
    Configures a `FlutterEngine` after its creation.

    This method is called after `provideFlutterEngine(Context)`, and after the given `FlutterEngine` has been attached to the owning `FragmentActivity`. See `ActivityControlSurface.attachToActivity(ExclusiveAppComponent, Lifecycle)`.

    It is possible that the owning `FragmentActivity` opted not to connect itself as an `ActivityControlSurface`. In that case, any configuration, e.g., plugins, must not expect or depend upon an available `Activity` at the time that this method is invoked.

    The default behavior of this method is to defer to the owning `FragmentActivity` as a `FlutterEngineConfigurator`. Subclasses can override this method if the subclass needs to override the `FragmentActivity`'s behavior, or add to it.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

    Specified by:
      `configureFlutterEngine` in interface `FlutterEngineConfigurator`
    Parameters:
      `flutterEngine` - The Flutter engine.

  - ### cleanUpFlutterEngine

    public void cleanUpFlutterEngine(@NonNull FlutterEngine flutterEngine)
    Hook for the host to cleanup references that were established in `configureFlutterEngine(FlutterEngine)` before the host is destroyed or detached.

    This method is called in `onDetach()`.

    Specified by:
      `cleanUpFlutterEngine` in interface `FlutterEngineConfigurator`
    Parameters:
      `flutterEngine` - The Flutter engine.

  - ### shouldAttachEngineToActivity

    public boolean shouldAttachEngineToActivity()
    See `shouldAttachEngineToActivity()` and `shouldAttachEngineToActivity()`.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate`

  - ### shouldHandleDeeplinking

    public boolean shouldHandleDeeplinking()
    Whether to handle the deeplinking from the `Intent` automatically if the `getInitialRoute` returns null.

  - ### onFlutterSurfaceViewCreated

    public void onFlutterSurfaceViewCreated(@NonNull FlutterSurfaceView flutterSurfaceView)

  - ### onFlutterTextureViewCreated

    public void onFlutterTextureViewCreated(@NonNull FlutterTextureView flutterTextureView)

  - ### onFlutterUiDisplayed

    public void onFlutterUiDisplayed()
    Invoked after the `FlutterView` within this `FlutterFragment` starts rendering pixels to the screen.

    This method forwards `onFlutterUiDisplayed()` to its attached `Activity`, if the attached `Activity` implements `FlutterUiDisplayListener`.

    Subclasses that override this method must call through to the `super` method.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### onFlutterUiNoLongerDisplayed

    public void onFlutterUiNoLongerDisplayed()
    Invoked after the `FlutterView` within this `FlutterFragment` stops rendering pixels to the screen.

    This method forwards `onFlutterUiNoLongerDisplayed()` to its attached `Activity`, if the attached `Activity` implements `FlutterUiDisplayListener`.

    Subclasses that override this method must call through to the `super` method.

    Used by this `FlutterFragment`'s `FlutterActivityAndFragmentDelegate.Host`

  - ### shouldRestoreAndSaveState

    public boolean shouldRestoreAndSaveState()

  - ### updateSystemUiOverlays

    public void updateSystemUiOverlays()

  - ### shouldDispatchAppLifecycleState

    public boolean shouldDispatchAppLifecycleState()
    Give the host application a chance to take control of the app lifecycle events.

    Return `false` means the host application dispatches these app lifecycle events, while return `true` means the engine dispatches these events.

    Defaults to `true`.

  - ### attachToEngineAutomatically

    public boolean attachToEngineAutomatically()
    Whether to automatically attach the `FlutterView` to the engine.

    Returning `false` means that the task of attaching the `FlutterView` to the engine will be taken over by the host application.

    Defaults to `true`.

  - ### getBackCallbackState

    public boolean getBackCallbackState()

  - ### popSystemNavigator

    public boolean popSystemNavigator()
    Allow implementer to customize the behavior needed when the Flutter framework calls to pop the Android-side navigation stack.

    Avoid overriding this method when using `shouldAutomaticallyHandleOnBackPressed(true)`. If you do, you must always `return super.popSystemNavigator()` rather than `return false`. Otherwise the navigation behavior will recurse infinitely between this method and `onBackPressed()`, breaking navigation.

    Specified by:
      `popSystemNavigator` in interface `PlatformPlugin.PlatformPluginDelegate`
    Returns:
      true if the implementation consumed the pop signal. If false, a default behavior of finishing the activity or sending the signal to `OnBackPressedDispatcher` will be executed.

  - ### setFrameworkHandlesBack

    public void setFrameworkHandlesBack(boolean frameworkHandlesBack)
    Description copied from interface: `PlatformPlugin.PlatformPluginDelegate`
    The Flutter application would or would not like to handle navigation pop events itself.

    Relevant for registering and unregistering the app's OnBackInvokedCallback for the Predictive Back feature, for example as in `FlutterActivity`.

    Specified by:
      `setFrameworkHandlesBack` in interface `PlatformPlugin.PlatformPluginDelegate`

  - ### getContext

    @NonNull Context getContext()
    Returns the `Context` that backs the host `Activity` or `Fragment`.

  - ### getActivity

    @Nullable Activity getActivity()
    Returns the host `Activity` or the `Activity` that is currently attached to the host `Fragment`.

  - ### getLifecycle

    @NonNull androidx.lifecycle.Lifecycle getLifecycle()
    Returns the `Lifecycle` that backs the host `Activity` or `Fragment`.