io.flutter.embedding.android.FlutterActivityAndFragmentDelegate Class Reference

Inheritance diagram for io.flutter.embedding.android.FlutterActivityAndFragmentDelegate:

Classes
interface	DelegateFactory
interface	Host

Public Member Functions
Activity	getAppComponent ()
void	detachFromFlutterEngine ()
Public Member Functions inherited from io.flutter.embedding.android.ExclusiveAppComponent< Activity >
void	detachFromFlutterEngine ()
T	getAppComponent ()

Package Functions
	FlutterActivityAndFragmentDelegate (@NonNull Host host)
	FlutterActivityAndFragmentDelegate (@NonNull Host host, @Nullable FlutterEngineGroup engineGroup)
void	release ()
FlutterEngine	getFlutterEngine ()
boolean	isFlutterEngineFromHost ()
boolean	isAttached ()
void	onAttach (@NonNull Context context)
void	setUpFlutterEngine ()
View	onCreateView (LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState, int flutterViewId, boolean shouldDelayFirstAndroidViewDraw)
void	onRestoreInstanceState (@Nullable Bundle bundle)
void	onStart ()
void	onResume ()
void	onPostResume ()
void	updateSystemUiOverlays ()
void	onPause ()
void	onStop ()
void	onDestroyView ()
void	onSaveInstanceState (@Nullable Bundle bundle)
void	onDetach ()
void	onBackPressed ()
void	startBackGesture (@NonNull BackEvent backEvent)
void	updateBackGestureProgress (@NonNull BackEvent backEvent)
void	commitBackGesture ()
void	cancelBackGesture ()
void	onRequestPermissionsResult (int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
void	onNewIntent (@NonNull Intent intent)
void	onActivityResult (int requestCode, int resultCode, Intent data)
void	onUserLeaveHint ()
void	onWindowFocusChanged (boolean hasFocus)
void	onTrimMemory (int level)

Package Attributes
FlutterView	flutterView
OnPreDrawListener	activePreDrawListener

Detailed Description

Delegate that implements all Flutter logic that is the same between a FlutterActivity and a FlutterFragment.

Why does this class exist?

One might ask why an Activity and Fragment delegate needs to exist. Given that a Fragment can be placed within an Activity, it would make more sense to use a FlutterFragment within a FlutterActivity.

The Fragment support library adds 100k of binary size to an app, and full-Flutter apps do not otherwise require that binary hit. Therefore, it was concluded that Flutter must provide a FlutterActivity based on the AOSP Activity, and an independent FlutterFragment for add-to-app developers.

If a time ever comes where the inclusion of Fragments in a full-Flutter app is no longer deemed an issue, this class should be immediately decomposed between FlutterActivity and FlutterFragment and then eliminated.

Caution when modifying this class

Any time that a "delegate" is created with the purpose of encapsulating the internal behaviors of another object, that delegate is highly susceptible to degeneration. It is easy to tack new responsibilities on to the delegate which would not otherwise be added to the original object. It is also easy to begin hanging listeners and callbacks on a delegate object that likewise would not be added to the original object. A delegate can quickly become a complex web of dependencies and optional references that are very difficult to track.

Maintainers of this class should take care to only place code in this delegate that would otherwise be placed in either FlutterActivity or FlutterFragment, and in exactly the same form. Do not use this class as a convenient shortcut for any other behavior.

Definition at line 75 of file FlutterActivityAndFragmentDelegate.java.

Constructor & Destructor Documentation

FlutterActivityAndFragmentDelegate() [1/2]

io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.FlutterActivityAndFragmentDelegate ( @NonNull Host  host )

inlinepackage

Definition at line 117 of file FlutterActivityAndFragmentDelegate.java.

                                                         {
    this(host, null);
  }

FlutterActivityAndFragmentDelegate() [2/2]

io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.FlutterActivityAndFragmentDelegate ( @NonNull Host  host, @Nullable FlutterEngineGroup  engineGroup  )

inlinepackage

Definition at line 121 of file FlutterActivityAndFragmentDelegate.java.

                                                                                                   {
    this.host = host;
    this.isFirstFrameRendered = false;
    this.engineGroup = engineGroup;
  }

Member Function Documentation

cancelBackGesture()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.cancelBackGesture ( )

inlinepackage

Invoke this from OnBackAnimationCallback#onBackCancelled().

This method should be called when a back gesture is cancelled or the back button is pressed. It informs the Flutter framework about the cancellation.

This method enables the Flutter framework to rollback any UI changes or animations initiated in response to the back gesture. This includes resetting UI elements to their state prior to the gesture's start.

Definition at line 879 of file FlutterActivityAndFragmentDelegate.java.

                           {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(TAG, "Forwarding cancelBackGesture() to FlutterEngine.");
      flutterEngine.getBackGestureChannel().cancelBackGesture();
    } else {
      Log.w(TAG, "Invoked cancelBackGesture() before FlutterFragment was attached to an Activity.");
    }
  }

