io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest Class Reference

Public Member Functions
void	setup ()
void	itSendsLifecycleEventsToFlutter ()
void	itDoesNotSendsLifecycleEventsToFlutter ()
void	itDefersToTheHostToProvideFlutterEngine ()
void	itUsesCachedEngineWhenProvided ()
void	itThrowsExceptionIfCachedEngineDoesNotExist ()
void	flutterEngineGroupGetsInitialRouteFromIntent ()
void	itUsesNewEngineInGroupWhenProvided ()
void	itThrowsExceptionIfNewEngineInGroupNotExist ()
void	itGivesHostAnOpportunityToConfigureFlutterEngine ()
void	itGivesHostAnOpportunityToConfigureFlutterSurfaceView ()
void	itGivesHostAnOpportunityToConfigureFlutterTextureView ()
void	itGivesHostAnOpportunityToCleanUpFlutterEngine ()
void	itSendsInitialRouteToFlutter ()
void	itExecutesDartEntrypointProvidedByHost ()
void	itExecutesDartEntrypointWithArgsProvidedByHost ()
void	itExecutesDartLibraryUriProvidedByHost ()
void	itUsesDefaultFlutterLoaderAppBundlePathWhenUnspecified ()
void	itAttachesFlutterToTheActivityIfDesired ()
void	itDoesNotAttachFlutterToTheActivityIfNotDesired ()
void	itSendsPopRouteMessageToFlutterWhenHardwareBackButtonIsPressed ()
void	itForwardsStartBackGestureToFlutter ()
void	itForwardsUpdateBackGestureProgressToFlutter ()
void	itForwardsCommitBackGestureToFlutter ()
void	itForwardsCancelBackGestureToFlutter ()
void	itForwardsOnRequestPermissionsResultToFlutterEngine ()
void	itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinking ()
void	itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingWithQueryParameterAndFragment ()
void	itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingWithFragmentNoQueryParameter ()
void	itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingNoQueryParameter ()
void	itSendsdefaultInitialRouteOnStartIfNotDeepLinkingFromIntent ()
void	itSendsPushRouteInformationMessageWhenOnNewIntent ()
void	itDoesSendPushRouteInformationMessageWhenOnNewIntentIsNonHierarchicalUri ()
void	itSendsPushRouteInformationMessageWhenOnNewIntentWithQueryParameterAndFragment ()
void	itSendsPushRouteInformationMessageWhenOnNewIntentWithFragmentNoQueryParameter ()
void	itSendsPushRouteInformationMessageWhenOnNewIntentNoQueryParameter ()
void	itForwardsOnNewIntentToFlutterEngine ()
void	itForwardsOnActivityResultToFlutterEngine ()
void	itForwardsOnUserLeaveHintToFlutterEngine ()
void	itNotifiesDartExecutorAndSendsMessageOverSystemChannelWhenToldToTrimMemory ()
void	itDestroysItsOwnEngineIfHostRequestsIt ()
void	itDoesNotDestroyItsOwnEngineWhenHostSaysNotTo ()
void	itDestroysCachedEngineWhenHostRequestsIt ()
void	itDoesNotDestroyCachedEngineWhenHostSaysNotTo ()
void	itDelaysFirstDrawWhenRequested ()
void	itDoesNotDelayFirstDrawWhenNotRequested ()
void	itThrowsWhenDelayingTheFirstDrawAndUsingATextureView ()
void	itChangesFlutterViewVisibilityWhenOnStartAndOnStop ()
void	flutterSurfaceViewVisibilityChangedWithFlutterView ()
void	usesFlutterEngineGroup ()
void	itDoesAttachFlutterViewToEngine ()
void	itDoesNotAttachFlutterViewToEngine ()
void	itDoesNotDetachTwice ()

Detailed Description

Definition at line 66 of file FlutterActivityAndFragmentDelegateTest.java.

Member Function Documentation

flutterEngineGroupGetsInitialRouteFromIntent()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.flutterEngineGroupGetsInitialRouteFromIntent ( )

inline

Definition at line 300 of file FlutterActivityAndFragmentDelegateTest.java.

                                                             {
    // ---- Test setup ----
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    Activity mockActivity = mock(Activity.class);
    Intent mockIntent = mock(Intent.class);
    when(mockFlutterLoader.findAppBundlePath()).thenReturn("default_flutter_assets/path");
    FlutterInjector.setInstance(
        new FlutterInjector.Builder().setFlutterLoader(mockFlutterLoader).build());
    FlutterEngineGroup flutterEngineGroup = mock(FlutterEngineGroup.class);
    FlutterEngineGroupCache.getInstance().put("my_flutter_engine_group", flutterEngineGroup);
 
    List<String> entryPointArgs = new ArrayList<>();
    entryPointArgs.add("entrypoint-arg");
 
    // Adjust fake host to request cached engine group.
    when(mockHost.getInitialRoute()).thenReturn(null);
    when(mockHost.getCachedEngineGroupId()).thenReturn("my_flutter_engine_group");
    when(mockHost.provideFlutterEngine(any(Context.class))).thenReturn(null);
    when(mockHost.shouldAttachEngineToActivity()).thenReturn(false);
    when(mockHost.getDartEntrypointArgs()).thenReturn(entryPointArgs);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    when(mockHost.getActivity()).thenReturn(mockActivity);
    when(mockActivity.getIntent()).thenReturn(mockIntent);
    when(mockIntent.getData()).thenReturn(Uri.parse("foo://example.com/initial_route"));
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is obtained in onAttach().
    delegate.onAttach(ctx);
 
    DartExecutor.DartEntrypoint entrypoint = new DartExecutor.DartEntrypoint("/fake/path", "main");
    ArgumentCaptor<FlutterEngineGroup.Options> optionsCaptor =
        ArgumentCaptor.forClass(FlutterEngineGroup.Options.class);
    verify(flutterEngineGroup, times(1)).createAndRunEngine(optionsCaptor.capture());
    assertEquals("foo://example.com/initial_route", optionsCaptor.getValue().getInitialRoute());
  }

flutterSurfaceViewVisibilityChangedWithFlutterView()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.flutterSurfaceViewVisibilityChangedWithFlutterView ( )

inline

Definition at line 1301 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                   {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    // --- Execute the behavior under test ---
    // For `FlutterSurfaceView`, setting visibility to the current `FlutterView` will not take
    // effect since it is not in the view tree. So we need to make sure that when the visibility of
    // `FlutterView` changes, the `FlutterSurfaceView` changes at the same time
    // See https://github.com/flutter/flutter/issues/105203
    assertEquals(FlutterSurfaceView.class, delegate.flutterView.renderSurface.getClass());
    FlutterSurfaceView surfaceView = (FlutterSurfaceView) delegate.flutterView.renderSurface;
    // Verify that the `FlutterSurfaceView` is gone.
    delegate.flutterView.setVisibility(View.GONE);
    assertEquals(View.GONE, surfaceView.getVisibility());
    // Verify that the `FlutterSurfaceView` is visible.
    delegate.flutterView.setVisibility(View.VISIBLE);
    assertEquals(View.VISIBLE, surfaceView.getVisibility());
    // Verify that the `FlutterSurfaceView` is invisible.
    delegate.flutterView.setVisibility(View.INVISIBLE);
    assertEquals(View.INVISIBLE, surfaceView.getVisibility());
  }

