Package io.flutter.embedding.android

# Class FlutterActivity

java.lang.Object
android.content.Context
android.content.ContextWrapper
android.view.ContextThemeWrapper
android.app.Activity
io.flutter.embedding.android.FlutterActivity

All Implemented Interfaces:
  `ComponentCallbacks`, `ComponentCallbacks2`, `KeyEvent.Callback`, `LayoutInflater.Factory`, `LayoutInflater.Factory2`, `View.OnCreateContextMenuListener`, `Window.Callback`, `androidx.lifecycle.LifecycleOwner`, `FlutterEngineConfigurator`, `FlutterEngineProvider`, `PlatformPlugin.PlatformPluginDelegate`

public class FlutterActivity extends Activity implements androidx.lifecycle.LifecycleOwner
`Activity` which displays a fullscreen Flutter UI.

`FlutterActivity` is the simplest and most direct way to integrate Flutter within an Android app.

FlutterActivity responsibilities

`FlutterActivity` maintains the following responsibilities:

- Displays an Android launch screen.
- Configures the status bar appearance.
- Chooses the Dart execution app bundle path, entrypoint and entrypoint arguments.
- Chooses Flutter's initial route.
- Renders `Activity` transparently, if desired.
- Offers hooks for subclasses to provide and configure a `FlutterEngine`.
- Save and restore instance state, see `#shouldRestoreAndSaveState()`;

Dart entrypoint, entrypoint arguments, initial route, and app bundle path

The Dart entrypoint executed within this `Activity` is "main()" by default. To change the entrypoint that a `FlutterActivity` executes, subclass `FlutterActivity` and override `getDartEntrypointFunctionName()`. For non-main Dart entrypoints to not be tree-shaken away, you need to annotate those functions with `@pragma('vm:entry-point')` in Dart.

The Dart entrypoint arguments will be passed as a list of string to Dart's entrypoint function. It can be passed using a `FlutterActivity.NewEngineIntentBuilder` via `FlutterActivity.NewEngineIntentBuilder.dartEntrypointArgs`.

The Flutter route that is initially loaded within this `Activity` is "/". The initial route may be specified explicitly by passing the name of the route as a `String` in `FlutterActivityLaunchConfigs.EXTRA_INITIAL_ROUTE`, e.g., "my/deep/link".

The initial route can each be controlled using a `FlutterActivity.NewEngineIntentBuilder` via `FlutterActivity.NewEngineIntentBuilder.initialRoute`.

The app bundle path, Dart entrypoint, Dart entrypoint arguments, and initial route can also be controlled in a subclass of `FlutterActivity` by overriding their respective methods:

- `getAppBundlePath()`
- `getDartEntrypointFunctionName()`
- `getDartEntrypointArgs()`
- `getInitialRoute()`

The Dart entrypoint and app bundle path are not supported as `Intent` parameters since your Dart library entrypoints are your private APIs and Intents are invocable by other processes.

Using a cached FlutterEngine

`FlutterActivity` can be used with a cached `FlutterEngine` instead of creating a new one. Use `withCachedEngine(String)` to build a `FlutterActivity` `Intent` that is configured to use an existing, cached `FlutterEngine`. `FlutterEngineCache` is the cache that is used to obtain a given cached `FlutterEngine`. You must create and put a `FlutterEngine` into the `FlutterEngineCache` yourself before using the `withCachedEngine(String)` builder. An `IllegalStateException` will be thrown if a cached engine is requested but does not exist in the cache.

When using a cached `FlutterEngine`, that `FlutterEngine` should already be executing Dart code, which means that the Dart entrypoint and initial route have already been defined. Therefore, `FlutterActivity.CachedEngineIntentBuilder` does not offer configuration of these properties.

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 `FlutterActivity` is 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.

See https://flutter.dev/docs/development/add-to-app/performance for additional performance explorations on engine loading.

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

Alternatives to FlutterActivity