commitBackGesture()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.commitBackGesture ( )

inlinepackage

Invoke this from OnBackAnimationCallback#onBackInvoked().

This method is called to signify the completion of a back gesture and commits the navigation action initiated by the gesture. It should be invoked as the final step in handling a back gesture.

This method indicates to the Flutter framework that it should proceed with the back navigation, including finalizing animations and updating the UI to reflect the navigation outcome.

Definition at line 857 of file FlutterActivityAndFragmentDelegate.java.

                           {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(TAG, "Forwarding commitBackGesture() to FlutterEngine.");
      flutterEngine.getBackGestureChannel().commitBackGesture();
    } else {
      Log.w(TAG, "Invoked commitBackGesture() before FlutterFragment was attached to an Activity.");
    }
  }

detachFromFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.detachFromFlutterEngine ( )

inline

Definition at line 697 of file FlutterActivityAndFragmentDelegate.java.

                                        {
    if (host.shouldDestroyEngineWithHost()) {
      // The host owns the engine and should never have its engine taken by another exclusive
      // activity.
      throw new AssertionError(
          "The internal FlutterEngine created by "
              + host
              + " has been attached to by another activity. To persist a FlutterEngine beyond the "
              + "ownership of this activity, explicitly create a FlutterEngine");
    }
 
    // Default, but customizable, behavior is for the host to call {@link #onDetach}
    // deterministically as to not mix more events during the lifecycle of the next exclusive
    // activity.
    host.detachFromFlutterEngine();
  }

getAppComponent()

Activity io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.getAppComponent ( )

inline

Definition at line 224 of file FlutterActivityAndFragmentDelegate.java.

                                             {
    final Activity activity = host.getActivity();
    if (activity == null) {
      throw new AssertionError(
          "FlutterActivityAndFragmentDelegate's getAppComponent should only "
              + "be queried after onAttach, when the host's activity should always be non-null");
    }
    return activity;
  }

getFlutterEngine()

FlutterEngine io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.getFlutterEngine ( )

inlinepackage

Returns the io.flutter.embedding.engine.FlutterEngine that is owned by this delegate and its host Activity or Fragment.

Definition at line 150 of file FlutterActivityAndFragmentDelegate.java.

                                     {
    return flutterEngine;
  }

isAttached()

boolean io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.isAttached ( )

inlinepackage

Whether or not this FlutterActivityAndFragmentDelegate is attached to a
FlutterEngine.

Definition at line 166 of file FlutterActivityAndFragmentDelegate.java.

                         {
    return isAttached;
  }

isFlutterEngineFromHost()

boolean io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.isFlutterEngineFromHost ( )

inlinepackage

Returns true if the host Activity/Fragment provided a FlutterEngine, as opposed to this delegate creating a new one.

Definition at line 158 of file FlutterActivityAndFragmentDelegate.java.

                                      {
    return isFlutterEngineFromHost;
  }

onActivityResult()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onActivityResult ( int  requestCode, int  resultCode, Intent  data  )

inlinepackage

Invoke this from Activity#onActivityResult(int, int, Intent) or
Fragment#onActivityResult(int, int, Intent).

This method forwards to interested Flutter plugins.

Definition at line 950 of file FlutterActivityAndFragmentDelegate.java.

                                                                      {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(
          TAG,
          "Forwarding onActivityResult() to FlutterEngine:\n"
              + "requestCode: "
              + requestCode
              + "\n"
              + "resultCode: "
              + resultCode
              + "\n"
              + "data: "
              + data);
      flutterEngine.getActivityControlSurface().onActivityResult(requestCode, resultCode, data);
    } else {
      Log.w(TAG, "onActivityResult() invoked before FlutterFragment was attached to an Activity.");
    }
  }