itAttachesFlutterToTheActivityIfDesired()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itAttachesFlutterToTheActivityIfDesired ( )

inline

Definition at line 600 of file FlutterActivityAndFragmentDelegateTest.java.

                                                        {
    // ---- Test setup ----
    // Declare that the host wants Flutter to attach to the surrounding Activity.
    when(mockHost.shouldAttachEngineToActivity()).thenReturn(true);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Flutter is attached to the surrounding Activity in onAttach.
    delegate.onAttach(ctx);
 
    // Verify that the ActivityControlSurface was told to attach to an Activity.
    verify(mockFlutterEngine.getActivityControlSurface(), times(1))
        .attachToActivity(any(ExclusiveAppComponent.class), any(Lifecycle.class));
 
    // Flutter is detached from the surrounding Activity in onDetach.
    delegate.onDetach();
 
    // Verify that the ActivityControlSurface was told to detach from the Activity.
    verify(mockFlutterEngine.getActivityControlSurface(), times(1)).detachFromActivity();
  }

itChangesFlutterViewVisibilityWhenOnStartAndOnStop()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itChangesFlutterViewVisibilityWhenOnStartAndOnStop ( )

inline

Definition at line 1265 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                   {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    // Verify that the flutterView is visible.
    assertEquals(View.VISIBLE, delegate.flutterView.getVisibility());
    delegate.onStop();
    // Verify that the flutterView is gone.
    assertEquals(View.GONE, delegate.flutterView.getVisibility());
    delegate.onStart();
    // Verify that the flutterView is visible.
    assertEquals(View.VISIBLE, delegate.flutterView.getVisibility());
 
    delegate.flutterView.setVisibility(View.INVISIBLE);
    delegate.onStop();
    // Verify that the flutterView is gone.
    assertEquals(View.GONE, delegate.flutterView.getVisibility());
    delegate.onStart();
    // Verify that the flutterView is invisible.
    assertEquals(View.INVISIBLE, delegate.flutterView.getVisibility());
 
    delegate.flutterView.setVisibility(View.GONE);
    delegate.onStop();
    // Verify that the flutterView is gone.
    assertEquals(View.GONE, delegate.flutterView.getVisibility());
    delegate.onStart();
    // Verify that the flutterView is gone.
    assertEquals(View.GONE, delegate.flutterView.getVisibility());
  }

itDefersToTheHostToProvideFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDefersToTheHostToProvideFlutterEngine ( )

inline

Definition at line 229 of file FlutterActivityAndFragmentDelegateTest.java.

                                                        {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is created in onAttach().
    delegate.onAttach(ctx);
 
    // Verify that the host was asked to provide a FlutterEngine.
    verify(mockHost, times(1)).provideFlutterEngine(any(Context.class));
 
    // Verify that the delegate's FlutterEngine is our mock FlutterEngine.
    assertEquals(
        "The delegate failed to use the host's FlutterEngine.",
        mockFlutterEngine,
        delegate.getFlutterEngine());
  }

itDelaysFirstDrawWhenRequested()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDelaysFirstDrawWhenRequested ( )

inline

Definition at line 1214 of file FlutterActivityAndFragmentDelegateTest.java.

                                               {
    // ---- Test setup ----
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // We're testing lifecycle behaviors, which require/expect that certain methods have already
    // been executed by the time they run. Therefore, we run those expected methods first.
    delegate.onAttach(ctx);
 
    // --- Execute the behavior under test ---
    boolean shouldDelayFirstAndroidViewDraw = true;
    delegate.onCreateView(null, null, null, 0, shouldDelayFirstAndroidViewDraw);
 
    assertNotNull(delegate.activePreDrawListener);
  }

itDestroysCachedEngineWhenHostRequestsIt()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDestroysCachedEngineWhenHostRequestsIt ( )

inline

Definition at line 1151 of file FlutterActivityAndFragmentDelegateTest.java.

                                                         {
    // ---- Test setup ----
    // Place a FlutterEngine in the static cache.
    FlutterEngine cachedEngine = mockFlutterEngine();
    FlutterEngineCache.getInstance().put("my_flutter_engine", cachedEngine);
 
    // Adjust fake host to request cached engine.
    when(mockHost.getCachedEngineId()).thenReturn("my_flutter_engine");
 
    // Adjust fake host to request engine destruction.
    when(mockHost.shouldDestroyEngineWithHost()).thenReturn(true);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Push the delegate through all lifecycle methods all the way to destruction.
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
    delegate.onPause();
    delegate.onStop();
    delegate.onDestroyView();
    delegate.onDetach();
 
    // --- Verify that the cached engine was destroyed ---
    verify(cachedEngine, times(1)).destroy();
    assertNull(FlutterEngineCache.getInstance().get("my_flutter_engine"));
  }

itDestroysItsOwnEngineIfHostRequestsIt()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDestroysItsOwnEngineIfHostRequestsIt ( )

inline

Definition at line 1103 of file FlutterActivityAndFragmentDelegateTest.java.

                                                       {
    // ---- Test setup ----
    // Adjust fake host to request engine destruction.
    when(mockHost.shouldDestroyEngineWithHost()).thenReturn(true);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Push the delegate through all lifecycle methods all the way to destruction.
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
    delegate.onPause();
    delegate.onStop();
    delegate.onDestroyView();
    delegate.onDetach();
 
    // --- Verify that the cached engine was destroyed ---
    verify(mockFlutterEngine, times(1)).destroy();
  }

itDoesAttachFlutterViewToEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesAttachFlutterViewToEngine ( )

inline

Definition at line 1342 of file FlutterActivityAndFragmentDelegateTest.java.

                                                {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
 
    // --- Execute the behavior under test ---
    assertTrue(delegate.flutterView.isAttachedToFlutterEngine());
  }

itDoesNotAttachFlutterToTheActivityIfNotDesired()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotAttachFlutterToTheActivityIfNotDesired ( )

inline