If Flutter is needed in a location that cannot use an `Activity`, consider using a `FlutterFragment`. Using a `FlutterFragment` requires forwarding some calls from an `Activity` to the `FlutterFragment`.

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`.

Launch Screen

`FlutterActivity` supports the display of an Android "launch screen", which is displayed while the Android application loads. It is only applicable if `FlutterActivity` is the first `Activity` displayed upon loading the app.

Prior to Flutter 2.5, `FlutterActivity` supported the display of a Flutter-specific "splash screen" that would be displayed after the launch screen passes. This has since been deprecated. If a launch screen is specified, it will automatically persist for as long as it takes Flutter to initialize and render its first frame.

Use Android themes to display a launch screen. Create two themes: a launch theme and a normal theme. In the launch theme, set `windowBackground` to the desired `Drawable` for the launch screen. In the normal theme, set `windowBackground` to any desired background color that should normally appear behind your Flutter content. In most cases this background color will never be seen, but for possible transition edge cases it is a good idea to explicitly replace the launch screen window background with a neutral color.

Do not change aspects of system chrome between a launch theme and normal theme. Either define both themes to be fullscreen or not, and define both themes to display the same status bar and navigation bar settings. To adjust system chrome once the Flutter app renders, use platform channels to instruct Android to do so at the appropriate time. This will avoid any jarring visual changes during app startup.

In the AndroidManifest.xml, set the theme of `FlutterActivity` to the defined launch theme. In the metadata section for `FlutterActivity`, defined the following reference to your normal theme:

`<meta-data android:name="io.flutter.embedding.android.NormalTheme" android:resource="@style/YourNormalTheme" />`

With themes defined, and AndroidManifest.xml updated, Flutter displays the specified launch screen until the Android application is initialized.

Alternative Activity `FlutterFragmentActivity` is also available, which is similar to `FlutterActivity` but it extends `FragmentActivity`. You should use `FlutterActivity`, if possible, but if you need a `FragmentActivity` then you should use `FlutterFragmentActivity`.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static class`
  `FlutterActivity.CachedEngineIntentBuilder`
  Builder to create an `Intent` that launches a `FlutterActivity` with an existing `FlutterEngine` that is cached in `FlutterEngineCache`.
  `static class`
  `FlutterActivity.NewEngineInGroupIntentBuilder`
  Builder to create an `Intent` that launches a `FlutterActivity` with a new `FlutterEngine` created by FlutterEngineGroup#createAndRunEngine.
  `static class`
  `FlutterActivity.NewEngineIntentBuilder`
  Builder to create an `Intent` that launches a `FlutterActivity` with a new `FlutterEngine` and the desired configuration.

  ## Nested classes/interfaces inherited from class android.app.Activity

  `Activity.ScreenCaptureCallback`

  ## Nested classes/interfaces inherited from class android.content.Context

  `Context.BindServiceFlags`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected io.flutter.embedding.android.FlutterActivityAndFragmentDelegate`
  `delegate`
  `static final int`
  `FLUTTER_VIEW_ID`
  The ID of the `FlutterView` created by this activity.

  ### Fields inherited from class android.app.Activity

  `DEFAULT_KEYS_DIALER, DEFAULT_KEYS_DISABLE, DEFAULT_KEYS_SEARCH_GLOBAL, DEFAULT_KEYS_SEARCH_LOCAL, DEFAULT_KEYS_SHORTCUT, FOCUSED_STATE_SET, FULLSCREEN_MODE_REQUEST_ENTER, FULLSCREEN_MODE_REQUEST_EXIT, OVERRIDE_TRANSITION_CLOSE, OVERRIDE_TRANSITION_OPEN, RESULT_CANCELED, RESULT_FIRST_USER, RESULT_OK`

  ### Fields inherited from class android.content.Context

  `ACCESSIBILITY_SERVICE, ACCOUNT_SERVICE, ACTIVITY_SERVICE, ALARM_SERVICE, APP_OPS_SERVICE, APP_SEARCH_SERVICE, APPWIDGET_SERVICE, AUDIO_SERVICE, BATTERY_SERVICE, BIND_ABOVE_CLIENT, BIND_ADJUST_WITH_ACTIVITY, BIND_ALLOW_ACTIVITY_STARTS, BIND_ALLOW_OOM_MANAGEMENT, BIND_AUTO_CREATE, BIND_DEBUG_UNBIND, BIND_EXTERNAL_SERVICE, BIND_EXTERNAL_SERVICE_LONG, BIND_IMPORTANT, BIND_INCLUDE_CAPABILITIES, BIND_NOT_FOREGROUND, BIND_NOT_PERCEPTIBLE, BIND_SHARED_ISOLATED_PROCESS, BIND_WAIVE_PRIORITY, BIOMETRIC_SERVICE, BLOB_STORE_SERVICE, BLUETOOTH_SERVICE, BUGREPORT_SERVICE, CAMERA_SERVICE, CAPTIONING_SERVICE, CARRIER_CONFIG_SERVICE, CLIPBOARD_SERVICE, COMPANION_DEVICE_SERVICE, CONNECTIVITY_DIAGNOSTICS_SERVICE, CONNECTIVITY_SERVICE, CONSUMER_IR_SERVICE, CONTEXT_IGNORE_SECURITY, CONTEXT_INCLUDE_CODE, CONTEXT_RESTRICTED, CREDENTIAL_SERVICE, CROSS_PROFILE_APPS_SERVICE, DEVICE_ID_DEFAULT, DEVICE_ID_INVALID, DEVICE_LOCK_SERVICE, DEVICE_POLICY_SERVICE, DISPLAY_HASH_SERVICE, DISPLAY_SERVICE, DOMAIN_VERIFICATION_SERVICE, DOWNLOAD_SERVICE, DROPBOX_SERVICE, EUICC_SERVICE, FILE_INTEGRITY_SERVICE, FINGERPRINT_SERVICE, GAME_SERVICE, GRAMMATICAL_INFLECTION_SERVICE, HARDWARE_PROPERTIES_SERVICE, HEALTHCONNECT_SERVICE, INPUT_METHOD_SERVICE, INPUT_SERVICE, IPSEC_SERVICE, JOB_SCHEDULER_SERVICE, KEYGUARD_SERVICE, LAUNCHER_APPS_SERVICE, LAYOUT_INFLATER_SERVICE, LOCALE_SERVICE, LOCATION_SERVICE, MEDIA_COMMUNICATION_SERVICE, MEDIA_METRICS_SERVICE, MEDIA_PROJECTION_SERVICE, MEDIA_ROUTER_SERVICE, MEDIA_SESSION_SERVICE, MIDI_SERVICE, MODE_APPEND, MODE_ENABLE_WRITE_AHEAD_LOGGING, MODE_MULTI_PROCESS, MODE_NO_LOCALIZED_COLLATORS, MODE_PRIVATE, MODE_WORLD_READABLE, MODE_WORLD_WRITEABLE, NETWORK_STATS_SERVICE, NFC_SERVICE, NOTIFICATION_SERVICE, NSD_SERVICE, OVERLAY_SERVICE, PEOPLE_SERVICE, PERFORMANCE_HINT_SERVICE, POWER_SERVICE, PRINT_SERVICE, RECEIVER_EXPORTED, RECEIVER_NOT_EXPORTED, RECEIVER_VISIBLE_TO_INSTANT_APPS, RESTRICTIONS_SERVICE, ROLE_SERVICE, SEARCH_SERVICE, SENSOR_SERVICE, SHORTCUT_SERVICE, STATUS_BAR_SERVICE, STORAGE_SERVICE, STORAGE_STATS_SERVICE, SYSTEM_HEALTH_SERVICE, TELECOM_SERVICE, TELEPHONY_IMS_SERVICE, TELEPHONY_SERVICE, TELEPHONY_SUBSCRIPTION_SERVICE, TEXT_CLASSIFICATION_SERVICE, TEXT_SERVICES_MANAGER_SERVICE, TV_INPUT_SERVICE, TV_INTERACTIVE_APP_SERVICE, UI_MODE_SERVICE, USAGE_STATS_SERVICE, USB_SERVICE, USER_SERVICE, VIBRATOR_MANAGER_SERVICE, VIBRATOR_SERVICE, VIRTUAL_DEVICE_SERVICE, VPN_MANAGEMENT_SERVICE, WALLPAPER_SERVICE, WIFI_AWARE_SERVICE, WIFI_P2P_SERVICE, WIFI_RTT_RANGING_SERVICE, WIFI_SERVICE, WINDOW_SERVICE`

  ### 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
  `FlutterActivity()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `boolean`
  `attachToEngineAutomatically()`
  Whether to automatically attach the `FlutterView` to the engine.
  `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`
  `configureFlutterEngine(FlutterEngine flutterEngine)`
  Hook for subclasses to easily configure a `FlutterEngine`.
  `static Intent`
  `createDefaultIntent(Context launchContext)`
  Creates an `Intent` that launches a `FlutterActivity`, which creates a `FlutterEngine` that executes a `main()` Dart entrypoint, and displays the "/" route as Flutter's initial route.
  `void`
  `detachFromFlutterEngine()`
  `Activity`
  `getActivity()`
  `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain an `Activity` reference as needed.
  `String`
  `getAppBundlePath()`
  A custom path to the bundle that contains this Flutter app's resources, e.g., Dart code snapshots.
  `protected FlutterActivityLaunchConfigs.BackgroundMode`
  `getBackgroundMode()`
  The desired window background mode of this `Activity`, which defaults to `FlutterActivityLaunchConfigs.BackgroundMode.opaque`.
  `String`
  `getCachedEngineGroupId()`
  Returns the ID of a statically cached `FlutterEngineGroup` to use within this `FlutterActivity`, or `null` if this `FlutterActivity` does not want to use a cached `FlutterEngineGroup`.
  `String`
  `getCachedEngineId()`
  Returns the ID of a statically cached `FlutterEngine` to use within this `FlutterActivity`, or `null` if this `FlutterActivity` does not want to use a cached `FlutterEngine`.
  `Context`
  `getContext()`
  `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain a `Context` reference as needed.
  `List<String>`
  `getDartEntrypointArgs()`
  The Dart entrypoint arguments will be passed as a list of string to Dart's entrypoint function.
  `String`
  `getDartEntrypointFunctionName()`
  The Dart entrypoint that will be executed as soon as the Dart snapshot is loaded.
  `String`
  `getDartEntrypointLibraryUri()`
  The Dart library URI for the entrypoint that will be executed as soon as the Dart snapshot is loaded.
  `ExclusiveAppComponent<Activity>`
  `getExclusiveAppComponent()`
  Returns the Android App Component exclusively attached to `FlutterEngine`.
  `protected 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()`
  The initial route that a Flutter app will render upon loading and executing its Dart code.
  `androidx.lifecycle.Lifecycle`
  `getLifecycle()`
  `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain a `Lifecycle` reference as needed.
  `protected Bundle`
  `getMetaData()`
  Retrieves the meta data specified in the AndroidManifest.xml.
  `RenderMode`
  `getRenderMode()`
  `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain the desired `RenderMode` that should be used when instantiating a `FlutterView`.
  `TransparencyMode`
  `getTransparencyMode()`
  `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain the desired `TransparencyMode` that should be used when instantiating a `FlutterView`.
  `protected void`
  `onActivityResult(int requestCode, int resultCode, Intent data)`
  `void`
  `onBackPressed()`
  `protected void`
  `onCreate(Bundle savedInstanceState)`
  `protected void`
  `onDestroy()`
  `void`
  `onFlutterSurfaceViewCreated(FlutterSurfaceView flutterSurfaceView)`
  `void`
  `onFlutterTextureViewCreated(FlutterTextureView flutterTextureView)`
  `void`
  `onFlutterUiDisplayed()`
  `void`
  `onFlutterUiNoLongerDisplayed()`
  `protected void`
  `onNewIntent(Intent intent)`
  `protected void`
  `onPause()`
  `void`
  `onPostResume()`
  `void`
  `onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults)`
  `protected void`
  `onResume()`
  `protected void`
  `onSaveInstanceState(Bundle outState)`
  `protected void`
  `onStart()`
  `protected void`
  `onStop()`
  `void`
  `onTrimMemory(int level)`
  `void`
  `onUserLeaveHint()`
  `void`
  `onWindowFocusChanged(boolean hasFocus)`
  `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 easily provide a custom `FlutterEngine`.
  `PlatformPlugin`
  `providePlatformPlugin(Activity activity, FlutterEngine flutterEngine)`
  `void`
  `registerOnBackInvokedCallback()`
  Registers the callback with OnBackInvokedDispatcher to capture back navigation gestures and pass them to the framework.
  `void`
  `release()`
  Irreversibly release this activity's control of the `FlutterEngine` and its subcomponents.
  `void`
  `setFrameworkHandlesBack(boolean frameworkHandlesBack)`
  The Flutter application would or would not like to handle navigation pop events itself.
  `boolean`
  `shouldAttachEngineToActivity()`
  Hook for subclasses to control whether or not the `FlutterFragment` within this `Activity` automatically attaches its `FlutterEngine` to this `Activity`.
  `boolean`
  `shouldDestroyEngineWithHost()`
  Returns false if the `FlutterEngine` backing this `FlutterActivity` should outlive this `FlutterActivity`, or true to be destroyed when the `FlutterActivity` is destroyed.
  `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`
  `unregisterOnBackInvokedCallback()`
  Unregisters the callback from OnBackInvokedDispatcher.
  `void`
  `updateSystemUiOverlays()`
  `static FlutterActivity.CachedEngineIntentBuilder`
  `withCachedEngine(String cachedEngineId)`
  Creates a `FlutterActivity.CachedEngineIntentBuilder`, which can be used to configure an `Intent` to launch a `FlutterActivity` that internally uses an existing `FlutterEngine` that is cached in `FlutterEngineCache`.
  `static FlutterActivity.NewEngineIntentBuilder`
  `withNewEngine()`
  Creates an `FlutterActivity.NewEngineIntentBuilder`, which can be used to configure an `Intent` to launch a `FlutterActivity` that internally creates a new `FlutterEngine` using the desired Dart entrypoint, initial route, etc.
  `static FlutterActivity.NewEngineInGroupIntentBuilder`
  `withNewEngineInGroup(String engineGroupId)`
  Creates a `FlutterActivity.NewEngineInGroupIntentBuilder`, which can be used to configure an `Intent` to launch a `FlutterActivity` by internally creating a FlutterEngine from an existing `FlutterEngineGroup` cached in a specified `FlutterEngineGroupCache`.

  ### Methods inherited from class android.app.Activity

  `addContentView, attachBaseContext, clearOverrideActivityTransition, closeContextMenu, closeOptionsMenu, createPendingResult, dismissDialog, dismissKeyboardShortcutsHelper, dispatchGenericMotionEvent, dispatchKeyEvent, dispatchKeyShortcutEvent, dispatchPopulateAccessibilityEvent, dispatchTouchEvent, dispatchTrackballEvent, dump, enterPictureInPictureMode, enterPictureInPictureMode, findViewById, finish, finishActivity, finishActivityFromChild, finishAffinity, finishAfterTransition, finishAndRemoveTask, finishFromChild, getActionBar, getApplication, getCallingActivity, getCallingPackage, getChangingConfigurations, getComponentName, getContentScene, getContentTransitionManager, getCurrentFocus, getFragmentManager, getIntent, getLastNonConfigurationInstance, getLaunchedFromPackage, getLaunchedFromUid, getLayoutInflater, getLoaderManager, getLocalClassName, getMaxNumPictureInPictureActions, getMediaController, getMenuInflater, getOnBackInvokedDispatcher, getParent, getParentActivityIntent, getPreferences, getReferrer, getRequestedOrientation, getSearchEvent, getSplashScreen, getSystemService, getTaskId, getTitle, getTitleColor, getVoiceInteractor, getVolumeControlStream, getWindow, getWindowManager, hasWindowFocus, invalidateOptionsMenu, isActivityTransitionRunning, isChangingConfigurations, isChild, isDestroyed, isFinishing, isImmersive, isInMultiWindowMode, isInPictureInPictureMode, isLaunchedFromBubble, isLocalVoiceInteractionSupported, isTaskRoot, isVoiceInteraction, isVoiceInteractionRoot, managedQuery, moveTaskToBack, navigateUpTo, navigateUpToFromChild, onActionModeFinished, onActionModeStarted, onActivityReenter, onApplyThemeResource, onAttachedToWindow, onAttachFragment, onChildTitleChanged, onConfigurationChanged, onContentChanged, onContextItemSelected, onContextMenuClosed, onCreate, onCreateContextMenu, onCreateDescription, onCreateDialog, onCreateDialog, onCreateNavigateUpTaskStack, onCreateOptionsMenu, onCreatePanelMenu, onCreatePanelView, onCreateThumbnail, onCreateView, onCreateView, onDetachedFromWindow, onEnterAnimationComplete, onGenericMotionEvent, onGetDirectActions, onKeyDown, onKeyLongPress, onKeyMultiple, onKeyShortcut, onKeyUp, onLocalVoiceInteractionStarted, onLocalVoiceInteractionStopped, onLowMemory, onMenuItemSelected, onMenuOpened, onMultiWindowModeChanged, onMultiWindowModeChanged, onNavigateUp, onNavigateUpFromChild, onOptionsItemSelected, onOptionsMenuClosed, onPanelClosed, onPerformDirectAction, onPictureInPictureModeChanged, onPictureInPictureModeChanged, onPictureInPictureRequested, onPictureInPictureUiStateChanged, onPostCreate, onPostCreate, onPrepareDialog, onPrepareDialog, onPrepareNavigateUpTaskStack, onPrepareOptionsMenu, onPreparePanel, onProvideAssistContent, onProvideAssistData, onProvideKeyboardShortcuts, onProvideReferrer, onRestart, onRestoreInstanceState, onRestoreInstanceState, onRetainNonConfigurationInstance, onSaveInstanceState, onSearchRequested, onSearchRequested, onStateNotSaved, onTitleChanged, onTopResumedActivityChanged, onTouchEvent, onTrackballEvent, onUserInteraction, onVisibleBehindCanceled, onWindowAttributesChanged, onWindowStartingActionMode, onWindowStartingActionMode, openContextMenu, openOptionsMenu, overrideActivityTransition, overrideActivityTransition, overridePendingTransition, overridePendingTransition, postponeEnterTransition, recreate, registerActivityLifecycleCallbacks, registerComponentCallbacks, registerForContextMenu, registerScreenCaptureCallback, releaseInstance, removeDialog, reportFullyDrawn, requestDragAndDropPermissions, requestFullscreenMode, requestPermissions, requestShowKeyboardShortcuts, requestVisibleBehind, requestWindowFeature, requireViewById, runOnUiThread, setActionBar, setContentTransitionManager, setContentView, setContentView, setContentView, setDefaultKeyMode, setEnterSharedElementCallback, setExitSharedElementCallback, setFeatureDrawable, setFeatureDrawableAlpha, setFeatureDrawableResource, setFeatureDrawableUri, setFinishOnTouchOutside, setImmersive, setInheritShowWhenLocked, setIntent, setLocusContext, setMediaController, setPictureInPictureParams, setProgress, setProgressBarIndeterminate, setProgressBarIndeterminateVisibility, setProgressBarVisibility, setRecentsScreenshotEnabled, setRequestedOrientation, setResult, setResult, setSecondaryProgress, setShouldDockBigOverlays, setShowWhenLocked, setTaskDescription, setTheme, setTitle, setTitle, setTitleColor, setTranslucent, setTurnScreenOn, setVisible, setVolumeControlStream, setVrModeEnabled, shouldDockBigOverlays, shouldShowRequestPermissionRationale, shouldUpRecreateTask, showAssist, showDialog, showDialog, showLockTaskEscapeMessage, startActionMode, startActionMode, startActivities, startActivities, startActivity, startActivity, startActivityForResult, startActivityForResult, startActivityFromChild, startActivityFromChild, startActivityFromFragment, startActivityFromFragment, startActivityIfNeeded, startActivityIfNeeded, startIntentSender, startIntentSender, startIntentSenderForResult, startIntentSenderForResult, startIntentSenderFromChild, startIntentSenderFromChild, startLocalVoiceInteraction, startLockTask, startManagingCursor, startNextMatchingActivity, startNextMatchingActivity, startPostponedEnterTransition, startSearch, stopLocalVoiceInteraction, stopLockTask, stopManagingCursor, takeKeyEvents, triggerSearch, unregisterActivityLifecycleCallbacks, unregisterComponentCallbacks, unregisterForContextMenu, unregisterScreenCaptureCallback`

  ### Methods inherited from class android.view.ContextThemeWrapper

  `applyOverrideConfiguration, getAssets, getResources, getTheme, setTheme`

  ### Methods inherited from class android.content.ContextWrapper

  `bindIsolatedService, bindService, bindService, bindService, bindService, bindServiceAsUser, bindServiceAsUser, checkCallingOrSelfPermission, checkCallingOrSelfUriPermission, checkCallingOrSelfUriPermissions, checkCallingPermission, checkCallingUriPermission, checkCallingUriPermissions, checkPermission, checkSelfPermission, checkUriPermission, checkUriPermission, checkUriPermissions, clearWallpaper, createAttributionContext, createConfigurationContext, createContext, createContextForSplit, createDeviceContext, createDeviceProtectedStorageContext, createDisplayContext, createPackageContext, createWindowContext, createWindowContext, databaseList, deleteDatabase, deleteFile, deleteSharedPreferences, enforceCallingOrSelfPermission, enforceCallingOrSelfUriPermission, enforceCallingPermission, enforceCallingUriPermission, enforcePermission, enforceUriPermission, enforceUriPermission, fileList, getApplicationContext, getApplicationInfo, getAttributionSource, getAttributionTag, getBaseContext, getCacheDir, getClassLoader, getCodeCacheDir, getContentResolver, getDatabasePath, getDataDir, getDeviceId, getDir, getDisplay, getExternalCacheDir, getExternalCacheDirs, getExternalFilesDir, getExternalFilesDirs, getExternalMediaDirs, getFilesDir, getFileStreamPath, getMainExecutor, getMainLooper, getNoBackupFilesDir, getObbDir, getObbDirs, getOpPackageName, getPackageCodePath, getPackageManager, getPackageName, getPackageResourcePath, getParams, getSharedPreferences, getSystemServiceName, getWallpaper, getWallpaperDesiredMinimumHeight, getWallpaperDesiredMinimumWidth, grantUriPermission, isDeviceProtectedStorage, isRestricted, isUiContext, moveDatabaseFrom, moveSharedPreferencesFrom, openFileInput, openFileOutput, openOrCreateDatabase, openOrCreateDatabase, peekWallpaper, registerDeviceIdChangeListener, registerReceiver, registerReceiver, registerReceiver, registerReceiver, removeStickyBroadcast, removeStickyBroadcastAsUser, revokeSelfPermissionsOnKill, revokeUriPermission, revokeUriPermission, sendBroadcast, sendBroadcast, sendBroadcast, sendBroadcastAsUser, sendBroadcastAsUser, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcastAsUser, sendStickyBroadcast, sendStickyBroadcast, sendStickyBroadcastAsUser, sendStickyOrderedBroadcast, sendStickyOrderedBroadcastAsUser, setWallpaper, setWallpaper, startForegroundService, startInstrumentation, startService, stopService, unbindService, unregisterDeviceIdChangeListener, unregisterReceiver, updateServiceGroup`

  ### Methods inherited from class android.content.Context

  `bindIsolatedService, getColor, getColorStateList, getDrawable, getString, getString, getSystemService, getText, obtainStyledAttributes, obtainStyledAttributes, obtainStyledAttributes, obtainStyledAttributes, revokeSelfPermissionOnKill, sendBroadcastWithMultiplePermissions`

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

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface android.view.Window.Callback

  `onPointerCaptureChanged`