onAttach()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onAttach ( @NonNull Context  context )

inlinepackage

Invoke this method from Activity#onCreate(Bundle) or
Fragment#onAttach(Context).

This method does the following:

1. Initializes the Flutter system.
2. Obtains or creates a io.flutter.embedding.engine.FlutterEngine.
3. Creates and configures a PlatformPlugin.
4. Attaches the io.flutter.embedding.engine.FlutterEngine to the surrounding
Activity, if desired.
5. Configures the io.flutter.embedding.engine.FlutterEngine via Host#configureFlutterEngine(FlutterEngine).

Definition at line 188 of file FlutterActivityAndFragmentDelegate.java.

                                          {
    ensureAlive();
 
    // When "retain instance" is true, the FlutterEngine will survive configuration
    // changes. Therefore, we create a new one only if one does not already exist.
    if (flutterEngine == null) {
      setUpFlutterEngine();
    }
 
    if (host.shouldAttachEngineToActivity()) {
      // Notify any plugins that are currently attached to our FlutterEngine that they
      // are now attached to an Activity.
      //
      // Passing this Fragment's Lifecycle should be sufficient because as long as this Fragment
      // is attached to its Activity, the lifecycles should be in sync. Once this Fragment is
      // detached from its Activity, that Activity will be detached from the FlutterEngine, too,
      // which means there shouldn't be any possibility for the Fragment Lifecycle to get out of
      // sync with the Activity. We use the Fragment's Lifecycle because it is possible that the
      // attached Activity is not a LifecycleOwner.
      Log.v(TAG, "Attaching FlutterEngine to the Activity that owns this delegate.");
      flutterEngine.getActivityControlSurface().attachToActivity(this, host.getLifecycle());
    }
 
    // Regardless of whether or not a FlutterEngine already existed, the PlatformPlugin
    // is bound to a specific Activity. Therefore, it needs to be created and configured
    // every time this Fragment attaches to a new Activity.
    // TODO(mattcarroll): the PlatformPlugin needs to be reimagined because it implicitly takes
    //                    control of the entire window. This is unacceptable for non-fullscreen
    //                    use-cases.
    platformPlugin = host.providePlatformPlugin(host.getActivity(), flutterEngine);
 
    host.configureFlutterEngine(flutterEngine);
    isAttached = true;
  }

onBackPressed()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onBackPressed ( )

inlinepackage

Invoke this from android.app.Activity#onBackPressed().

A Fragment host must have its containing Activity forward this call so that the Fragment can then invoke this method.

This method instructs Flutter's navigation system to "pop route".

Definition at line 785 of file FlutterActivityAndFragmentDelegate.java.

                       {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(TAG, "Forwarding onBackPressed() to FlutterEngine.");
      flutterEngine.getNavigationChannel().popRoute();
    } else {
      Log.w(TAG, "Invoked onBackPressed() before FlutterFragment was attached to an Activity.");
    }
  }

onCreateView()

View io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onCreateView ( LayoutInflater  inflater, @Nullable ViewGroup  container, @Nullable Bundle  savedInstanceState, int  flutterViewId, boolean  shouldDelayFirstAndroidViewDraw  )

inlinepackage

Invoke this method from Activity#onCreate(Bundle) to create the content View, or from Fragment#onCreateView(LayoutInflater, ViewGroup, Bundle).

inflater and container may be null when invoked from an Activity.

shouldDelayFirstAndroidViewDraw determines whether to set up an android.view.ViewTreeObserver.OnPreDrawListener, which will defer the current drawing pass till after the Flutter UI has been displayed. This results in more accurate timings reported with Android tools, such as "Displayed" timing printed with am start.

Note that it should only be set to true when Host#getRenderMode() is
RenderMode.surface.

This method:

1. creates a new FlutterView in a View hierarchy
2. adds a FlutterUiDisplayListener to it
3. attaches a io.flutter.embedding.engine.FlutterEngine to the new FlutterView
4. returns the new View hierarchy

