io.flutter.embedding.android.FlutterFragmentTest Class Reference

Classes
class	TestDelegateFactory

Public Member Functions
void	itCreatesDefaultFragmentWithExpectedDefaults ()
void	itCreatesNewEngineFragmentWithRequestedSettings ()
void	itCreatesNewEngineInGroupFragmentWithRequestedSettings ()
void	itCreatesNewEngineFragmentThatDelaysFirstDrawWhenRequested ()
void	itCreatesCachedEngineFragmentWithExpectedDefaults ()
void	itCreatesCachedEngineFragmentThatDestroysTheEngine ()
void	itCreatesCachedEngineFragmentThatDelaysFirstDrawWhenRequested ()
void	itCanBeDetachedFromTheEngineAndStopSendingFurtherEvents ()
void	itDoesNotReleaseEnginewhenDetachFromFlutterEngine ()
void	itReleaseEngineWhenOnDetach ()
void	itReturnsExclusiveAppComponent ()
void	itDelegatesOnBackPressedWithSetFrameworkHandlesBack ()
void	itHandlesPopSystemNavigationAutomaticallyWhenEnabled ()
void	itRegistersComponentCallbacks ()

Package Attributes
boolean	isDelegateAttached

Detailed Description

Definition at line 37 of file FlutterFragmentTest.java.

Member Function Documentation

itCanBeDetachedFromTheEngineAndStopSendingFurtherEvents()

void io.flutter.embedding.android.FlutterFragmentTest.itCanBeDetachedFromTheEngineAndStopSendingFurtherEvents ( )

inline

Definition at line 175 of file FlutterFragmentTest.java.

                                                                        {
    FlutterActivityAndFragmentDelegate mockDelegate =
        mock(FlutterActivityAndFragmentDelegate.class);
    TestDelegateFactory delegateFactory = new TestDelegateFactory(mockDelegate);
    FlutterFragment fragment =
        FlutterFragment.withCachedEngine("my_cached_engine")
            .destroyEngineWithFragment(true)
            .build();
 
    isDelegateAttached = true;
    when(mockDelegate.isAttached()).thenAnswer(invocation -> isDelegateAttached);
    doAnswer(invocation -> isDelegateAttached = false).when(mockDelegate).onDetach();
 
    fragment.setDelegateFactory(delegateFactory);
    fragment.onStart();
    fragment.onResume();
    fragment.onPostResume();
 
    verify(mockDelegate, times(1)).onStart();
    verify(mockDelegate, times(1)).onResume();
    verify(mockDelegate, times(1)).onPostResume();
 
    fragment.onPause();
    fragment.detachFromFlutterEngine();
    verify(mockDelegate, times(1)).onPause();
    verify(mockDelegate, times(1)).onDestroyView();
    verify(mockDelegate, times(1)).onDetach();
 
    fragment.onStop();
    verify(mockDelegate, never()).onStop();
 
    fragment.onStart();
    fragment.onResume();
    fragment.onPostResume();
    // No more events through to the delegate.
    verify(mockDelegate, times(1)).onStart();
    verify(mockDelegate, times(1)).onResume();
    verify(mockDelegate, times(1)).onPostResume();
 
    fragment.onDestroy();
    // 1 time same as before.
    verify(mockDelegate, times(1)).onDestroyView();
    verify(mockDelegate, times(1)).onDetach();
  }

itCreatesCachedEngineFragmentThatDelaysFirstDrawWhenRequested()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesCachedEngineFragmentThatDelaysFirstDrawWhenRequested ( )

inline

Definition at line 165 of file FlutterFragmentTest.java.

                                                                              {
    FlutterFragment fragment =
        FlutterFragment.withCachedEngine("my_cached_engine")
            .shouldDelayFirstAndroidViewDraw(true)
            .build();
 
    assertNotNull(fragment.shouldDelayFirstAndroidViewDraw());
  }

itCreatesCachedEngineFragmentThatDestroysTheEngine()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesCachedEngineFragmentThatDestroysTheEngine ( )