Definition at line 627 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                {
    // ---- Test setup ----
    // Declare that the host does NOT want Flutter to attach to the surrounding Activity.
    when(mockHost.shouldAttachEngineToActivity()).thenReturn(false);
 
    // getActivity() returns null if the activity is not attached
    when(mockHost.getActivity()).thenReturn(null);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Flutter is attached to the surrounding Activity in onAttach.
    delegate.onAttach(ctx);
 
    // Make sure all of the other lifecycle methods can run safely as well
    // without a valid Activity
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
    delegate.onPause();
    delegate.onStop();
    delegate.onDestroyView();
 
    // Flutter is detached from the surrounding Activity in onDetach.
    delegate.onDetach();
 
    // Verify that the ActivityControlSurface was NOT told to attach or detach to an Activity.
    verify(mockFlutterEngine.getActivityControlSurface(), never())
        .attachToActivity(any(ExclusiveAppComponent.class), any(Lifecycle.class));
    verify(mockFlutterEngine.getActivityControlSurface(), never()).detachFromActivity();
  }

itDoesNotAttachFlutterViewToEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotAttachFlutterViewToEngine ( )

inline

Definition at line 1354 of file FlutterActivityAndFragmentDelegateTest.java.

                                                   {
    // ---- Test setup ----
    // Create the real object that we're testing.
    when(mockHost.attachToEngineAutomatically()).thenReturn(false);
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
 
    // --- Execute the behavior under test ---
    assertFalse(delegate.flutterView.isAttachedToFlutterEngine());
  }

itDoesNotDelayFirstDrawWhenNotRequested()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotDelayFirstDrawWhenNotRequested ( )

inline

Definition at line 1230 of file FlutterActivityAndFragmentDelegateTest.java.

                                                        {
    // ---- Test setup ----
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // We're testing lifecycle behaviors, which require/expect that certain methods have already
    // been executed by the time they run. Therefore, we run those expected methods first.
    delegate.onAttach(ctx);
 
    // --- Execute the behavior under test ---
    boolean shouldDelayFirstAndroidViewDraw = false;
    delegate.onCreateView(null, null, null, 0, shouldDelayFirstAndroidViewDraw);
 
    assertNull(delegate.activePreDrawListener);
  }

itDoesNotDestroyCachedEngineWhenHostSaysNotTo()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotDestroyCachedEngineWhenHostSaysNotTo ( )

inline

Definition at line 1183 of file FlutterActivityAndFragmentDelegateTest.java.

                                                              {
    // ---- Test setup ----
    // Place a FlutterEngine in the static cache.
    FlutterEngine cachedEngine = mockFlutterEngine();
    FlutterEngineCache.getInstance().put("my_flutter_engine", cachedEngine);
 
    // Adjust fake host to request cached engine.
    when(mockHost.getCachedEngineId()).thenReturn("my_flutter_engine");
 
    // Adjust fake host to request engine retention.
    when(mockHost.shouldDestroyEngineWithHost()).thenReturn(false);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Push the delegate through all lifecycle methods all the way to destruction.
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
    delegate.onPause();
    delegate.onStop();
    delegate.onDestroyView();
    delegate.onDetach();
 
    // --- Verify that the cached engine was NOT destroyed ---
    verify(cachedEngine, never()).destroy();
  }

itDoesNotDestroyItsOwnEngineWhenHostSaysNotTo()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotDestroyItsOwnEngineWhenHostSaysNotTo ( )

inline

Definition at line 1127 of file FlutterActivityAndFragmentDelegateTest.java.

                                                              {
    // ---- Test setup ----
    // Adjust fake host to request engine destruction.
    when(mockHost.shouldDestroyEngineWithHost()).thenReturn(false);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Push the delegate through all lifecycle methods all the way to destruction.
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
    delegate.onPause();
    delegate.onStop();
    delegate.onDestroyView();
    delegate.onDetach();
 
    // --- Verify that the cached engine was destroyed ---
    verify(mockFlutterEngine, never()).destroy();
  }

itDoesNotDetachTwice()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotDetachTwice ( )

inline