Definition at line 365 of file FlutterActivityAndFragmentDelegate.java.

                                               {
    Log.v(TAG, "Creating FlutterView.");
    ensureAlive();
 
    if (host.getRenderMode() == RenderMode.surface) {
      FlutterSurfaceView flutterSurfaceView =
          new FlutterSurfaceView(
              host.getContext(), host.getTransparencyMode() == TransparencyMode.transparent);
 
      // Allow our host to customize FlutterSurfaceView, if desired.
      host.onFlutterSurfaceViewCreated(flutterSurfaceView);
 
      // Create the FlutterView that owns the FlutterSurfaceView.
      flutterView = new FlutterView(host.getContext(), flutterSurfaceView);
    } else {
      FlutterTextureView flutterTextureView = new FlutterTextureView(host.getContext());
 
      flutterTextureView.setOpaque(host.getTransparencyMode() == TransparencyMode.opaque);
 
      // Allow our host to customize FlutterSurfaceView, if desired.
      host.onFlutterTextureViewCreated(flutterTextureView);
 
      // Create the FlutterView that owns the FlutterTextureView.
      flutterView = new FlutterView(host.getContext(), flutterTextureView);
    }
 
    // Add listener to be notified when Flutter renders its first frame.
    flutterView.addOnFirstFrameRenderedListener(flutterUiDisplayListener);
 
    if (host.attachToEngineAutomatically()) {
      Log.v(TAG, "Attaching FlutterEngine to FlutterView.");
      flutterView.attachToFlutterEngine(flutterEngine);
    }
    flutterView.setId(flutterViewId);
 
    if (shouldDelayFirstAndroidViewDraw) {
      delayFirstAndroidViewDraw(flutterView);
    }
    return flutterView;
  }

onDestroyView()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onDestroyView ( )

inlinepackage

Invoke this from Activity#onDestroy() or Fragment#onDestroyView().

This method removes this delegate's FlutterView's FlutterUiDisplayListener.

Definition at line 662 of file FlutterActivityAndFragmentDelegate.java.

                       {
    Log.v(TAG, "onDestroyView()");
    ensureAlive();
 
    if (activePreDrawListener != null) {
      flutterView.getViewTreeObserver().removeOnPreDrawListener(activePreDrawListener);
      activePreDrawListener = null;
    }
 
    // flutterView can be null in instances where a delegate.onDestroyView is called without
    // onCreateView being called. See https://github.com/flutter/engine/pull/41082 for more detail.
    if (flutterView != null) {
      flutterView.detachFromFlutterEngine();
      flutterView.removeOnFirstFrameRenderedListener(flutterUiDisplayListener);
    }
  }

onDetach()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onDetach ( )

inlinepackage

Invoke this from Activity#onDestroy() or Fragment#onDetach().

This method:

1. Detaches this delegate's io.flutter.embedding.engine.FlutterEngine from its surrounding Activity, if it was previously attached.
2. Destroys this delegate's PlatformPlugin.
3. Destroys this delegate's io.flutter.embedding.engine.FlutterEngine if Host#shouldDestroyEngineWithHost() ()} returns true.

Definition at line 729 of file FlutterActivityAndFragmentDelegate.java.

                  {
    if (!isAttached) {
      // Already detached.
      return;
    }
    Log.v(TAG, "onDetach()");
    ensureAlive();
 
    // Give the host an opportunity to cleanup any references that were created in
    // configureFlutterEngine().
    host.cleanUpFlutterEngine(flutterEngine);
 
    if (host.shouldAttachEngineToActivity()) {
      // Notify plugins that they are no longer attached to an Activity.
      Log.v(TAG, "Detaching FlutterEngine from the Activity that owns this Fragment.");
      if (host.getActivity().isChangingConfigurations()) {
        flutterEngine.getActivityControlSurface().detachFromActivityForConfigChanges();
      } else {
        flutterEngine.getActivityControlSurface().detachFromActivity();
      }
    }
 
    // Null out the platformPlugin to avoid a possible retain cycle between the plugin, this
    // Fragment,
    // and this Fragment's Activity.
    if (platformPlugin != null) {
      platformPlugin.destroy();
      platformPlugin = null;
    }
 
    if (host.shouldDispatchAppLifecycleState() && flutterEngine != null) {
      flutterEngine.getLifecycleChannel().appIsDetached();
    }
 
    // Destroy our FlutterEngine if we're not set to retain it.
    if (host.shouldDestroyEngineWithHost()) {
      flutterEngine.destroy();
 
      if (host.getCachedEngineId() != null) {
        FlutterEngineCache.getInstance().remove(host.getCachedEngineId());
      }
 
      flutterEngine = null;
    }
 
    isAttached = false;
  }

