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:
Activity
transparently, if desired.
FlutterEngine
.
#shouldRestoreAndSaveState()
;
Dart entrypoint, 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 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, and initial route can also be controlled in a subclass
of FlutterActivity
by overriding their respective methods:
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:
FlutterActivity
is the first Activity
displayed by the app, because
pre-warming a FlutterEngine
would have no impact in this situation.
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.
FlutterEngine flutterEngine = new FlutterEngine(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 and Splash Screen
FlutterActivity
supports the display of an Android "launch screen" as well as a
Flutter-specific "splash screen". The launch screen is displayed while the Android application
loads. It is only applicable if FlutterActivity
is the first Activity
displayed
upon loading the app. After the launch screen passes, a splash screen is optionally displayed.
The splash screen is displayed 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.
Flutter also requires initialization time. To specify a splash screen for Flutter
initialization, subclass FlutterActivity
and override provideSplashScreen()
. See
SplashScreen
for details on implementing a splash screen.
Flutter ships with a splash screen that automatically displays the exact same windowBackground
as the launch theme discussed previously. To use that splash screen, include
the following metadata in AndroidManifest.xml for this FlutterActivity
:
<meta-data android:name="io.flutter.app.android.SplashScreenUntilFirstFrame"
android:value="true" />
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
.
Modifier and Type | Class and 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.NewEngineIntentBuilder
Builder to create an
Intent that launches a FlutterActivity with a new FlutterEngine and the desired configuration. |
Activity.TranslucentConversionListener
Context.BindServiceFlags, Context.CreatePackageOptions, Context.DatabaseMode, Context.FileMode, Context.PreferencesMode, Context.RegisterReceiverFlags, Context.ServiceName
ComponentCallbacks2.TrimMemoryLevel
Modifier and Type | Field and Description |
---|---|
protected io.flutter.embedding.android.FlutterActivityAndFragmentDelegate |
delegate |
DEFAULT_KEYS_DIALER, DEFAULT_KEYS_DISABLE, DEFAULT_KEYS_SEARCH_GLOBAL, DEFAULT_KEYS_SEARCH_LOCAL, DEFAULT_KEYS_SHORTCUT, DONT_FINISH_TASK_WITH_ACTIVITY, FINISH_TASK_WITH_ACTIVITY, FINISH_TASK_WITH_ROOT_ACTIVITY, FOCUSED_STATE_SET, RESULT_CANCELED, RESULT_FIRST_USER, RESULT_OK
ACCESSIBILITY_SERVICE, ACCOUNT_SERVICE, ACTIVITY_SERVICE, ALARM_SERVICE, APP_OPS_SERVICE, APPWIDGET_SERVICE, AUDIO_SERVICE, AUTOFILL_MANAGER_SERVICE, BACKUP_SERVICE, BATTERY_SERVICE, BIND_ABOVE_CLIENT, BIND_ADJUST_WITH_ACTIVITY, BIND_ALLOW_INSTANT, BIND_ALLOW_OOM_MANAGEMENT, BIND_ALLOW_WHITELIST_MANAGEMENT, BIND_AUTO_CREATE, BIND_DEBUG_UNBIND, BIND_EXTERNAL_SERVICE, BIND_FOREGROUND_SERVICE, BIND_FOREGROUND_SERVICE_WHILE_AWAKE, BIND_IMPORTANT, BIND_IMPORTANT_BACKGROUND, BIND_NOT_FOREGROUND, BIND_NOT_VISIBLE, BIND_SHOWING_UI, BIND_TREAT_LIKE_ACTIVITY, BIND_VISIBLE, BIND_WAIVE_PRIORITY, BLUETOOTH_SERVICE, CAMERA_SERVICE, CAPTIONING_SERVICE, CARRIER_CONFIG_SERVICE, CLIPBOARD_SERVICE, COMPANION_DEVICE_SERVICE, CONNECTIVITY_SERVICE, CONSUMER_IR_SERVICE, CONTEXT_CREDENTIAL_PROTECTED_STORAGE, CONTEXT_DEVICE_PROTECTED_STORAGE, CONTEXT_IGNORE_SECURITY, CONTEXT_INCLUDE_CODE, CONTEXT_REGISTER_PACKAGE, CONTEXT_RESTRICTED, CONTEXTHUB_SERVICE, COUNTRY_DETECTOR, CROSS_PROFILE_APPS_SERVICE, DEVICE_IDENTIFIERS_SERVICE, DEVICE_IDLE_CONTROLLER, DEVICE_POLICY_SERVICE, DISPLAY_SERVICE, DOWNLOAD_SERVICE, DROPBOX_SERVICE, ETHERNET_SERVICE, EUICC_CARD_SERVICE, EUICC_SERVICE, FINGERPRINT_SERVICE, GATEKEEPER_SERVICE, HARDWARE_PROPERTIES_SERVICE, HDMI_CONTROL_SERVICE, INCIDENT_SERVICE, INPUT_METHOD_SERVICE, INPUT_SERVICE, IPSEC_SERVICE, JOB_SCHEDULER_SERVICE, KEYGUARD_SERVICE, LAUNCHER_APPS_SERVICE, LAYOUT_INFLATER_SERVICE, LOCATION_SERVICE, LOWPAN_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_POLICY_SERVICE, NETWORK_SCORE_SERVICE, NETWORK_STATS_SERVICE, NETWORK_WATCHLIST_SERVICE, NETWORKMANAGEMENT_SERVICE, NFC_SERVICE, NOTIFICATION_SERVICE, NSD_SERVICE, OEM_LOCK_SERVICE, OVERLAY_SERVICE, PERSISTENT_DATA_BLOCK_SERVICE, POWER_SERVICE, PRINT_SERVICE, RADIO_SERVICE, RECEIVER_VISIBLE_TO_INSTANT_APPS, RECOVERY_SERVICE, RESTRICTIONS_SERVICE, SEARCH_SERVICE, SECURE_ELEMENT_SERVICE, SENSOR_SERVICE, SERIAL_SERVICE, SHORTCUT_SERVICE, SIP_SERVICE, SLICE_SERVICE, SOUND_TRIGGER_SERVICE, STATS_COMPANION_SERVICE, STATS_MANAGER, STATUS_BAR_SERVICE, STORAGE_SERVICE, STORAGE_STATS_SERVICE, SYSTEM_HEALTH_SERVICE, SYSTEM_UPDATE_SERVICE, TELECOM_SERVICE, TELEPHONY_SERVICE, TELEPHONY_SUBSCRIPTION_SERVICE, TEXT_CLASSIFICATION_SERVICE, TEXT_SERVICES_MANAGER_SERVICE, TIME_ZONE_RULES_MANAGER_SERVICE, TRUST_SERVICE, TV_INPUT_SERVICE, UI_MODE_SERVICE, UPDATE_LOCK_SERVICE, USAGE_STATS_SERVICE, USB_SERVICE, USER_SERVICE, VIBRATOR_SERVICE, VOICE_INTERACTION_MANAGER_SERVICE, VR_SERVICE, WALLPAPER_SERVICE, WIFI_AWARE_SERVICE, WIFI_P2P_SERVICE, WIFI_RTT_RANGING_SERVICE, WIFI_RTT_SERVICE, WIFI_SCANNING_SERVICE, WIFI_SERVICE, WINDOW_SERVICE
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 and Description |
---|
FlutterActivity() |
Modifier and Type | Method and Description |
---|---|
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()
Callback called when the
FlutterEngine has been attached to by another activity
before this activity was destroyed. |
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 |
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. |
String |
getDartEntrypointFunctionName()
The Dart entrypoint that will be executed as soon as the Dart snapshot is loaded.
|
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)
Invoked by this delegate when the
FlutterSurfaceView that renders the Flutter UI is
initially instantiated. |
void |
onFlutterTextureViewCreated(FlutterTextureView flutterTextureView)
Invoked by this delegate when the
FlutterTextureView that renders the Flutter UI is
initially instantiated. |
void |
onFlutterUiDisplayed()
Invoked by this delegate when its
FlutterView starts painting pixels. |
void |
onFlutterUiNoLongerDisplayed()
Invoked by this delegate when its
FlutterView stops painting pixels. |
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() |
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)
Hook for the host to create/provide a
PlatformPlugin if the associated Flutter
experience should control system chrome. |
SplashScreen |
provideSplashScreen()
Provides a
SplashScreen to display while Flutter initializes and renders its first
frame. |
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 |
shouldHandleDeeplinking()
Whether to handle the deeplinking from the
Intent automatically if the getInitialRoute returns null. |
boolean |
shouldRestoreAndSaveState()
Whether state restoration is enabled.
|
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. |
addContentView, attachBaseContext, autofillClientAuthenticate, autofillClientDispatchUnhandledKey, autofillClientFindViewByAccessibilityIdTraversal, autofillClientFindViewByAutofillIdTraversal, autofillClientFindViewsByAutofillIdTraversal, autofillClientGetActivityToken, autofillClientGetComponentName, autofillClientGetNextAutofillId, autofillClientGetViewVisibility, autofillClientIsCompatibilityModeEnabled, autofillClientIsFillUiShowing, autofillClientIsVisibleForAutofill, autofillClientRequestHideFillUi, autofillClientRequestShowFillUi, autofillClientResetableStateAvailable, autofillClientRunOnUiThread, canStartActivityForResult, closeContextMenu, closeOptionsMenu, convertFromTranslucent, convertToTranslucent, createPendingResult, dismissDialog, dismissKeyboardShortcutsHelper, dispatchEnterAnimationComplete, dispatchGenericMotionEvent, dispatchKeyEvent, dispatchKeyShortcutEvent, dispatchPopulateAccessibilityEvent, dispatchTouchEvent, dispatchTrackballEvent, dump, enterPictureInPictureMode, enterPictureInPictureMode, enterPictureInPictureMode, enterPictureInPictureModeIfPossible, exitFreeformMode, findViewById, finish, finishActivity, finishActivityFromChild, finishAffinity, finishAfterTransition, finishAndRemoveTask, finishFromChild, getActionBar, getActivityThread, getActivityToken, getApplication, getAutofillClient, getCallingActivity, getCallingPackage, getChangingConfigurations, getComponentName, getContentScene, getContentTransitionManager, getCurrentFocus, getFragmentManager, getIntent, getLastNonConfigurationInstance, getLayoutInflater, getLoaderManager, getLocalClassName, getMaxNumPictureInPictureActions, getMediaController, getMenuInflater, getNextAutofillId, getParent, getParentActivityIntent, getPreferences, getReferrer, getRequestedOrientation, getSearchEvent, getSystemService, getTaskId, getTitle, getTitleColor, getVoiceInteractor, getVolumeControlStream, getWindow, getWindowManager, hasWindowFocus, invalidateOptionsMenu, isActivityTransitionRunning, isBackgroundVisibleBehind, isChangingConfigurations, isChild, isDestroyed, isDisablingEnterExitEventForAutofill, isFinishing, isImmersive, isInMultiWindowMode, isInPictureInPictureMode, isLocalVoiceInteractionSupported, isOverlayWithDecorCaptionEnabled, isResumed, isTaskRoot, isVoiceInteraction, isVoiceInteractionRoot, managedQuery, managedQuery, moveTaskToBack, navigateUpTo, navigateUpToFromChild, onActionModeFinished, onActionModeStarted, onActivityReenter, onApplyThemeResource, onAttachedToWindow, onAttachFragment, onBackgroundVisibleBehindChanged, onChildTitleChanged, onConfigurationChanged, onContentChanged, onContextItemSelected, onContextMenuClosed, onCreate, onCreateContextMenu, onCreateDescription, onCreateDialog, onCreateDialog, onCreateNavigateUpTaskStack, onCreateOptionsMenu, onCreatePanelMenu, onCreatePanelView, onCreateThumbnail, onCreateView, onCreateView, onDetachedFromWindow, onEnterAnimationComplete, onGenericMotionEvent, onKeyDown, onKeyLongPress, onKeyMultiple, onKeyShortcut, onKeyUp, onLocalVoiceInteractionStarted, onLocalVoiceInteractionStopped, onLowMemory, onMenuItemSelected, onMenuOpened, onMovedToDisplay, onMultiWindowModeChanged, onMultiWindowModeChanged, onNavigateUp, onNavigateUpFromChild, onNewActivityOptions, onOptionsItemSelected, onOptionsMenuClosed, onPanelClosed, onPictureInPictureModeChanged, onPictureInPictureModeChanged, onPostCreate, onPostCreate, onPrepareDialog, onPrepareDialog, onPrepareNavigateUpTaskStack, onPrepareOptionsMenu, onPreparePanel, onProvideAssistContent, onProvideAssistData, onProvideKeyboardShortcuts, onProvideReferrer, onRestart, onRestoreInstanceState, onRestoreInstanceState, onRetainNonConfigurationInstance, onSaveInstanceState, onSearchRequested, onSearchRequested, onStateNotSaved, onTitleChanged, onTouchEvent, onTrackballEvent, onUserInteraction, onVisibleBehindCanceled, onWindowAttributesChanged, onWindowDismissed, onWindowFocusChanged, onWindowStartingActionMode, onWindowStartingActionMode, openContextMenu, openOptionsMenu, overridePendingTransition, postponeEnterTransition, recreate, registerForContextMenu, registerRemoteAnimations, releaseInstance, removeDialog, reportFullyDrawn, requestDragAndDropPermissions, requestPermissions, requestShowKeyboardShortcuts, requestVisibleBehind, requestWindowFeature, requireViewById, runOnUiThread, setActionBar, setContentTransitionManager, setContentView, setContentView, setContentView, setDefaultKeyMode, setDisablePreviewScreenshots, setEnterSharedElementCallback, setExitSharedElementCallback, setFeatureDrawable, setFeatureDrawableAlpha, setFeatureDrawableResource, setFeatureDrawableUri, setFinishOnTouchOutside, setImmersive, setIntent, setMediaController, setOverlayWithDecorCaptionEnabled, setPersistent, setPictureInPictureArgs, setPictureInPictureParams, setProgress, setProgressBarIndeterminate, setProgressBarIndeterminateVisibility, setProgressBarVisibility, setRequestedOrientation, setResult, setResult, setSecondaryProgress, setShowWhenLocked, setTaskDescription, setTheme, setTitle, setTitle, setTitleColor, setTurnScreenOn, setVisible, setVolumeControlStream, setVrModeEnabled, shouldShowRequestPermissionRationale, shouldUpRecreateTask, showAssist, showDialog, showDialog, showLockTaskEscapeMessage, startActionMode, startActionMode, startActivities, startActivities, startActivity, startActivity, startActivityAsCaller, startActivityAsUser, startActivityAsUser, startActivityAsUserFromFragment, startActivityForResult, startActivityForResult, startActivityForResult, startActivityForResultAsUser, startActivityForResultAsUser, startActivityForResultAsUser, startActivityFromChild, startActivityFromChild, startActivityFromFragment, startActivityFromFragment, startActivityIfNeeded, startActivityIfNeeded, startIntentSender, startIntentSender, startIntentSenderForResult, startIntentSenderForResult, startIntentSenderFromChild, startIntentSenderFromChild, startIntentSenderFromChildFragment, startLocalVoiceInteraction, startLockTask, startManagingCursor, startNextMatchingActivity, startNextMatchingActivity, startPostponedEnterTransition, startSearch, stopLocalVoiceInteraction, stopLockTask, stopManagingCursor, takeKeyEvents, triggerSearch, unregisterForContextMenu
applyOverrideConfiguration, getAssets, getOverrideConfiguration, getResources, getTheme, getThemeResId
bindService, bindServiceAsUser, bindServiceAsUser, canLoadUnsafeResources, checkCallingOrSelfPermission, checkCallingOrSelfUriPermission, checkCallingPermission, checkCallingUriPermission, checkPermission, checkPermission, checkSelfPermission, checkUriPermission, checkUriPermission, checkUriPermission, clearWallpaper, createApplicationContext, createConfigurationContext, createContextForSplit, createCredentialProtectedStorageContext, createDeviceProtectedStorageContext, createDisplayContext, createPackageContext, createPackageContextAsUser, databaseList, deleteDatabase, deleteFile, deleteSharedPreferences, enforceCallingOrSelfPermission, enforceCallingOrSelfUriPermission, enforceCallingPermission, enforceCallingUriPermission, enforcePermission, enforceUriPermission, enforceUriPermission, fileList, getApplicationContext, getApplicationInfo, getBaseContext, getBasePackageName, getCacheDir, getClassLoader, getCodeCacheDir, getContentResolver, getDatabasePath, getDataDir, getDir, getDisplay, getDisplayAdjustments, getExternalCacheDir, getExternalCacheDirs, getExternalFilesDir, getExternalFilesDirs, getExternalMediaDirs, getFilesDir, getFileStreamPath, getIApplicationThread, getMainExecutor, getMainLooper, getMainThreadHandler, getNoBackupFilesDir, getObbDir, getObbDirs, getOpPackageName, getPackageCodePath, getPackageManager, getPackageName, getPackageResourcePath, getPreloadsFileCache, getServiceDispatcher, getSharedPreferences, getSharedPreferences, getSharedPreferencesPath, getSystemServiceName, getUserId, getWallpaper, getWallpaperDesiredMinimumHeight, getWallpaperDesiredMinimumWidth, grantUriPermission, isAutofillCompatibilityEnabled, isCredentialProtectedStorage, isDeviceProtectedStorage, isRestricted, moveDatabaseFrom, moveSharedPreferencesFrom, openFileInput, openFileOutput, openOrCreateDatabase, openOrCreateDatabase, peekWallpaper, registerReceiver, registerReceiver, registerReceiver, registerReceiver, registerReceiverAsUser, reloadSharedPreferences, removeStickyBroadcast, removeStickyBroadcastAsUser, revokeUriPermission, revokeUriPermission, sendBroadcast, sendBroadcast, sendBroadcast, sendBroadcast, sendBroadcastAsUser, sendBroadcastAsUser, sendBroadcastAsUser, sendBroadcastAsUser, sendBroadcastAsUserMultiplePermissions, sendBroadcastMultiplePermissions, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcast, sendOrderedBroadcastAsUser, sendOrderedBroadcastAsUser, sendOrderedBroadcastAsUser, sendStickyBroadcast, sendStickyBroadcastAsUser, sendStickyBroadcastAsUser, sendStickyOrderedBroadcast, sendStickyOrderedBroadcastAsUser, setAutofillClient, setAutofillCompatibilityEnabled, setWallpaper, setWallpaper, startActivitiesAsUser, startForegroundService, startForegroundServiceAsUser, startInstrumentation, startService, startServiceAsUser, stopService, stopServiceAsUser, unbindService, unregisterReceiver, updateDisplay
assertRuntimeOverlayThemable, getColor, getColorStateList, getDrawable, getSharedPrefsFile, getString, getString, getSystemService, getText, getUser, obtainStyledAttributes, obtainStyledAttributes, obtainStyledAttributes, obtainStyledAttributes, registerComponentCallbacks, unregisterComponentCallbacks
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
onPointerCaptureChanged
protected io.flutter.embedding.android.FlutterActivityAndFragmentDelegate delegate
@NonNull public static Intent createDefaultIntent(@NonNull Context launchContext)
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.
@NonNull public static FlutterActivity.NewEngineIntentBuilder withNewEngine()
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.public static FlutterActivity.CachedEngineIntentBuilder withCachedEngine(@NonNull String cachedEngineId)
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
.protected void onCreate(@Nullable Bundle savedInstanceState)
@Nullable public SplashScreen provideSplashScreen()
SplashScreenProvider
SplashScreen
to display while Flutter initializes and renders its first
frame.public void onPostResume()
onPostResume
in class Activity
protected void onSaveInstanceState(Bundle outState)
onSaveInstanceState
in class Activity
public void detachFromFlutterEngine()
FlutterEngine
has been attached to by another activity
before this activity was destroyed.
The expected behavior is for this activity to synchronously stop using the FlutterEngine
to avoid lifecycle crosstalk with the new activity.
protected void onActivityResult(int requestCode, int resultCode, Intent data)
onActivityResult
in class Activity
protected void onNewIntent(@NonNull Intent intent)
onNewIntent
in class Activity
public void onBackPressed()
onBackPressed
in class Activity
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
onRequestPermissionsResult
in class Activity
public void onUserLeaveHint()
onUserLeaveHint
in class Activity
public void onTrimMemory(int level)
onTrimMemory
in interface ComponentCallbacks2
onTrimMemory
in class Activity
@NonNull public Context getContext()
FlutterActivityAndFragmentDelegate.Host
method that is used by FlutterActivityAndFragmentDelegate
to obtain a Context
reference as needed.@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.@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.getLifecycle
in interface androidx.lifecycle.LifecycleOwner
@NonNull public FlutterShellArgs getFlutterShellArgs()
FlutterActivityAndFragmentDelegate.Host
method that is used by FlutterActivityAndFragmentDelegate
to obtain Flutter shell arguments when initializing
Flutter.@Nullable public String getCachedEngineId()
FlutterEngine
to use within this FlutterActivity
, or null
if this FlutterActivity
does not want to use a cached
FlutterEngine
.public boolean shouldDestroyEngineWithHost()
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.
@NonNull public String getDartEntrypointFunctionName()
This preference can be controlled by setting a <meta-data>
called FlutterActivityLaunchConfigs.DART_ENTRYPOINT_META_DATA_KEY
within the Android manifest
definition for this FlutterActivity
.
Subclasses may override this method to directly control the Dart entrypoint.
public String getInitialRoute()
This preference can be controlled with 2 methods:
FlutterActivityLaunchConfigs.EXTRA_INITIAL_ROUTE
with the
launching Intent
, or
<meta-data>
called FlutterActivityLaunchConfigs.INITIAL_ROUTE_META_DATA_KEY
for this Activity
in
the Android manifest.
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.
@NonNull public String getAppBundlePath()
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.
@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
.@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
.@NonNull protected FlutterActivityLaunchConfigs.BackgroundMode getBackgroundMode()
Activity
, which defaults to FlutterActivityLaunchConfigs.BackgroundMode.opaque
.@Nullable public FlutterEngine provideFlutterEngine(@NonNull Context context)
FlutterEngine
.
This hook is where a cached FlutterEngine
should be provided, if a cached FlutterEngine
is desired.
@Nullable protected FlutterEngine getFlutterEngine()
FlutterEngine
that is owned by this
FlutterActivity
.@Nullable protected Bundle getMetaData() throws PackageManager.NameNotFoundException
@Nullable public PlatformPlugin providePlatformPlugin(@Nullable Activity activity, @NonNull FlutterEngine flutterEngine)
PlatformPlugin
if the associated Flutter
experience should control system chrome.public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine)
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. To avoid automatic plugin registration, 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.
public void cleanUpFlutterEngine(@NonNull FlutterEngine flutterEngine)
configureFlutterEngine(FlutterEngine)
before the host is destroyed or detached.
This method is called in onDestroy()
.
public boolean shouldAttachEngineToActivity()
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
FluttterActivity
at an unusual time, preventing this FlutterActivity
from
correctly managing the relationship between the FlutterEngine
and itself.
public boolean shouldHandleDeeplinking()
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
.
public void onFlutterSurfaceViewCreated(@NonNull FlutterSurfaceView flutterSurfaceView)
FlutterSurfaceView
that renders the Flutter UI is
initially instantiated.
This method is only invoked if the FlutterView.RenderMode
is set to FlutterView.RenderMode.surface
. Otherwise, onFlutterTextureViewCreated(FlutterTextureView)
is invoked.
This method is invoked before the given FlutterSurfaceView
is attached to the
View
hierarchy. Implementers should not attempt to climb the View
hierarchy
or make assumptions about relationships with other View
s.
public void onFlutterTextureViewCreated(@NonNull FlutterTextureView flutterTextureView)
FlutterTextureView
that renders the Flutter UI is
initially instantiated.
This method is only invoked if the FlutterView.RenderMode
is set to FlutterView.RenderMode.texture
. Otherwise, onFlutterSurfaceViewCreated(FlutterSurfaceView)
is invoked.
This method is invoked before the given FlutterTextureView
is attached to the
View
hierarchy. Implementers should not attempt to climb the View
hierarchy
or make assumptions about relationships with other View
s.
public void onFlutterUiDisplayed()
FlutterView
starts painting pixels.public void onFlutterUiNoLongerDisplayed()
FlutterView
stops painting pixels.public boolean shouldRestoreAndSaveState()
When this returns true, the instance state provided to onRestoreInstanceState(Bundle)
will be forwarded to the framework via the RestorationChannel
and during onSaveInstanceState(Bundle)
the current framework
instance state obtained from RestorationChannel
will be stored in the provided
bundle.
This defaults to true, unless a cached engine is used.
public boolean popSystemNavigator()
PlatformPlugin.PlatformPluginDelegate
OnBackPressedDispatcher
will be executed.