inline

Definition at line 153 of file FlutterFragmentTest.java.

                                                                   {
    FlutterFragment fragment =
        FlutterFragment.withCachedEngine("my_cached_engine")
            .destroyEngineWithFragment(true)
            .build();
 
    assertTrue(fragment.shouldAttachEngineToActivity());
    assertEquals("my_cached_engine", fragment.getCachedEngineId());
    assertTrue(fragment.shouldDestroyEngineWithHost());
  }

itCreatesCachedEngineFragmentWithExpectedDefaults()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesCachedEngineFragmentWithExpectedDefaults ( )

inline

Definition at line 143 of file FlutterFragmentTest.java.

                                                                  {
    FlutterFragment fragment = FlutterFragment.withCachedEngine("my_cached_engine").build();
 
    assertTrue(fragment.shouldAttachEngineToActivity());
    assertEquals("my_cached_engine", fragment.getCachedEngineId());
    assertFalse(fragment.shouldDestroyEngineWithHost());
    assertFalse(fragment.shouldDelayFirstAndroidViewDraw());
  }

itCreatesDefaultFragmentWithExpectedDefaults()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesDefaultFragmentWithExpectedDefaults ( )

inline

Definition at line 55 of file FlutterFragmentTest.java.

                                                             {
    FlutterFragment fragment = FlutterFragment.createDefault();
    TestDelegateFactory delegateFactory =
        new TestDelegateFactory(new FlutterActivityAndFragmentDelegate(fragment));
    fragment.setDelegateFactory(delegateFactory);
 
    assertEquals("main", fragment.getDartEntrypointFunctionName());
    assertNull(fragment.getDartEntrypointLibraryUri());
    assertNull(fragment.getDartEntrypointArgs());
    assertEquals("/", fragment.getInitialRoute());
    assertArrayEquals(new String[] {}, fragment.getFlutterShellArgs().toArray());
    assertTrue(fragment.shouldAttachEngineToActivity());
    assertFalse(fragment.shouldHandleDeeplinking());
    assertNull(fragment.getCachedEngineId());
    assertTrue(fragment.shouldDestroyEngineWithHost());
    assertEquals(RenderMode.surface, fragment.getRenderMode());
    assertEquals(TransparencyMode.transparent, fragment.getTransparencyMode());
    assertFalse(fragment.shouldDelayFirstAndroidViewDraw());
  }

itCreatesNewEngineFragmentThatDelaysFirstDrawWhenRequested()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesNewEngineFragmentThatDelaysFirstDrawWhenRequested ( )

inline

Definition at line 135 of file FlutterFragmentTest.java.

                                                                           {
    FlutterFragment fragment =
        FlutterFragment.withNewEngine().shouldDelayFirstAndroidViewDraw(true).build();
 
    assertNotNull(fragment.shouldDelayFirstAndroidViewDraw());
  }

itCreatesNewEngineFragmentWithRequestedSettings()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesNewEngineFragmentWithRequestedSettings ( )

inline

Definition at line 76 of file FlutterFragmentTest.java.

                                                                {
    FlutterFragment fragment =
        FlutterFragment.withNewEngine()
            .dartEntrypoint("custom_entrypoint")
            .dartLibraryUri("package:foo/bar.dart")
            .dartEntrypointArgs(new ArrayList<String>(Arrays.asList("foo", "bar")))
            .initialRoute("/custom/route")
            .shouldAttachEngineToActivity(false)
            .handleDeeplinking(true)
            .renderMode(RenderMode.texture)
            .transparencyMode(TransparencyMode.opaque)
            .build();
    TestDelegateFactory delegateFactory =
        new TestDelegateFactory(new FlutterActivityAndFragmentDelegate(fragment));
    fragment.setDelegateFactory(delegateFactory);
 
    assertEquals("custom_entrypoint", fragment.getDartEntrypointFunctionName());
    assertEquals("package:foo/bar.dart", fragment.getDartEntrypointLibraryUri());
    assertEquals("/custom/route", fragment.getInitialRoute());
    assertArrayEquals(new String[] {"foo", "bar"}, fragment.getDartEntrypointArgs().toArray());
    assertArrayEquals(new String[] {}, fragment.getFlutterShellArgs().toArray());
    assertFalse(fragment.shouldAttachEngineToActivity());
    assertTrue(fragment.shouldHandleDeeplinking());
    assertNull(fragment.getCachedEngineId());
    assertTrue(fragment.shouldDestroyEngineWithHost());
    assertEquals(RenderMode.texture, fragment.getRenderMode());
    assertEquals(TransparencyMode.opaque, fragment.getTransparencyMode());
  }