onNewIntent()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onNewIntent ( @NonNull Intent  intent )

inlinepackage

Invoke this from Activity#onNewIntent(Intent).

A Fragment host must have its containing Activity forward this call so that the Fragment can then invoke this method.

This method forwards to interested Flutter plugins.

Definition at line 928 of file FlutterActivityAndFragmentDelegate.java.

                                           {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(
          TAG,
          "Forwarding onNewIntent() to FlutterEngine and sending pushRouteInformation message.");
      flutterEngine.getActivityControlSurface().onNewIntent(intent);
      String initialRoute = maybeGetInitialRouteFromIntent(intent);
      if (initialRoute != null && !initialRoute.isEmpty()) {
        flutterEngine.getNavigationChannel().pushRouteInformation(initialRoute);
      }
    } else {
      Log.w(TAG, "onNewIntent() invoked before FlutterFragment was attached to an Activity.");
    }
  }

onPause()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onPause ( )

inlinepackage

Invoke this from Activity#onPause() or Fragment#onPause().

This method notifies the running Flutter app that it is "inactive" as per the Flutter app lifecycle.

Definition at line 612 of file FlutterActivityAndFragmentDelegate.java.

                 {
    Log.v(TAG, "onPause()");
    ensureAlive();
    if (host.shouldDispatchAppLifecycleState() && flutterEngine != null) {
      flutterEngine.getLifecycleChannel().appIsInactive();
    }
  }

onPostResume()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onPostResume ( )

inlinepackage

Invoke this from Activity#onPostResume().

A Fragment host must have its containing Activity forward this call so that the Fragment can then invoke this method.

This method informs the PlatformPlugin that onPostResume() has run, which is used to update system UI overlays.

Definition at line 582 of file FlutterActivityAndFragmentDelegate.java.

                      {
    Log.v(TAG, "onPostResume()");
    ensureAlive();
    if (flutterEngine != null) {
      updateSystemUiOverlays();
      flutterEngine.getPlatformViewsController().onResume();
    } else {
      Log.w(TAG, "onPostResume() invoked before FlutterFragment was attached to an Activity.");
    }
  }

onRequestPermissionsResult()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onRequestPermissionsResult ( int  requestCode, @NonNull String[]  permissions, @NonNull int[]  grantResults  )

inlinepackage

Invoke this from android.app.Activity#onRequestPermissionsResult(int, String[], int[]) or Fragment#onRequestPermissionsResult(int, String[], int[]).

This method forwards to interested Flutter plugins.

Definition at line 895 of file FlutterActivityAndFragmentDelegate.java.

                                                                                   {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(
          TAG,
          "Forwarding onRequestPermissionsResult() to FlutterEngine:\n"
              + "requestCode: "
              + requestCode
              + "\n"
              + "permissions: "
              + Arrays.toString(permissions)
              + "\n"
              + "grantResults: "
              + Arrays.toString(grantResults));
      flutterEngine
          .getActivityControlSurface()
          .onRequestPermissionsResult(requestCode, permissions, grantResults);
    } else {
      Log.w(
          TAG,
          "onRequestPermissionResult() invoked before FlutterFragment was attached to an Activity.");
    }
  }

onRestoreInstanceState()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onRestoreInstanceState ( @Nullable Bundle  bundle )

inlinepackage

Definition at line 411 of file FlutterActivityAndFragmentDelegate.java.

                                                       {
    Log.v(
        TAG,
        "onRestoreInstanceState. Giving framework and plugins an opportunity to restore state.");
    ensureAlive();
 
    Bundle pluginState = null;
    byte[] frameworkState = null;
    if (bundle != null) {
      pluginState = bundle.getBundle(PLUGINS_RESTORATION_BUNDLE_KEY);
      frameworkState = bundle.getByteArray(FRAMEWORK_RESTORATION_BUNDLE_KEY);
    }
 
    if (host.shouldRestoreAndSaveState()) {
      flutterEngine.getRestorationChannel().setRestorationData(frameworkState);
    }
 
    if (host.shouldAttachEngineToActivity()) {
      flutterEngine.getActivityControlSurface().onRestoreInstanceState(pluginState);
    }
  }

onResume()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onResume ( )

inlinepackage

Invoke this from Activity#onResume() or Fragment#onResume().

