Manually create and warm up the root Container

[m-sadegh-sh]

This is a general requirement to warm up a capsule and the capsule should be ready before showing any Flutter-specific widget. For example, a capsule reads a user configuration from shared preferences to create a ThemeData instance.

The initial plan would be this. Use a RearchBootstrapper widget, which automatically creates a Container instance, shares it through the widget tree, and disposes the created Container instance. And, use the .toWarmUpWidget extension method to warm the required capsules, and finally construct the MaterialApp.

Imagine I have set up a native splash screen. So I do some third-party initialization, e.g. Firebase, Supabase, etc before calling the runApp. So these will keep the native splash screen being shown, as desired. Now it's time to warm up the required capsules, and this is gonna be achieved as part of a custom widget named CapsuleWarmUp (internally utilizes toWarmUpWidget ). So I have to implement a UI for the loading state.

I prefer to do the warmup before Flutter draws its first frame, and this means the splash screen will be kept showing.

Future<void> main() async {
  ensureWidgetsInitialized();
  await initializeSupabase();

  final container = await setupCapsuleContainer();

  restoreSystemUIMode();

  runApp(
    CapsuleContainerProvider(
      container: container,
      child: const App(),
    ),
  );
}

Future<CapsuleContainer> setupCapsuleContainer() async {
  final container = CapsuleContainer();

  await container.warmUp(
    [sharedPreferencesReaderWarmUpCapsule],
  );

  return container;
}

This works fine, but the only thing I'm concerned about is the lack of the Container disposal. If I call dispose right after the runApp call, things go wrong. Should I ever be concerned about this? The root container must be there as long as the app is running. So if I do not dispose it, I feel it will not lead to a memory leak.

I would be happy to hear your thoughts.

[GregoryConrad]

Hi 👋

I'll preface this answer with the following (for anyone else stumbling upon this discussion in the future):

Note

Most of the time you should be using the warm up methodology defined in the docs.

That being disclosed, you explicitly said:

I prefer to do the warmup before Flutter draws its first frame, and this means the splash screen will be kept showing.

Which is a valid use-case that I hadn't thought of before.

but the only thing I'm concerned about is the lack of the Container disposal

Don't worry about it; Flutter doesn't even guarantee that deactivate/unmount will be called on app close (and thus container/other resource disposal that's managed by the widget tree). And since your container will live for the life of the app (since the CapsuleContainerProvider has a reference to it), you will never run into issues.

Your approach looks fine to me, except for:

Warning

Since you're opting to do this manually, just ensure you also runApp with a dummy app to present a user-friendly error message in case the app fails to start.
This can be achieved via a try/catch around the await container.warmUp() that showcases the error messages via runApp in the catch block.

[GregoryConrad]

BTW, if you feel "dirty" by not disposing the CapsuleContainer, you could wrap your entire app in a StatefulWidget that calls the container's dispose for you in its State.dispose. But that is frankly more effort than I think it's worth, since as I mentioned above, that State.dispose is not guaranteed to be called anyways (in fact, I think it isn't called on most platforms).

[m-sadegh-sh]

Thanks for the response. I'll apply what you suggested for the error handling.

[m-sadegh-sh]

@GregoryConrad BTW, I sent you a connection request on LinkedIn. Let's connect because I'm posting about the awesome Rearch there and wanted to mention you in my posts.

[GregoryConrad]

@m-sadegh-sh Not sure I got your request; here's my LinkedIn