Definition at line 1367 of file FlutterActivityAndFragmentDelegateTest.java.

                                     {
    FlutterEngine cachedEngine = mockFlutterEngine();
    FlutterEngineCache.getInstance().put("my_flutter_engine", cachedEngine);
 
    // Engine is a cached singleton that isn't owned by either hosts.
    when(mockHost.shouldDestroyEngineWithHost()).thenReturn(false);
    when(mockHost2.shouldDestroyEngineWithHost()).thenReturn(false);
 
    // Adjust fake hosts to request cached engine.
    when(mockHost.getCachedEngineId()).thenReturn("my_flutter_engine");
    when(mockHost2.getCachedEngineId()).thenReturn("my_flutter_engine");
 
    // Create the real objects that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
    FlutterActivityAndFragmentDelegate delegate2 =
        new FlutterActivityAndFragmentDelegate(mockHost2);
 
    // This test is written to recreate the following scenario:
    // 1. We have a FlutterFragment_A attached to a singleton cached engine.
    // 2. An intent arrives that spawns FlutterFragment_B.
    // 3. FlutterFragment_B starts and steals the engine from FlutterFragment_A while attaching.
    //    Via a call to FlutterActivityAndFragmentDelegate.detachFromFlutterEngine().
    // 4. FlutterFragment_A is forcibly detached from the engine.
    // 5. FlutterFragment_B is attached to the engine.
    // 6. FlutterFragment_A is detached from the engine.
    // Note that the second detach for FlutterFragment_A is done unconditionally when the Fragment
    // is being
    // torn down.
 
    // At this point the engine's life cycle channel receives a message (triggered by
    // FlutterFragment_A's second detach)
    // that indicates the app is detached. This breaks FlutterFragment_B.
 
    // Below is a sequence of calls that mimicks the calls that the above scenario would trigger
    // without
    // relying on an intent to trigger the behaviour.
 
    // FlutterFragment_A is attached to the engine.
    delegate.onAttach(ctx);
 
    // NOTE: The following two calls happen in a slightly different order in reality. That is, via,
    // a call to host.detachFromFlutterEngine, delegate2.onAttach ends up invoking
    // delegate.onDetach.
    // To keep this regression test simple, we call them directly.
 
    // Detach FlutterFragment_A.
    delegate.onDetach();
 
    verify(cachedEngine.getLifecycleChannel(), times(1)).appIsDetached();
 
    // Attaches to the engine FlutterFragment_B.
    delegate2.onAttach(ctx);
    delegate2.onResume();
 
    verify(cachedEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(cachedEngine.getLifecycleChannel(), times(1)).appIsDetached();
 
    // A second Detach of FlutterFragment_A happens when the Fragment is detached.
    delegate.onDetach();
 
    // IMPORTANT: The bug we fixed would have resulted in the engine thinking the app
    // is detached twice instead of once.
    verify(cachedEngine.getLifecycleChannel(), times(1)).appIsDetached();
  }

itDoesNotSendsLifecycleEventsToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesNotSendsLifecycleEventsToFlutter ( )

inline

Definition at line 201 of file FlutterActivityAndFragmentDelegateTest.java.

                                                       {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    when(mockHost.shouldDispatchAppLifecycleState()).thenReturn(false);
 
    // We're testing lifecycle behaviors, which require/expect that certain methods have already
    // been executed by the time they run. Therefore, we run those expected methods first.
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
    delegate.onWindowFocusChanged(false);
    delegate.onWindowFocusChanged(true);
    delegate.onPause();
    delegate.onStop();
    delegate.onDetach();
 
    verify(mockFlutterEngine.getLifecycleChannel(), never()).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
  }

itDoesSendPushRouteInformationMessageWhenOnNewIntentIsNonHierarchicalUri()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itDoesSendPushRouteInformationMessageWhenOnNewIntentIsNonHierarchicalUri ( )

inline

Definition at line 919 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                         {
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    Intent mockIntent = mock(Intent.class);
 
    // mailto: URIs are non-hierarchical
    when(mockIntent.getData()).thenReturn(Uri.parse("mailto:test@test.com"));
 
    // Emulate the host and call the method
    delegate.onNewIntent(mockIntent);
 
    // Verify that the navigation channel was not given a push route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1))
        .pushRouteInformation("mailto:test@test.com");
  }

itExecutesDartEntrypointProvidedByHost()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itExecutesDartEntrypointProvidedByHost ( )

inline

Definition at line 496 of file FlutterActivityAndFragmentDelegateTest.java.

                                                       {
    // ---- Test setup ----
    // Set Dart entrypoint parameters on fake host.
    when(mockHost.getAppBundlePath()).thenReturn("/my/bundle/path");
    when(mockHost.getDartEntrypointFunctionName()).thenReturn("myEntrypoint");
 
    // Create the DartEntrypoint that we expect to be executed.
    DartExecutor.DartEntrypoint dartEntrypoint =
        new DartExecutor.DartEntrypoint("/my/bundle/path", "myEntrypoint");
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Dart is executed in onStart().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
 
    // Verify that the host's Dart entrypoint was used.
    verify(mockFlutterEngine.getDartExecutor(), times(1))
        .executeDartEntrypoint(eq(dartEntrypoint), isNull());
  }

itExecutesDartEntrypointWithArgsProvidedByHost()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itExecutesDartEntrypointWithArgsProvidedByHost ( )

inline

Definition at line 521 of file FlutterActivityAndFragmentDelegateTest.java.

                                                               {
    // ---- Test setup ----
    // Set Dart entrypoint parameters on fake host.
    when(mockHost.getAppBundlePath()).thenReturn("/my/bundle/path");
    when(mockHost.getDartEntrypointFunctionName()).thenReturn("myEntrypoint");
    List<String> dartEntrypointArgs = new ArrayList<String>(Arrays.asList("foo", "bar"));
    when(mockHost.getDartEntrypointArgs()).thenReturn(dartEntrypointArgs);
 
    // Create the DartEntrypoint that we expect to be executed
    DartExecutor.DartEntrypoint dartEntrypoint =
        new DartExecutor.DartEntrypoint("/my/bundle/path", "myEntrypoint");
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Dart is executed in onStart().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
 
    // Verify that the host's Dart entrypoint was used.
    verify(mockFlutterEngine.getDartExecutor(), times(1))
        .executeDartEntrypoint(any(DartExecutor.DartEntrypoint.class), eq(dartEntrypointArgs));
  }

itExecutesDartLibraryUriProvidedByHost()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itExecutesDartLibraryUriProvidedByHost ( )

inline

Definition at line 548 of file FlutterActivityAndFragmentDelegateTest.java.

                                                       {
    when(mockHost.getAppBundlePath()).thenReturn("/my/bundle/path");
    when(mockHost.getDartEntrypointFunctionName()).thenReturn("myEntrypoint");
    when(mockHost.getDartEntrypointLibraryUri()).thenReturn("package:foo/bar.dart");
 
    DartExecutor.DartEntrypoint expectedEntrypoint =
        new DartExecutor.DartEntrypoint("/my/bundle/path", "package:foo/bar.dart", "myEntrypoint");
 
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
 
    verify(mockFlutterEngine.getDartExecutor(), times(1))
        .executeDartEntrypoint(eq(expectedEntrypoint), isNull());
  }

itForwardsCancelBackGestureToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsCancelBackGestureToFlutter ( )

inline

Definition at line 728 of file FlutterActivityAndFragmentDelegateTest.java.

                                                     {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and inform our delegate of the back gesture cancellation
    delegate.cancelBackGesture();
 
    // Verify that the back gesture tried to send a message to Flutter.
    verify(mockFlutterEngine.getBackGestureChannel(), times(1)).cancelBackGesture();
  }

itForwardsCommitBackGestureToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsCommitBackGestureToFlutter ( )

inline

Definition at line 712 of file FlutterActivityAndFragmentDelegateTest.java.

                                                     {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and inform our delegate when the back gesture is committed
    delegate.commitBackGesture();
 
    // Verify that the back gesture tried to send a message to Flutter.
    verify(mockFlutterEngine.getBackGestureChannel(), times(1)).commitBackGesture();
  }

itForwardsOnActivityResultToFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsOnActivityResultToFlutterEngine ( )

inline

Definition at line 1018 of file FlutterActivityAndFragmentDelegateTest.java.

                                                          {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onActivityResult(0, 0, null);
 
    // Verify that the call was forwarded to the engine.
    verify(mockFlutterEngine.getActivityControlSurface(), times(1))
        .onActivityResult(any(Integer.class), any(Integer.class), /*intent=*/ isNull());
  }

itForwardsOnNewIntentToFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsOnNewIntentToFlutterEngine ( )

inline

Definition at line 1002 of file FlutterActivityAndFragmentDelegateTest.java.

                                                     {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onNewIntent(mock(Intent.class));
 
    // Verify that the call was forwarded to the engine.
    verify(mockFlutterEngine.getActivityControlSurface(), times(1)).onNewIntent(any(Intent.class));
  }

itForwardsOnRequestPermissionsResultToFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsOnRequestPermissionsResultToFlutterEngine ( )

inline

Definition at line 744 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                    {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onRequestPermissionsResult(0, new String[] {}, new int[] {});
 
    // Verify that the call was forwarded to the engine.
    verify(mockFlutterEngine.getActivityControlSurface(), times(1))
        .onRequestPermissionsResult(any(Integer.class), any(String[].class), any(int[].class));
  }

itForwardsOnUserLeaveHintToFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsOnUserLeaveHintToFlutterEngine ( )

inline

Definition at line 1035 of file FlutterActivityAndFragmentDelegateTest.java.

                                                         {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onUserLeaveHint();
 
    // Verify that the call was forwarded to the engine.
    verify(mockFlutterEngine.getActivityControlSurface(), times(1)).onUserLeaveHint();
  }

itForwardsStartBackGestureToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsStartBackGestureToFlutter ( )

inline

Definition at line 677 of file FlutterActivityAndFragmentDelegateTest.java.

                                                    {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and inform our delegate of the start back gesture with a mocked BackEvent
    BackEvent backEvent = mock(BackEvent.class);
    delegate.startBackGesture(backEvent);
 
    // Verify that the back gesture tried to send a message to Flutter.
    verify(mockFlutterEngine.getBackGestureChannel(), times(1)).startBackGesture(backEvent);
  }

itForwardsUpdateBackGestureProgressToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itForwardsUpdateBackGestureProgressToFlutter ( )

inline

Definition at line 694 of file FlutterActivityAndFragmentDelegateTest.java.

                                                             {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and inform our delegate of the back gesture progress with a mocked BackEvent
    BackEvent backEvent = mock(BackEvent.class);
    delegate.updateBackGestureProgress(backEvent);
 
    // Verify that the back gesture tried to send a message to Flutter.
    verify(mockFlutterEngine.getBackGestureChannel(), times(1))
        .updateBackGestureProgress(backEvent);
  }

itGivesHostAnOpportunityToCleanUpFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itGivesHostAnOpportunityToCleanUpFlutterEngine ( )

inline

Definition at line 462 of file FlutterActivityAndFragmentDelegateTest.java.

                                                               {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is created in onAttach().
    delegate.onAttach(ctx);
    delegate.onDetach();
 
    // Verify that the host was asked to configure our FlutterEngine.
    verify(mockHost, times(1)).cleanUpFlutterEngine(mockFlutterEngine);
  }

itGivesHostAnOpportunityToConfigureFlutterEngine()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itGivesHostAnOpportunityToConfigureFlutterEngine ( )

inline

Definition at line 402 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                 {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is created in onAttach().
    delegate.onAttach(ctx);
 
    // Verify that the host was asked to configure our FlutterEngine.
    verify(mockHost, times(1)).configureFlutterEngine(mockFlutterEngine);
  }

itGivesHostAnOpportunityToConfigureFlutterSurfaceView()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itGivesHostAnOpportunityToConfigureFlutterSurfaceView ( )

inline

Definition at line 416 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                      {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
 
    // Verify that the host was asked to configure a FlutterSurfaceView.
    verify(mockHost, times(1)).onFlutterSurfaceViewCreated(isNotNull());
  }

itGivesHostAnOpportunityToConfigureFlutterTextureView()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itGivesHostAnOpportunityToConfigureFlutterTextureView ( )

inline

Definition at line 433 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                      {
    // ---- Test setup ----
    Host customMockHost = mock(Host.class);
    when(customMockHost.getContext()).thenReturn(ctx);
    when(customMockHost.getActivity()).thenReturn(Robolectric.setupActivity(Activity.class));
    when(customMockHost.getLifecycle()).thenReturn(mock(Lifecycle.class));
    when(customMockHost.getFlutterShellArgs()).thenReturn(new FlutterShellArgs(new String[] {}));
    when(customMockHost.getDartEntrypointFunctionName()).thenReturn("main");
    when(customMockHost.getAppBundlePath()).thenReturn("/fake/path");
    when(customMockHost.getInitialRoute()).thenReturn("/");
    when(customMockHost.getRenderMode()).thenReturn(RenderMode.texture);
    when(customMockHost.getTransparencyMode()).thenReturn(TransparencyMode.transparent);
    when(customMockHost.provideFlutterEngine(any(Context.class))).thenReturn(mockFlutterEngine);
    when(customMockHost.shouldAttachEngineToActivity()).thenReturn(true);
    when(customMockHost.shouldDestroyEngineWithHost()).thenReturn(true);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate =
        new FlutterActivityAndFragmentDelegate(customMockHost);
 
    // --- Execute the behavior under test ---
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, false);
 
    // Verify that the host was asked to configure a FlutterTextureView.
    verify(customMockHost, times(1)).onFlutterTextureViewCreated(isNotNull());
  }

