How to make a Splash Screen Android: a professional approach

In the world of mobile development, first impressions are everything. When a user clicks on your application icon, he should not see a white or black screen waiting for resources to load. Splash Screen (splash screen) is a calling card that indicates that the process has begun. In the modern realities of Android, the development of this element has ceased to be a simple matter of inserting a picture into an XML file.

With the release of Android 12 and the Jetpack SplashScreen API library, the approach to implementation has changed dramatically. Now the system takes control of the launch animation, ensuring a smooth transition from the icon to the application content. Developers there is no need to reinvent the wheel, but it is important to understand the new working mechanisms. Ignoring these standards may result in your application looking outdated or working incorrectly on new devices.

In this guide, we will look in detail at how to make an Android splash screen using the latest tools. We will touch on issues of adaptation to different OS versions, theme customization, and handling complex initialization logic. Understanding these processes will allow you to create a seamless experience with your software product.

Evolution and modern launch standards

In the past, creating a loading screen was a matter of creating a separate one Activity, which displayed the logo while heavy operations were performed in the background. This method, known as "Legacy Splash Screen", often resulted in jank when transitioning to the main interface. The system did not know when the application was ready and simply killed the screensaver process on a timer or when the activity ended.

The modern approach implemented in Android 12 and available through backward compatibility for older versions works differently. The system displays a static image immediately after clicking on the icon. This image is generated based on manifest data and application resources. Once the application is ready, an animated transition to the first screen occurs.

⚠️ Warning: Using outdated methods for implementing the splash screen on Android 12 and higher may result in the logo appearing twice or screens switching abruptly, which negatively affects the perceived speed of work.

The key advantage of the new API is predictability. The operating system itself manages the life cycle of the screensaver. You don't have to manually create stub activities. All that is required is the correct theme setup and use of the class InstallSplashScreen. This reduces the likelihood of errors and simplifies code maintenance.

Setting up resources and application themes

Foundation for correct display of the splash screen is the theme of the application. Unlike the old methods, where we changed the background of the window, now we set special attributes in the style. They are the ones that the system draws in the first milliseconds of launch. To do this, you need to define or modify a theme in the file. themes.xml the theme must be defined or modified.

It is important to separate resources for light and dark themes. Users appreciate it when an app respects their system settings. To do this, separate resource files are created or qualifiers are used night. The main attribute that interests us is postSplashScreenTheme. It specifies which theme to apply after the splash screen disappears.

Here is an example of how the definitions should look in XML:

<style name="Theme.App.Starting" parent="Theme.SplashScreen">
<item name="windowSplashScreenBackground">@color/splash_background</item>
<item name="windowSplashScreenAnimatedIcon">@drawable/ic_splash</item>
- <item name="postSplashScreenTheme">@style/Theme.App</item>
</style>

Here windowSplashScreenBackground sets the background color, and windowSplashScreenAnimatedIcon the logo itself. Please note that it is recommended to use vector graphics (VectorDrawable) or adaptive icons for the icon. This ensures clear images on screens of any resolution.

Implementation via the Jetpack SplashScreen API

To enable the functionality, you need to add a dependency to the file build.gradle of your module. The library ensures that the new standards work even on devices running Android 6.0 and higher. Without this library, you will not be able to take advantage of the controlled disappearance of the splash screen.

After adding the dependency, let's move on to the code. The initialization logic is placed in the method onCreate of your start activity (usually this MainActivity). The method call installSplashScreen must occur before the call setContentView. Violation of the order will result in the splash screen not being displayed or displayed incorrectly.

Example implementation in Kotlin:

class MainActivity: AppCompatActivity {
override fun onCreate(savedInstanceState: savedInstanceState?) {
val splashScreen = installSplashScreen
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// Further initialization logic
}
}

splashScreen.setKeepOnScreenCondition {
// Return true while loading is in progress
isLoading.value
}