itCreatesNewEngineInGroupFragmentWithRequestedSettings()

void io.flutter.embedding.android.FlutterFragmentTest.itCreatesNewEngineInGroupFragmentWithRequestedSettings ( )

inline

Definition at line 106 of file FlutterFragmentTest.java.

                                                                       {
    FlutterFragment fragment =
        FlutterFragment.withNewEngineInGroup("my_cached_engine_group")
            .dartEntrypoint("custom_entrypoint")
            .initialRoute("/custom/route")
            .shouldAttachEngineToActivity(false)
            .handleDeeplinking(true)
            .renderMode(RenderMode.texture)
            .transparencyMode(TransparencyMode.opaque)
            .build();
 
    TestDelegateFactory delegateFactory =
        new TestDelegateFactory(new FlutterActivityAndFragmentDelegate(fragment));
 
    fragment.setDelegateFactory(delegateFactory);
 
    assertEquals("my_cached_engine_group", fragment.getCachedEngineGroupId());
    assertEquals("custom_entrypoint", fragment.getDartEntrypointFunctionName());
    assertEquals("/custom/route", fragment.getInitialRoute());
    assertArrayEquals(new String[] {}, fragment.getFlutterShellArgs().toArray());
    assertFalse(fragment.shouldAttachEngineToActivity());
    assertTrue(fragment.shouldHandleDeeplinking());
    assertNull(fragment.getCachedEngineId());
    assertTrue(fragment.shouldDestroyEngineWithHost());
    assertEquals(RenderMode.texture, fragment.getRenderMode());
    assertEquals(TransparencyMode.opaque, fragment.getTransparencyMode());
  }

itDelegatesOnBackPressedWithSetFrameworkHandlesBack()

void io.flutter.embedding.android.FlutterFragmentTest.itDelegatesOnBackPressedWithSetFrameworkHandlesBack ( )

inline

Definition at line 293 of file FlutterFragmentTest.java.

                                                                    {
    // We need to mock FlutterJNI to avoid triggering native code.
    FlutterJNI flutterJNI = mock(FlutterJNI.class);
    when(flutterJNI.isAttached()).thenReturn(true);
 
    FlutterEngine flutterEngine =
        new FlutterEngine(ctx, new FlutterLoader(), flutterJNI, null, false);
    FlutterEngineCache.getInstance().put("my_cached_engine", flutterEngine);
 
    FlutterFragment fragment =
        FlutterFragment.withCachedEngine("my_cached_engine")
            // This enables the use of onBackPressedCallback, which is what
            // sends backs to the framework if setFrameworkHandlesBack is true.
            .shouldAutomaticallyHandleOnBackPressed(true)
            .build();
    FragmentActivity activity = getMockFragmentActivity();
    activity
        .getSupportFragmentManager()
        .beginTransaction()
        .add(android.R.id.content, fragment)
        .commitNow();
 
    FlutterActivityAndFragmentDelegate mockDelegate =
        mock(FlutterActivityAndFragmentDelegate.class);
    isDelegateAttached = true;
    when(mockDelegate.isAttached()).thenAnswer(invocation -> isDelegateAttached);
    doAnswer(invocation -> isDelegateAttached = false).when(mockDelegate).onDetach();
    TestDelegateFactory delegateFactory = new TestDelegateFactory(mockDelegate);
    fragment.setDelegateFactory(delegateFactory);
 
    // Calling onBackPressed now will still be handled by Android (the default),
    // until setFrameworkHandlesBack is set to true.
    activity.onBackPressed();
    verify(mockDelegate, times(0)).onBackPressed();
 
    // Setting setFrameworkHandlesBack to true means the delegate will receive
    // the back and Android won't handle it.
    fragment.setFrameworkHandlesBack(true);
    activity.getOnBackPressedDispatcher().onBackPressed();
    verify(mockDelegate, times(1)).onBackPressed();
  }