itNotifiesDartExecutorAndSendsMessageOverSystemChannelWhenToldToTrimMemory()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itNotifiesDartExecutorAndSendsMessageOverSystemChannelWhenToldToTrimMemory ( )

inline

Definition at line 1051 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                           {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Test assumes no frames have been displayed.
    verify(mockHost, times(0)).onFlutterUiDisplayed();
 
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onTrimMemory(TRIM_MEMORY_RUNNING_MODERATE);
    delegate.onTrimMemory(TRIM_MEMORY_RUNNING_LOW);
    verify(mockFlutterEngine.getDartExecutor(), times(0)).notifyLowMemoryWarning();
    verify(mockFlutterEngine.getSystemChannel(), times(0)).sendMemoryPressureWarning();
 
    delegate.onTrimMemory(TRIM_MEMORY_RUNNING_CRITICAL);
    delegate.onTrimMemory(TRIM_MEMORY_BACKGROUND);
    delegate.onTrimMemory(TRIM_MEMORY_COMPLETE);
    delegate.onTrimMemory(TRIM_MEMORY_MODERATE);
    delegate.onTrimMemory(TRIM_MEMORY_UI_HIDDEN);
    verify(mockFlutterEngine.getDartExecutor(), times(0)).notifyLowMemoryWarning();
    verify(mockFlutterEngine.getSystemChannel(), times(0)).sendMemoryPressureWarning();
 
    verify(mockHost, times(0)).onFlutterUiDisplayed();
 
    delegate.onCreateView(null, null, null, 0, false);
    final FlutterRenderer renderer = mockFlutterEngine.getRenderer();
    ArgumentCaptor<FlutterUiDisplayListener> listenerCaptor =
        ArgumentCaptor.forClass(FlutterUiDisplayListener.class);
    // 2 times: once for engine attachment, once for view creation.
    verify(renderer, times(2)).addIsDisplayingFlutterUiListener(listenerCaptor.capture());
    listenerCaptor.getValue().onFlutterUiDisplayed();
 
    verify(mockHost, times(1)).onFlutterUiDisplayed();
 
    delegate.onTrimMemory(TRIM_MEMORY_RUNNING_MODERATE);
    verify(mockFlutterEngine.getDartExecutor(), times(0)).notifyLowMemoryWarning();
    verify(mockFlutterEngine.getSystemChannel(), times(0)).sendMemoryPressureWarning();
 
    delegate.onTrimMemory(TRIM_MEMORY_RUNNING_LOW);
    delegate.onTrimMemory(TRIM_MEMORY_RUNNING_CRITICAL);
    delegate.onTrimMemory(TRIM_MEMORY_BACKGROUND);
    delegate.onTrimMemory(TRIM_MEMORY_COMPLETE);
    delegate.onTrimMemory(TRIM_MEMORY_MODERATE);
    delegate.onTrimMemory(TRIM_MEMORY_UI_HIDDEN);
    verify(mockFlutterEngine.getDartExecutor(), times(6)).notifyLowMemoryWarning();
    verify(mockFlutterEngine.getSystemChannel(), times(6)).sendMemoryPressureWarning();
  }