This method notifies the running Flutter app that it is "resumed" as per the Flutter app lifecycle.

Definition at line 563 of file FlutterActivityAndFragmentDelegate.java.

                  {
    Log.v(TAG, "onResume()");
    ensureAlive();
    if (host.shouldDispatchAppLifecycleState() && flutterEngine != null) {
      flutterEngine.getLifecycleChannel().appIsResumed();
    }
  }

onSaveInstanceState()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onSaveInstanceState ( @Nullable Bundle  bundle )

inlinepackage

Definition at line 679 of file FlutterActivityAndFragmentDelegate.java.

                                                    {
    Log.v(TAG, "onSaveInstanceState. Giving framework and plugins an opportunity to save state.");
    ensureAlive();
 
    if (host.shouldRestoreAndSaveState()) {
      bundle.putByteArray(
          FRAMEWORK_RESTORATION_BUNDLE_KEY,
          flutterEngine.getRestorationChannel().getRestorationData());
    }
 
    if (host.shouldAttachEngineToActivity()) {
      final Bundle plugins = new Bundle();
      flutterEngine.getActivityControlSurface().onSaveInstanceState(plugins);
      bundle.putBundle(PLUGINS_RESTORATION_BUNDLE_KEY, plugins);
    }
  }

onStart()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onStart ( )

inlinepackage

Invoke this from Activity#onStart() or Fragment#onStart().

This method:

1. Begins executing Dart code, if it is not already executing.

Definition at line 444 of file FlutterActivityAndFragmentDelegate.java.

                 {
    Log.v(TAG, "onStart()");
    ensureAlive();
    doInitialFlutterViewRun();
    // This is a workaround for a bug on some OnePlus phones. The visibility of the application
    // window is still true after locking the screen on some OnePlus phones, and shows a black
    // screen when unlocked. We can work around this by changing the visibility of FlutterView in
    // onStart and onStop.
    // See https://github.com/flutter/flutter/issues/93276
    if (previousVisibility != null) {
      flutterView.setVisibility(previousVisibility);
    }
  }

onStop()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onStop ( )

inlinepackage

Invoke this from Activity#onStop() or Fragment#onStop().

This method:

1. This method notifies the running Flutter app that it is "paused" as per the Flutter app lifecycle.
2. Detaches this delegate's io.flutter.embedding.engine.FlutterEngine from this delegate's FlutterView.

Definition at line 634 of file FlutterActivityAndFragmentDelegate.java.

                {
    Log.v(TAG, "onStop()");
    ensureAlive();
 
    if (host.shouldDispatchAppLifecycleState() && flutterEngine != null) {
      flutterEngine.getLifecycleChannel().appIsPaused();
    }
 
    // This is a workaround for a bug on some OnePlus phones. The visibility of the application
    // window is still true after locking the screen on some OnePlus phones, and shows a black
    // screen when unlocked. We can work around this by changing the visibility of FlutterView in
    // onStart and onStop.
    // See https://github.com/flutter/flutter/issues/93276
    previousVisibility = flutterView.getVisibility();
    flutterView.setVisibility(View.GONE);
    if (flutterEngine != null) {
      // When an Activity is stopped it won't have its onTrimMemory callback invoked. Normally,
      // this isn't a problem but because of a bug in some builds of Android 14 we must act as
      // if the onTrimMemory callback has been called.
      flutterEngine.getRenderer().onTrimMemory(ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
    }
  }

onTrimMemory()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onTrimMemory ( int  level )

inlinepackage

Invoke this from android.app.Activity#onTrimMemory(int).

A Fragment host must have its containing Activity forward this call so that the Fragment can then invoke this method.

This method sends a "memory pressure warning" message to Flutter over the "system channel".

Definition at line 1017 of file FlutterActivityAndFragmentDelegate.java.

                               {
    ensureAlive();
    if (flutterEngine != null) {
      // Use a trim level delivered while the application is running so the
      // framework has a chance to react to the notification.
      // Avoid being too aggressive before the first frame is rendered. If it is
      // not at least running critical, we should avoid delaying the frame for
      // an overly aggressive GC.
      boolean trim = isFirstFrameRendered && level >= TRIM_MEMORY_RUNNING_LOW;
      if (trim) {
        flutterEngine.getDartExecutor().notifyLowMemoryWarning();
        flutterEngine.getSystemChannel().sendMemoryPressureWarning();
      }
      flutterEngine.getRenderer().onTrimMemory(level);
      flutterEngine.getPlatformViewsController().onTrimMemory(level);
    }
  }

onUserLeaveHint()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onUserLeaveHint ( )

inlinepackage

Invoke this from Activity#onUserLeaveHint().

A Fragment host must have its containing Activity forward this call so that the Fragment can then invoke this method.

This method forwards to interested Flutter plugins.

Definition at line 978 of file FlutterActivityAndFragmentDelegate.java.

                         {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(TAG, "Forwarding onUserLeaveHint() to FlutterEngine.");
      flutterEngine.getActivityControlSurface().onUserLeaveHint();
    } else {
      Log.w(TAG, "onUserLeaveHint() invoked before FlutterFragment was attached to an Activity.");
    }
  }