itDoesNotReleaseEnginewhenDetachFromFlutterEngine()

void io.flutter.embedding.android.FlutterFragmentTest.itDoesNotReleaseEnginewhenDetachFromFlutterEngine ( )

inline

Definition at line 221 of file FlutterFragmentTest.java.

                                                                  {
    FlutterActivityAndFragmentDelegate mockDelegate =
        mock(FlutterActivityAndFragmentDelegate.class);
    isDelegateAttached = true;
    when(mockDelegate.isAttached()).thenAnswer(invocation -> isDelegateAttached);
    doAnswer(invocation -> isDelegateAttached = false).when(mockDelegate).onDetach();
    TestDelegateFactory delegateFactory = new TestDelegateFactory(mockDelegate);
 
    FlutterFragment fragment =
        FlutterFragment.withCachedEngine("my_cached_engine")
            .destroyEngineWithFragment(true)
            .build();
 
    fragment.setDelegateFactory(delegateFactory);
    fragment.onStart();
    fragment.onResume();
    fragment.onPostResume();
    fragment.onPause();
 
    assertTrue(mockDelegate.isAttached());
    fragment.detachFromFlutterEngine();
    verify(mockDelegate, times(1)).onDetach();
    verify(mockDelegate, never()).release();
    assertFalse(mockDelegate.isAttached());
  }

itHandlesPopSystemNavigationAutomaticallyWhenEnabled()

void io.flutter.embedding.android.FlutterFragmentTest.itHandlesPopSystemNavigationAutomaticallyWhenEnabled ( )

inline

Definition at line 339 of file FlutterFragmentTest.java.

                                                                     {
    // We need to mock FlutterJNI to avoid triggering native code.
    FlutterJNI flutterJNI = mock(FlutterJNI.class);
    when(flutterJNI.isAttached()).thenReturn(true);
 
    FlutterEngine flutterEngine =
        new FlutterEngine(ctx, new FlutterLoader(), flutterJNI, null, false);
    FlutterEngineCache.getInstance().put("my_cached_engine", flutterEngine);
 
    FlutterFragment fragment =
        FlutterFragment.withCachedEngine("my_cached_engine")
            .shouldAutomaticallyHandleOnBackPressed(true)
            .build();
    FragmentActivity activity = getMockFragmentActivity();
    activity
        .getSupportFragmentManager()
        .beginTransaction()
        .add(android.R.id.content, fragment)
        .commitNow();
    final AtomicBoolean onBackPressedCalled = new AtomicBoolean(false);
    OnBackPressedCallback callback =
        new OnBackPressedCallback(true) {
          @Override
          public void handleOnBackPressed() {
            onBackPressedCalled.set(true);
          }
        };
    activity.getOnBackPressedDispatcher().addCallback(callback);
 
    FlutterActivityAndFragmentDelegate mockDelegate =
        mock(FlutterActivityAndFragmentDelegate.class);
    TestDelegateFactory delegateFactory = new TestDelegateFactory(mockDelegate);
    fragment.setDelegateFactory(delegateFactory);
 
    assertTrue(callback.isEnabled());
 
    assertTrue(fragment.popSystemNavigator());
 
    verify(mockDelegate, never()).onBackPressed();
    assertTrue(onBackPressedCalled.get());
    assertTrue(callback.isEnabled());
 
    callback.setEnabled(false);
    assertFalse(callback.isEnabled());
    assertTrue(fragment.popSystemNavigator());
 
    verify(mockDelegate, never()).onBackPressed();
    assertFalse(callback.isEnabled());
  }