itSendsdefaultInitialRouteOnStartIfNotDeepLinkingFromIntent()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsdefaultInitialRouteOnStartIfNotDeepLinkingFromIntent ( )

inline

Definition at line 873 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                            {
    // Creates an empty intent without launch uri.
    Intent intent = FlutterActivity.createDefaultIntent(ctx);
 
    ActivityController<FlutterActivity> activityController =
        Robolectric.buildActivity(FlutterActivity.class, intent);
    FlutterActivity flutterActivity = activityController.get();
 
    when(mockHost.getActivity()).thenReturn(flutterActivity);
    when(mockHost.getInitialRoute()).thenReturn(null);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    // Emulate app start.
    delegate.onStart();
 
    // Verify that the navigation channel was given the default initial route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).setInitialRoute("/");
  }

itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinking()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinking ( )

inline

Definition at line 762 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                                   {
    Intent intent = FlutterActivity.createDefaultIntent(ctx);
    intent.setData(Uri.parse("http://myApp/custom/route?query=test"));
 
    ActivityController<FlutterActivity> activityController =
        Robolectric.buildActivity(FlutterActivity.class, intent);
    FlutterActivity flutterActivity = activityController.get();
 
    when(mockHost.getActivity()).thenReturn(flutterActivity);
    when(mockHost.getInitialRoute()).thenReturn(null);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    // Emulate app start.
    delegate.onStart();
 
    // Verify that the navigation channel was given the initial route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1))
        .setInitialRoute("http://myApp/custom/route?query=test");
  }

itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingNoQueryParameter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingNoQueryParameter ( )

inline

Definition at line 846 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                                                   {
    Intent intent = FlutterActivity.createDefaultIntent(ctx);
    intent.setData(Uri.parse("http://myApp/custom/route"));
 
    ActivityController<FlutterActivity> activityController =
        Robolectric.buildActivity(FlutterActivity.class, intent);
    FlutterActivity flutterActivity = activityController.get();
 
    when(mockHost.getActivity()).thenReturn(flutterActivity);
    when(mockHost.getInitialRoute()).thenReturn(null);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    // Emulate app start.
    delegate.onStart();
 
    // Verify that the navigation channel was given the initial route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1))
        .setInitialRoute("http://myApp/custom/route");
  }

itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingWithFragmentNoQueryParameter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingWithFragmentNoQueryParameter ( )

inline

Definition at line 818 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                                                               {
    Intent intent = FlutterActivity.createDefaultIntent(ctx);
    intent.setData(Uri.parse("http://myApp/custom/route#fragment"));
 
    ActivityController<FlutterActivity> activityController =
        Robolectric.buildActivity(FlutterActivity.class, intent);
    FlutterActivity flutterActivity = activityController.get();
 
    when(mockHost.getActivity()).thenReturn(flutterActivity);
    when(mockHost.getInitialRoute()).thenReturn(null);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    // Emulate app start.
    delegate.onStart();
 
    // Verify that the navigation channel was given the initial route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1))
        .setInitialRoute("http://myApp/custom/route#fragment");
  }

itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingWithQueryParameterAndFragment()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsInitialRouteFromIntentOnStartIfNoInitialRouteFromActivityAndShouldHandleDeeplinkingWithQueryParameterAndFragment ( )

inline

Definition at line 790 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                                                                {
    Intent intent = FlutterActivity.createDefaultIntent(ctx);
    intent.setData(Uri.parse("http://myApp/custom/route?query=test#fragment"));
 
    ActivityController<FlutterActivity> activityController =
        Robolectric.buildActivity(FlutterActivity.class, intent);
    FlutterActivity flutterActivity = activityController.get();
 
    when(mockHost.getActivity()).thenReturn(flutterActivity);
    when(mockHost.getInitialRoute()).thenReturn(null);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    // Emulate app start.
    delegate.onStart();
 
    // Verify that the navigation channel was given the initial route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1))
        .setInitialRoute("http://myApp/custom/route?query=test#fragment");
  }

itSendsInitialRouteToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsInitialRouteToFlutter ( )

inline

Definition at line 477 of file FlutterActivityAndFragmentDelegateTest.java.

                                             {
    // ---- Test setup ----
    // Set initial route on our fake Host.
    when(mockHost.getInitialRoute()).thenReturn("/my/route");
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The initial route is sent in onStart().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
 
    // Verify that the navigation channel was given our initial route.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).setInitialRoute("/my/route");
  }

itSendsLifecycleEventsToFlutter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsLifecycleEventsToFlutter ( )

inline

Definition at line 121 of file FlutterActivityAndFragmentDelegateTest.java.

                                                {
    // ---- Test setup ----
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // We're testing lifecycle behaviors, which require/expect that certain methods have already
    // been executed by the time they run. Therefore, we run those expected methods first.
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
 
    // --- Execute the behavior under test ---
    // By the time an Activity/Fragment is started, we don't expect any lifecycle messages
    // to have been sent to Flutter.
    delegate.onStart();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
 
    // When the Activity/Fragment is resumed, a resumed message should have been sent to Flutter.
    delegate.onResume();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
 
    // When the app loses focus because something else has it (e.g. notification
    // windowshade or app switcher), it should go to inactive.
    delegate.onWindowFocusChanged(false);
    verify(mockFlutterEngine.getLifecycleChannel(), never()).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
 
    // When the app regains focus, it should go to resumed again.
    delegate.onWindowFocusChanged(true);
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
 
    // When the Activity/Fragment is paused, an inactive message should have been sent to Flutter.
    delegate.onPause();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
 
    // When the Activity/Fragment is stopped, a paused message should have been sent to Flutter.
    // Notice that Flutter uses the term "paused" in a different way, and at a different time
    // than the Android OS.
    delegate.onStop();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), never()).appIsDetached();
 
    // When activity detaches, a detached message should have been sent to Flutter.
    delegate.onDetach();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).aWindowIsFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).noWindowsAreFocused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsResumed();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsInactive();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsPaused();
    verify(mockFlutterEngine.getLifecycleChannel(), times(1)).appIsDetached();
  }

itSendsPopRouteMessageToFlutterWhenHardwareBackButtonIsPressed()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsPopRouteMessageToFlutterWhenHardwareBackButtonIsPressed ( )

inline

Definition at line 661 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                               {
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
 
    // Emulate the host and inform our delegate that the back button was pressed.
    delegate.onBackPressed();
 
    // Verify that the navigation channel tried to send a message to Flutter.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).popRoute();
  }

itSendsPushRouteInformationMessageWhenOnNewIntent()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsPushRouteInformationMessageWhenOnNewIntent ( )

inline

Definition at line 899 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                  {
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    String expected = "http://myApp/custom/route?query=test";
 
    Intent mockIntent = mock(Intent.class);
    when(mockIntent.getData()).thenReturn(Uri.parse(expected));
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onNewIntent(mockIntent);
 
    // Verify that the navigation channel was given the push route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).pushRouteInformation(expected);
  }