onWindowFocusChanged()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.onWindowFocusChanged ( boolean  hasFocus )

inlinepackage

Invoke this from Activity#onWindowFocusChanged().

A Fragment host must have its containing Activity forward this call so that the Fragment can then invoke this method.

Definition at line 994 of file FlutterActivityAndFragmentDelegate.java.

                                              {
    ensureAlive();
    Log.v(TAG, "Received onWindowFocusChanged: " + (hasFocus ? "true" : "false"));
    if (host.shouldDispatchAppLifecycleState() && flutterEngine != null) {
      // TODO(gspencergoog): Once we have support for multiple windows/views,
      // this code will need to consult the list of windows/views to determine if
      // any windows in the app are focused and call the appropriate function.
      if (hasFocus) {
        flutterEngine.getLifecycleChannel().aWindowIsFocused();
      } else {
        flutterEngine.getLifecycleChannel().noWindowsAreFocused();
      }
    }
  }

release()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.release ( )

inlinepackage

Disconnects this FlutterActivityAndFragmentDelegate from its host Activity or Fragment.

No further method invocations may occur on this FlutterActivityAndFragmentDelegate after invoking this method. If a method is invoked, an exception will occur.

This method only clears out references. It does not destroy its io.flutter.embedding.engine.FlutterEngine. The behavior that destroys a io.flutter.embedding.engine.FlutterEngine can be found in onDetach().

Definition at line 138 of file FlutterActivityAndFragmentDelegate.java.

                 {
    this.host = null;
    this.flutterEngine = null;
    this.flutterView = null;
    this.platformPlugin = null;
  }

setUpFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.setUpFlutterEngine ( )

inlinepackage

Obtains a reference to a FlutterEngine to back this delegate and its host.

First, the host is asked if it would like to use a cached io.flutter.embedding.engine.FlutterEngine, and if so, the cached io.flutter.embedding.engine.FlutterEngine is retrieved.

Second, the host is given an opportunity to provide a io.flutter.embedding.engine.FlutterEngine via Host#provideFlutterEngine(Context).

Third, the host is asked if it would like to use a cached io.flutter.embedding.engine.FlutterEngineGroup to create a new FlutterEngine by FlutterEngineGroup#createAndRunEngine

If the host does not provide a io.flutter.embedding.engine.FlutterEngine, then a new FlutterEngine is instantiated.