itRegistersComponentCallbacks()

void io.flutter.embedding.android.FlutterFragmentTest.itRegistersComponentCallbacks ( )

inline

Definition at line 390 of file FlutterFragmentTest.java.

                                              {
    FlutterActivityAndFragmentDelegate mockDelegate =
        mock(FlutterActivityAndFragmentDelegate.class);
    isDelegateAttached = true;
    when(mockDelegate.isAttached()).thenAnswer(invocation -> isDelegateAttached);
    doAnswer(invocation -> isDelegateAttached = false).when(mockDelegate).onDetach();
    TestDelegateFactory delegateFactory = new TestDelegateFactory(mockDelegate);
 
    Context spyCtx = spy(ctx);
    // We need to mock FlutterJNI to avoid triggering native code.
    FlutterJNI flutterJNI = mock(FlutterJNI.class);
    when(flutterJNI.isAttached()).thenReturn(true);
 
    FlutterEngine flutterEngine =
        new FlutterEngine(spyCtx, new FlutterLoader(), flutterJNI, null, false);
    FlutterEngineCache.getInstance().put("my_cached_engine", flutterEngine);
 
    FlutterFragment fragment = spy(FlutterFragment.withCachedEngine("my_cached_engine").build());
    when(fragment.getContext()).thenReturn(spyCtx);
    fragment.setDelegateFactory(delegateFactory);
 
    fragment.onAttach(spyCtx);
    verify(spyCtx, times(1)).registerComponentCallbacks(any());
    verify(spyCtx, never()).unregisterComponentCallbacks(any());
 
    fragment.onDetach();
    verify(spyCtx, times(1)).registerComponentCallbacks(any());
    verify(spyCtx, times(1)).unregisterComponentCallbacks(any());
  }

itReleaseEngineWhenOnDetach()

void io.flutter.embedding.android.FlutterFragmentTest.itReleaseEngineWhenOnDetach ( )

inline

Definition at line 248 of file FlutterFragmentTest.java.

                                            {
    FlutterActivityAndFragmentDelegate mockDelegate =
        mock(FlutterActivityAndFragmentDelegate.class);
    isDelegateAttached = true;
    when(mockDelegate.isAttached()).thenAnswer(invocation -> isDelegateAttached);
    doAnswer(invocation -> isDelegateAttached = false).when(mockDelegate).onDetach();
    TestDelegateFactory delegateFactory = new TestDelegateFactory(mockDelegate);
 
    FlutterFragment fragment =
        spy(
            FlutterFragment.withCachedEngine("my_cached_engine")
                .destroyEngineWithFragment(true)
                .build());
    when(fragment.getContext()).thenReturn(mock(Context.class));
 
    fragment.setDelegateFactory(delegateFactory);
    fragment.onStart();
    fragment.onResume();
    fragment.onPostResume();
    fragment.onPause();
 
    assertTrue(mockDelegate.isAttached());
    fragment.onDetach();
    verify(mockDelegate, times(1)).onDetach();
    verify(mockDelegate, times(1)).release();
    assertFalse(mockDelegate.isAttached());
  }

itReturnsExclusiveAppComponent()

void io.flutter.embedding.android.FlutterFragmentTest.itReturnsExclusiveAppComponent ( )

inline

Definition at line 277 of file FlutterFragmentTest.java.

                                               {
    FlutterFragment fragment = FlutterFragment.createDefault();
    FlutterActivityAndFragmentDelegate delegate = new FlutterActivityAndFragmentDelegate(fragment);
    TestDelegateFactory delegateFactory = new TestDelegateFactory(delegate);
    fragment.setDelegateFactory(delegateFactory);
 
    assertEquals(fragment.getExclusiveAppComponent(), delegate);
  }

Member Data Documentation

isDelegateAttached

boolean io.flutter.embedding.android.FlutterFragmentTest.isDelegateAttached

package

Definition at line 39 of file FlutterFragmentTest.java.

---

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

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