itSendsPushRouteInformationMessageWhenOnNewIntentNoQueryParameter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsPushRouteInformationMessageWhenOnNewIntentNoQueryParameter ( )

inline

Definition at line 982 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                  {
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    String expected = "http://myApp/custom/route#fragment";
 
    Intent mockIntent = mock(Intent.class);
    when(mockIntent.getData()).thenReturn(Uri.parse(expected));
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onNewIntent(mockIntent);
 
    // Verify that the navigation channel was given the push route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).pushRouteInformation(expected);
  }

itSendsPushRouteInformationMessageWhenOnNewIntentWithFragmentNoQueryParameter()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsPushRouteInformationMessageWhenOnNewIntentWithFragmentNoQueryParameter ( )

inline

Definition at line 962 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                              {
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    String expected = "http://myApp/custom/route#fragment";
 
    Intent mockIntent = mock(Intent.class);
    when(mockIntent.getData()).thenReturn(Uri.parse(expected));
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onNewIntent(mockIntent);
 
    // Verify that the navigation channel was given the push route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).pushRouteInformation(expected);
  }

itSendsPushRouteInformationMessageWhenOnNewIntentWithQueryParameterAndFragment()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itSendsPushRouteInformationMessageWhenOnNewIntentWithQueryParameterAndFragment ( )

inline

Definition at line 942 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                                               {
    when(mockHost.shouldHandleDeeplinking()).thenReturn(true);
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is set up in onAttach().
    delegate.onAttach(ctx);
    String expected = "http://myApp/custom/route?query=test#fragment";
 
    Intent mockIntent = mock(Intent.class);
    when(mockIntent.getData()).thenReturn(Uri.parse(expected));
    // Emulate the host and call the method that we expect to be forwarded.
    delegate.onNewIntent(mockIntent);
 
    // Verify that the navigation channel was given the push route message.
    verify(mockFlutterEngine.getNavigationChannel(), times(1)).pushRouteInformation(expected);
  }

itThrowsExceptionIfCachedEngineDoesNotExist()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itThrowsExceptionIfCachedEngineDoesNotExist ( )

inline

Definition at line 283 of file FlutterActivityAndFragmentDelegateTest.java.

                                                            {
    // ---- Test setup ----
    // Adjust fake host to request cached engine that does not exist.
    when(mockHost.getCachedEngineId()).thenReturn("my_flutter_engine");
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine existence is verified in onAttach()
    delegate.onAttach(ctx);
 
    // Expect IllegalStateException.
  }

itThrowsExceptionIfNewEngineInGroupNotExist()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itThrowsExceptionIfNewEngineInGroupNotExist ( )

inline

Definition at line 381 of file FlutterActivityAndFragmentDelegateTest.java.

                                                            {
    // ---- Test setup ----
    FlutterEngineGroupCache.getInstance().clear();
 
    // Adjust fake host to request cached engine group that does not exist.
    when(mockHost.getCachedEngineGroupId()).thenReturn("my_flutter_engine_group");
    when(mockHost.getCachedEngineId()).thenReturn(null);
    when(mockHost.provideFlutterEngine(any(Context.class))).thenReturn(null);
    when(mockHost.shouldAttachEngineToActivity()).thenReturn(false);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine existence is verified in onAttach()
    delegate.onAttach(ctx);
 
    // Expect IllegalStateException.
  }

itThrowsWhenDelayingTheFirstDrawAndUsingATextureView()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itThrowsWhenDelayingTheFirstDrawAndUsingATextureView ( )

inline

Definition at line 1246 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                     {
    // ---- Test setup ----
    when(mockHost.getRenderMode()).thenReturn(RenderMode.texture);
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // We're testing lifecycle behaviors, which require/expect that certain methods have already
    // been executed by the time they run. Therefore, we run those expected methods first.
    delegate.onAttach(ctx);
 
    // --- Execute the behavior under test ---
    boolean shouldDelayFirstAndroidViewDraw = true;
    assertThrows(
        IllegalArgumentException.class,
        () -> {
          delegate.onCreateView(null, null, null, 0, shouldDelayFirstAndroidViewDraw);
        });
  }

itUsesCachedEngineWhenProvided()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itUsesCachedEngineWhenProvided ( )

inline

Definition at line 249 of file FlutterActivityAndFragmentDelegateTest.java.

                                               {
    // ---- Test setup ----
    // Place a FlutterEngine in the static cache.
    FlutterEngine cachedEngine = mockFlutterEngine();
    FlutterEngineCache.getInstance().put("my_flutter_engine", cachedEngine);
 
    // Adjust fake host to request cached engine.
    when(mockHost.getCachedEngineId()).thenReturn("my_flutter_engine");
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is obtained in onAttach().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
    delegate.onResume();
 
    // --- Verify that the cached engine was used ---
    // Verify that the non-cached engine was not used.
    verify(mockFlutterEngine.getDartExecutor(), never())
        .executeDartEntrypoint(any(DartExecutor.DartEntrypoint.class));
 
    // We should never instruct a cached engine to execute Dart code - it should already be
    // executing it.
    verify(cachedEngine.getDartExecutor(), never())
        .executeDartEntrypoint(any(DartExecutor.DartEntrypoint.class));
 
    // If the cached engine is being used, it should have sent a resumed lifecycle event.
    verify(cachedEngine.getLifecycleChannel(), times(1)).appIsResumed();
  }

itUsesDefaultFlutterLoaderAppBundlePathWhenUnspecified()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itUsesDefaultFlutterLoaderAppBundlePathWhenUnspecified ( )

inline

Definition at line 567 of file FlutterActivityAndFragmentDelegateTest.java.

                                                                       {
    // ---- Test setup ----
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.findAppBundlePath()).thenReturn("default_flutter_assets/path");
    FlutterInjector.setInstance(
        new FlutterInjector.Builder().setFlutterLoader(mockFlutterLoader).build());
 
    // Set Dart entrypoint parameters on fake host.
    when(mockHost.getAppBundlePath()).thenReturn(null);
    when(mockHost.getDartEntrypointFunctionName()).thenReturn("myEntrypoint");
 
    // Create the DartEntrypoint that we expect to be executed.
    DartExecutor.DartEntrypoint dartEntrypoint =
        new DartExecutor.DartEntrypoint("default_flutter_assets/path", "myEntrypoint");
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // Dart is executed in onStart().
    delegate.onAttach(ctx);
    delegate.onCreateView(null, null, null, 0, true);
    delegate.onStart();
 
    // Verify that the host's Dart entrypoint was used.
    verify(mockFlutterEngine.getDartExecutor(), times(1))
        .executeDartEntrypoint(eq(dartEntrypoint), isNull());
  }