Definition at line 276 of file FlutterActivityAndFragmentDelegate.java.

                              {
    Log.v(TAG, "Setting up FlutterEngine.");
 
    // First, check if the host wants to use a cached FlutterEngine.
    String cachedEngineId = host.getCachedEngineId();
    if (cachedEngineId != null) {
      flutterEngine = FlutterEngineCache.getInstance().get(cachedEngineId);
      isFlutterEngineFromHost = true;
      if (flutterEngine == null) {
        throw new IllegalStateException(
            "The requested cached FlutterEngine did not exist in the FlutterEngineCache: '"
                + cachedEngineId
                + "'");
      }
      return;
    }
 
    // Second, defer to subclasses for a custom FlutterEngine.
    flutterEngine = host.provideFlutterEngine(host.getContext());
    if (flutterEngine != null) {
      isFlutterEngineFromHost = true;
      return;
    }
 
    // Third, check if the host wants to use a cached FlutterEngineGroup
    // and create new FlutterEngine using FlutterEngineGroup#createAndRunEngine
    String cachedEngineGroupId = host.getCachedEngineGroupId();
    if (cachedEngineGroupId != null) {
      FlutterEngineGroup flutterEngineGroup =
          FlutterEngineGroupCache.getInstance().get(cachedEngineGroupId);
      if (flutterEngineGroup == null) {
        throw new IllegalStateException(
            "The requested cached FlutterEngineGroup did not exist in the FlutterEngineGroupCache: '"
                + cachedEngineGroupId
                + "'");
      }
 
      flutterEngine =
          flutterEngineGroup.createAndRunEngine(
              addEntrypointOptions(new FlutterEngineGroup.Options(host.getContext())));
      isFlutterEngineFromHost = false;
      return;
    }
 
    // Our host did not provide a custom FlutterEngine. Create a FlutterEngine to back our
    // FlutterView.
    Log.v(
        TAG,
        "No preferred FlutterEngine was provided. Creating a new FlutterEngine for"
            + " this FlutterFragment.");
 
    FlutterEngineGroup group =
        engineGroup == null
            ? new FlutterEngineGroup(host.getContext(), host.getFlutterShellArgs().toArray())
            : engineGroup;
    flutterEngine =
        group.createAndRunEngine(
            addEntrypointOptions(
                new FlutterEngineGroup.Options(host.getContext())
                    .setAutomaticallyRegisterPlugins(false)
                    .setWaitForRestorationData(host.shouldRestoreAndSaveState())));
    isFlutterEngineFromHost = false;
  }

startBackGesture()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.startBackGesture ( @NonNull BackEvent  backEvent )

inlinepackage

Invoke this from OnBackAnimationCallback#onBackStarted(BackEvent).

This method should be called when the back gesture is initiated. It should be invoked as part of the implementation of OnBackAnimationCallback.

This method delegates the handling of the start of a back gesture to the Flutter framework, which is responsible for the appropriate response, such as initiating animations or preparing the UI for the back navigation process.

Parameters

backEvent

The BackEvent object containing information about the touch.

Definition at line 809 of file FlutterActivityAndFragmentDelegate.java.

                                                      {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(TAG, "Forwarding startBackGesture() to FlutterEngine.");
      flutterEngine.getBackGestureChannel().startBackGesture(backEvent);
    } else {
      Log.w(TAG, "Invoked startBackGesture() before FlutterFragment was attached to an Activity.");
    }
  }

updateBackGestureProgress()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.updateBackGestureProgress ( @NonNull BackEvent  backEvent )

inlinepackage

Invoke this from OnBackAnimationCallback#onBackProgressed(BackEvent).

This method should be called in response to progress in a back gesture, as part of the implementation of OnBackAnimationCallback.

This method delegates to the Flutter framework to update UI elements or animations based on the progression of the back gesture.

Parameters

backEvent

An BackEvent object describing the progress event.

Definition at line 832 of file FlutterActivityAndFragmentDelegate.java.

                                                               {
    ensureAlive();
    if (flutterEngine != null) {
      Log.v(TAG, "Forwarding updateBackGestureProgress() to FlutterEngine.");
      flutterEngine.getBackGestureChannel().updateBackGestureProgress(backEvent);
    } else {
      Log.w(
          TAG,
          "Invoked updateBackGestureProgress() before FlutterFragment was attached to an Activity.");
    }
  }

updateSystemUiOverlays()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.updateSystemUiOverlays ( )

inlinepackage

Refreshes Android's window system UI (AKA system chrome) to match Flutter's desired system chrome style.

Definition at line 597 of file FlutterActivityAndFragmentDelegate.java.

                                {
    if (platformPlugin != null) {
      // TODO(mattcarroll): find a better way to handle the update of UI overlays than calling
      // through to platformPlugin. We're implicitly entangling the Window, Activity,
      // Fragment, and engine all with this one call.
      platformPlugin.updateSystemUiOverlays();
    }
  }

Member Data Documentation

activePreDrawListener

OnPreDrawListener io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.activePreDrawListener

package

Definition at line 92 of file FlutterActivityAndFragmentDelegate.java.

flutterView

FlutterView io.flutter.embedding.android.FlutterActivityAndFragmentDelegate.flutterView

package

Definition at line 90 of file FlutterActivityAndFragmentDelegate.java.

---

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

• shell/platform/android/io/flutter/embedding/android/FlutterActivityAndFragmentDelegate.java