- ## 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)`.

  - ### delegate

    protected io.flutter.embedding.android.FlutterActivityAndFragmentDelegate delegate

- ## Constructor Details

  - ### FlutterActivity

    public FlutterActivity()

- ## Method Details

  - ### createDefaultIntent

    @NonNull public static Intent createDefaultIntent(@NonNull Context launchContext)
    Creates an `Intent` that launches a `FlutterActivity`, which creates a `FlutterEngine` that executes a `main()` Dart entrypoint, and displays the "/" route as Flutter's initial route.

    Consider using the `withCachedEngine(String)` `Intent` builder to control when the `FlutterEngine` should be created in your application.

    Parameters:
      `launchContext` - The launch context. e.g. An Activity.
    Returns:
      The default intent.

  - ### withNewEngine

    @NonNull public static FlutterActivity.NewEngineIntentBuilder withNewEngine()
    Creates an `FlutterActivity.NewEngineIntentBuilder`, which can be used to configure an `Intent` to launch a `FlutterActivity` that internally creates a new `FlutterEngine` using the desired Dart entrypoint, initial route, etc.
    Returns:
      The engine intent builder.

  - ### withCachedEngine

    public static FlutterActivity.CachedEngineIntentBuilder withCachedEngine(@NonNull String cachedEngineId)
    Creates a `FlutterActivity.CachedEngineIntentBuilder`, which can be used to configure an `Intent` to launch a `FlutterActivity` that internally uses an existing `FlutterEngine` that is cached in `FlutterEngineCache`.
    Parameters:
      `cachedEngineId` - A cached engine ID.
    Returns:
      The builder.

  - ### withNewEngineInGroup

    public static FlutterActivity.NewEngineInGroupIntentBuilder withNewEngineInGroup(@NonNull String engineGroupId)
    Creates a `FlutterActivity.NewEngineInGroupIntentBuilder`, which can be used to configure an `Intent` to launch a `FlutterActivity` by internally creating a FlutterEngine from an existing `FlutterEngineGroup` cached in a specified `FlutterEngineGroupCache`.

         // Create a FlutterEngineGroup, such as in the onCreate method of the Application.
         FlutterEngineGroup engineGroup = new FlutterEngineGroup(this);
         FlutterEngineGroupCache.getInstance().put("my_cached_engine_group_id", engineGroup);

         // Start a FlutterActivity with the FlutterEngineGroup by creating an intent with withNewEngineInGroup
         Intent intent = FlutterActivity.withNewEngineInGroup("my_cached_engine_group_id")
             .dartEntrypoint("custom_entrypoint")
             .initialRoute("/custom/route")
             .backgroundMode(BackgroundMode.transparent)
             .build(context);
         startActivity(intent);

    Parameters:
      `engineGroupId` - A cached engine group ID.
    Returns:
      The builder.

  - ### getExclusiveAppComponent

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

  - ### onCreate

    protected void onCreate(@Nullable Bundle savedInstanceState)
    Overrides:
      `onCreate` in class `Activity`

  - ### registerOnBackInvokedCallback

    public void registerOnBackInvokedCallback()
    Registers the callback with OnBackInvokedDispatcher to capture back navigation gestures and pass them to the framework.

    This replaces the deprecated onBackPressed method override in order to support API 33's predictive back navigation feature.

    The callback must be unregistered in order to prevent unpredictable behavior once outside the Flutter app.

  - ### unregisterOnBackInvokedCallback

    public void unregisterOnBackInvokedCallback()
    Unregisters the callback from OnBackInvokedDispatcher.

    This should be called when the activity is no longer in use to prevent unpredictable behavior such as being stuck and unable to press back.

  - ### 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`

  - ### onStart

    protected void onStart()
    Overrides:
      `onStart` in class `Activity`

  - ### onResume

    protected void onResume()
    Overrides:
      `onResume` in class `Activity`

  - ### onPostResume

    public void onPostResume()
    Overrides:
      `onPostResume` in class `Activity`

  - ### onPause

    protected void onPause()
    Overrides:
      `onPause` in class `Activity`

  - ### onStop

    protected void onStop()
    Overrides:
      `onStop` in class `Activity`

  - ### onSaveInstanceState

    protected void onSaveInstanceState(Bundle outState)
    Overrides:
      `onSaveInstanceState` in class `Activity`

  - ### release

    public void release()
    Irreversibly release this activity's control of the `FlutterEngine` and its subcomponents.

    Calling will disconnect this activity's view from the Flutter renderer, disconnect this activity from plugins' `ActivityControlSurface`, and stop system channel messages from this activity.

    After calling, this activity should be disposed immediately and not be re-used.

  - ### detachFromFlutterEngine

    public void detachFromFlutterEngine()

  - ### onDestroy

    protected void onDestroy()
    Overrides:
      `onDestroy` in class `Activity`

  - ### onActivityResult

    protected void onActivityResult(int requestCode, int resultCode, Intent data)
    Overrides:
      `onActivityResult` in class `Activity`

  - ### onNewIntent

    protected void onNewIntent(@NonNull Intent intent)
    Overrides:
      `onNewIntent` in class `Activity`

  - ### onBackPressed

    public void onBackPressed()
    Overrides:
      `onBackPressed` in class `Activity`

  - ### onRequestPermissionsResult

    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
    Overrides:
      `onRequestPermissionsResult` in class `Activity`

  - ### onUserLeaveHint

    public void onUserLeaveHint()
    Overrides:
      `onUserLeaveHint` in class `Activity`

  - ### onWindowFocusChanged

    public void onWindowFocusChanged(boolean hasFocus)
    Specified by:
      `onWindowFocusChanged` in interface `Window.Callback`
    Overrides:
      `onWindowFocusChanged` in class `Activity`

  - ### onTrimMemory

    public void onTrimMemory(int level)
    Specified by:
      `onTrimMemory` in interface `ComponentCallbacks2`
    Overrides:
      `onTrimMemory` in class `Activity`

  - ### getContext

    @NonNull public Context getContext()
    `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain a `Context` reference as needed.

  - ### getActivity

    @NonNull public Activity getActivity()
    `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain an `Activity` reference as needed. This reference is used by the delegate to instantiate a `FlutterView`, a `PlatformPlugin`, and to determine if the `Activity` is changing configurations.

  - ### getLifecycle

    @NonNull public androidx.lifecycle.Lifecycle getLifecycle()
    `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain a `Lifecycle` reference as needed. This reference is used by the delegate to provide Flutter plugins with access to lifecycle events.
    Specified by:
      `getLifecycle` in interface `androidx.lifecycle.LifecycleOwner`

  - ### 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 `FlutterActivity`, or `null` if this `FlutterActivity` 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 `FlutterActivity`, or `null` if this `FlutterActivity` does not want to use a cached `FlutterEngineGroup`.

  - ### shouldDestroyEngineWithHost

    public boolean shouldDestroyEngineWithHost()
    Returns false if the `FlutterEngine` backing this `FlutterActivity` should outlive this `FlutterActivity`, or true to be destroyed when the `FlutterActivity` is destroyed.

    The default value is `true` in cases where `FlutterActivity` created its own `FlutterEngine`, and `false` in cases where a cached `FlutterEngine` was provided.

  - ### getDartEntrypointFunctionName

    @NonNull public String getDartEntrypointFunctionName()
    The Dart entrypoint that will be executed as soon as the Dart snapshot is loaded.

    This preference can be controlled with 2 methods:

    1. Pass a boolean as `FlutterActivityLaunchConfigs.EXTRA_DART_ENTRYPOINT` with the launching `Intent`, or
    2. Set a `<meta-data>` called `FlutterActivityLaunchConfigs.DART_ENTRYPOINT_META_DATA_KEY` within the Android manifest definition for this `FlutterActivity`
    If both preferences are set, the `Intent` preference takes priority.

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

  - ### 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()
    The Dart library URI for the entrypoint that will be executed as soon as the Dart snapshot is loaded.

    Example value: "package:foo/bar.dart"

    This preference can be controlled by setting a `<meta-data>` called `FlutterActivityLaunchConfigs.DART_ENTRYPOINT_URI_META_DATA_KEY` within the Android manifest definition for this `FlutterActivity`.

    A value of null means use the default root library.

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

  - ### getInitialRoute

    public String getInitialRoute()
    The initial route that a Flutter app will render upon loading and executing its Dart code.

    This preference can be controlled with 2 methods:

    1. Pass a boolean as `FlutterActivityLaunchConfigs.EXTRA_INITIAL_ROUTE` with the launching `Intent`, or
    2. Set a `<meta-data>` called `FlutterActivityLaunchConfigs.INITIAL_ROUTE_META_DATA_KEY` for this `Activity` in the Android manifest.
    If both preferences are set, the `Intent` preference takes priority.

    The reason that a `<meta-data>` preference is supported is because this `Activity` might be the very first `Activity` launched, which means the developer won't have control over the incoming `Intent`.

    Subclasses may override this method to directly control the initial route.

    If this method returns null and the `shouldHandleDeeplinking` returns true, the initial route is derived from the `Intent` through the Intent.getData() instead.

  - ### getAppBundlePath

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

    When this `FlutterActivity` is run by Flutter tooling and a data String is included in the launching `Intent`, that data String is interpreted as an app bundle path.

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

    Subclasses may override this method to return a custom app bundle path.

  - ### getRenderMode

    @NonNull public RenderMode getRenderMode()
    `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain the desired `RenderMode` that should be used when instantiating a `FlutterView`.

  - ### getTransparencyMode

    @NonNull public TransparencyMode getTransparencyMode()
    `FlutterActivityAndFragmentDelegate.Host` method that is used by `FlutterActivityAndFragmentDelegate` to obtain the desired `TransparencyMode` that should be used when instantiating a `FlutterView`.

  - ### getBackgroundMode

    @NonNull protected FlutterActivityLaunchConfigs.BackgroundMode getBackgroundMode()
    The desired window background mode of this `Activity`, which defaults to `FlutterActivityLaunchConfigs.BackgroundMode.opaque`.
    Returns:
      The background mode.

  - ### provideFlutterEngine

    @Nullable public FlutterEngine provideFlutterEngine(@NonNull Context context)
    Hook for subclasses to easily provide a custom `FlutterEngine`.

    This hook is where a cached `FlutterEngine` should be provided, if a cached `FlutterEngine` is desired.

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

  - ### getFlutterEngine

    @Nullable protected FlutterEngine getFlutterEngine()
    Hook for subclasses to obtain a reference to the `FlutterEngine` that is owned by this `FlutterActivity`.
    Returns:
      The Flutter engine.

  - ### getMetaData

    @Nullable protected Bundle getMetaData() throws PackageManager.NameNotFoundException
    Retrieves the meta data specified in the AndroidManifest.xml.
    Returns:
      The meta data.
    Throws:
      `PackageManager.NameNotFoundException` - if a package with the given name cannot be found on the system.

  - ### providePlatformPlugin

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

  - ### configureFlutterEngine

    public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine)
    Hook for subclasses to easily configure a `FlutterEngine`.

    This method is called after `provideFlutterEngine(Context)`.

    All plugins listed in the app's pubspec are registered in the base implementation of this method unless the FlutterEngine for this activity was externally created. To avoid the automatic plugin registration for implicitly created FlutterEngines, override this method without invoking super(). To keep automatic plugin registration and further configure the FlutterEngine, override this method, invoke super(), and then configure the FlutterEngine as desired.

    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 `onDestroy()`.

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

  - ### shouldAttachEngineToActivity

    public boolean shouldAttachEngineToActivity()
    Hook for subclasses to control whether or not the `FlutterFragment` within this `Activity` automatically attaches its `FlutterEngine` to this `Activity`.

    This property is controlled with a protected method instead of an `Intent` argument because the only situation where changing this value would help, is a situation in which `FlutterActivity` is being subclassed to utilize a custom and/or cached `FlutterEngine`.

    Defaults to `true`.

    Control surfaces are used to provide Android resources and lifecycle events to plugins that are attached to the `FlutterEngine`. If `shouldAttachEngineToActivity` is true, then this `FlutterActivity` will connect its `FlutterEngine` to itself, 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. `Activity.onNewIntent(Intent)`. If `shouldAttachEngineToActivity` is false, then this `FlutterActivity` will not automatically manage the connection between its `FlutterEngine` and itself. In this case, plugins will not be offered a reference to an `Activity` or its OS hooks.

    Returning false from this method does not preclude a `FlutterEngine` from being attaching to a `FlutterActivity` - it just prevents the attachment from happening automatically. A developer can choose to subclass `FlutterActivity` and then invoke `ActivityControlSurface.attachToActivity(ExclusiveAppComponent, Lifecycle)` and `ActivityControlSurface.detachFromActivity()` at the desired times.

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

  - ### shouldHandleDeeplinking

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

    The default implementation looks `<meta-data>` called `FlutterActivityLaunchConfigs.HANDLE_DEEPLINKING_META_DATA_KEY` within the Android manifest definition for this `FlutterActivity`.

  - ### onFlutterSurfaceViewCreated

    public void onFlutterSurfaceViewCreated(@NonNull FlutterSurfaceView flutterSurfaceView)

  - ### onFlutterTextureViewCreated

    public void onFlutterTextureViewCreated(@NonNull FlutterTextureView flutterTextureView)

  - ### onFlutterUiDisplayed

    public void onFlutterUiDisplayed()

  - ### onFlutterUiNoLongerDisplayed

    public void onFlutterUiNoLongerDisplayed()

  - ### shouldRestoreAndSaveState

    public boolean shouldRestoreAndSaveState()

  - ### 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`.

  - ### popSystemNavigator

    public boolean popSystemNavigator()
    Description copied from interface: `PlatformPlugin.PlatformPluginDelegate`
    Allow implementer to customize the behavior needed when the Flutter framework calls to pop the Android-side navigation stack.
    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.

  - ### updateSystemUiOverlays

    public void updateSystemUiOverlays()