itUsesNewEngineInGroupWhenProvided()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.itUsesNewEngineInGroupWhenProvided ( )

inline

Definition at line 340 of file FlutterActivityAndFragmentDelegateTest.java.

                                                   {
    // ---- Test setup ----
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.findAppBundlePath()).thenReturn("default_flutter_assets/path");
    FlutterInjector.setInstance(
        new FlutterInjector.Builder().setFlutterLoader(mockFlutterLoader).build());
    FlutterEngineGroup flutterEngineGroup = mock(FlutterEngineGroup.class);
    FlutterEngineGroupCache.getInstance().put("my_flutter_engine_group", flutterEngineGroup);
 
    List<String> entryPointArgs = new ArrayList<>();
    entryPointArgs.add("entrypoint-arg");
 
    // Adjust fake host to request cached engine group.
    when(mockHost.getCachedEngineGroupId()).thenReturn("my_flutter_engine_group");
    when(mockHost.provideFlutterEngine(any(Context.class))).thenReturn(null);
    when(mockHost.shouldAttachEngineToActivity()).thenReturn(false);
    when(mockHost.getDartEntrypointArgs()).thenReturn(entryPointArgs);
 
    // Create the real object that we're testing.
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(mockHost);
 
    // --- Execute the behavior under test ---
    // The FlutterEngine is obtained in onAttach().
    delegate.onAttach(ctx);
 
    // If the engine in FlutterEngineGroup is being used, it should have sent a resumed lifecycle
    // event.
    // Note: "/fake/path" and "main" come from `setUp()`.
    DartExecutor.DartEntrypoint entrypoint = new DartExecutor.DartEntrypoint("/fake/path", "main");
    ArgumentCaptor<FlutterEngineGroup.Options> optionsCaptor =
        ArgumentCaptor.forClass(FlutterEngineGroup.Options.class);
    verify(flutterEngineGroup, times(1)).createAndRunEngine(optionsCaptor.capture());
    assertEquals(mockHost.getContext(), optionsCaptor.getValue().getContext());
    assertEquals(entrypoint, optionsCaptor.getValue().getDartEntrypoint());
    assertEquals(mockHost.getInitialRoute(), optionsCaptor.getValue().getInitialRoute());
    assertNotNull(optionsCaptor.getValue().getDartEntrypointArgs());
    assertEquals(1, optionsCaptor.getValue().getDartEntrypointArgs().size());
    assertEquals("entrypoint-arg", optionsCaptor.getValue().getDartEntrypointArgs().get(0));
  }

setup()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.setup ( )

inline

Definition at line 76 of file FlutterActivityAndFragmentDelegateTest.java.

                      {
    FlutterInjector.reset();
    // Create a mocked FlutterEngine for the various interactions required by the delegate
    // being tested.
    mockFlutterEngine = mockFlutterEngine();
 
    // Create a mocked Host, which is required by the delegate being tested.
    mockHost = mock(FlutterActivityAndFragmentDelegate.Host.class);
    when(mockHost.getContext()).thenReturn(ctx);
    when(mockHost.getActivity()).thenReturn(Robolectric.setupActivity(Activity.class));
    when(mockHost.getLifecycle()).thenReturn(mock(Lifecycle.class));
    when(mockHost.getFlutterShellArgs()).thenReturn(new FlutterShellArgs(new String[] {}));
    when(mockHost.getDartEntrypointFunctionName()).thenReturn("main");
    when(mockHost.getDartEntrypointArgs()).thenReturn(null);
    when(mockHost.getAppBundlePath()).thenReturn("/fake/path");
    when(mockHost.getInitialRoute()).thenReturn("/");
    when(mockHost.getRenderMode()).thenReturn(RenderMode.surface);
    when(mockHost.getTransparencyMode()).thenReturn(TransparencyMode.transparent);
    when(mockHost.provideFlutterEngine(any(Context.class))).thenReturn(mockFlutterEngine);
    when(mockHost.shouldAttachEngineToActivity()).thenReturn(true);
    when(mockHost.shouldHandleDeeplinking()).thenReturn(false);
    when(mockHost.shouldDestroyEngineWithHost()).thenReturn(true);
    when(mockHost.shouldDispatchAppLifecycleState()).thenReturn(true);
    when(mockHost.attachToEngineAutomatically()).thenReturn(true);
 
    mockHost2 = mock(FlutterActivityAndFragmentDelegate.Host.class);
    when(mockHost2.getContext()).thenReturn(ctx);
    when(mockHost2.getActivity()).thenReturn(Robolectric.setupActivity(Activity.class));
    when(mockHost2.getLifecycle()).thenReturn(mock(Lifecycle.class));
    when(mockHost2.getFlutterShellArgs()).thenReturn(new FlutterShellArgs(new String[] {}));
    when(mockHost2.getDartEntrypointFunctionName()).thenReturn("main");
    when(mockHost2.getDartEntrypointArgs()).thenReturn(null);
    when(mockHost2.getAppBundlePath()).thenReturn("/fake/path");
    when(mockHost2.getInitialRoute()).thenReturn("/");
    when(mockHost2.getRenderMode()).thenReturn(RenderMode.surface);
    when(mockHost2.getTransparencyMode()).thenReturn(TransparencyMode.transparent);
    when(mockHost2.provideFlutterEngine(any(Context.class))).thenReturn(mockFlutterEngine);
    when(mockHost2.shouldAttachEngineToActivity()).thenReturn(true);
    when(mockHost2.shouldHandleDeeplinking()).thenReturn(false);
    when(mockHost2.shouldDestroyEngineWithHost()).thenReturn(true);
    when(mockHost2.shouldDispatchAppLifecycleState()).thenReturn(true);
    when(mockHost2.attachToEngineAutomatically()).thenReturn(true);
  }

usesFlutterEngineGroup()

void io.flutter.embedding.android.FlutterActivityAndFragmentDelegateTest.usesFlutterEngineGroup ( )

inline

Definition at line 1326 of file FlutterActivityAndFragmentDelegateTest.java.

                                       {
    FlutterEngineGroup mockEngineGroup = mock(FlutterEngineGroup.class);
    when(mockEngineGroup.createAndRunEngine(any(FlutterEngineGroup.Options.class)))
        .thenReturn(mockFlutterEngine);
    FlutterActivityAndFragmentDelegate.Host host =
        mock(FlutterActivityAndFragmentDelegate.Host.class);
    when(mockHost.getContext()).thenReturn(ctx);
 
    FlutterActivityAndFragmentDelegate delegate =
        new FlutterActivityAndFragmentDelegate(mockHost, mockEngineGroup);
    delegate.onAttach(ctx);
    FlutterEngine engineUnderTest = delegate.getFlutterEngine();
    assertEquals(engineUnderTest, mockFlutterEngine);
  }

---

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

• shell/platform/android/test/io/flutter/embedding/android/FlutterActivityAndFragmentDelegateTest.java