How to implement in-app update prompt in Android?

Last Updated : 25 May, 2025

Normally to check for an app's update, a user need to open play store, navigate to the app's page and click on check for updates. But, what if we can notify the user as soon as there's an update release for the app on the app's screen itself. That's where In-App Updates comes into motion. In-app updates is a Google Play Core libraries feature that prompts the user to update their app immediately when the user opens it.

Types of In-App Updates:

There are two types of updates flows:

Flexible Updates: The user can continue using the app while the update downloads in the background. Once downloaded, the app prompts for a restart.
Immediate Update: A full-screen update prompt forces the user to update before continuing.

Step by Step Implementation

Step 1: Create a new project

To create a new project in the Android Studio, please refer to How to Create/Start a New Project in Android Studio?

Step 2: Add dependencies for in-app updates

Navigate to Gradle Scripts > build.gradle.kts (Module: app) and add the following dependencies under the dependencies{} scope.

dependencies {
    ...
    implementation ("com.google.android.play:app-update:2.1.0")
    implementation ("com.google.android.play:app-update-ktx:2.1.0")
}

Step 3: Add view binding support

Navigate to Gradle Scripts > build.gradle.kts (Module: app) and add the following code anywhere under the android{} scope.

android {
    ...
    buildFeatures {
        viewBinding = true
    }
    ...
}

Now, select on the Sync prompt on the top-right corner of the code screen.

Step 4: Check for Updates

Navigate to app > java > {package-name} > MainActivity. First, initialize the App Update Manager and Activity Result Launcher

// kotlin
private lateinit var appUpdateManager: AppUpdateManager
private lateinit var activityResultLauncher: ActivityResultLauncher<IntentSenderRequest>

// java
private AppUpdateManager appUpdateManager;
private ActivityResultLauncher<IntentSenderRequest> activityResultLauncher;

Then, create a function to check for app updates and call the function in the overridden onCreate() method.

Java

private void checkForInAppUpdates() {
    // Creates an instance of the AppUpdateManager
    appUpdateManager = AppUpdateManagerFactory.create(this);

    // Registers an activity result launcher to handle the update process result
    activityResultLauncher =
            registerForActivityResult(new ActivityResultContracts.StartIntentSenderForResult(),
                    result -> {
                        if (result.getResultCode() != RESULT_OK) {
                            // If the update fails, show a Toast message and log the failure
                            Toast.makeText(this, "Update failed: " + result.getResultCode(), Toast.LENGTH_SHORT).show();
                            Log.d("Update", "Update flow failed! Result code: " + result.getResultCode());
                        }
                    });

    // Registers a listener to monitor the update installation process
    appUpdateManager.registerListener(listener);

    // Fetches the update information
    appUpdateManager.getAppUpdateInfo().addOnSuccessListener(appUpdateInfo -> {
        // Checks if an update is available and allowed for flexible updates
        if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE &&
                appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)) {
            try {
                // Requests an in-app update
                appUpdateManager.startUpdateFlowForResult(
                        appUpdateInfo,
                        activityResultLauncher,
                        AppUpdateOptions.newBuilder(AppUpdateType.FLEXIBLE).build()
                );
            } catch (IntentSender.SendIntentException e) {
                e.printStackTrace();
            }
        }
    });
}

Kotlin

// checking for in-app updates
private fun checkForInAppUpdates() {
    appUpdateManager = AppUpdateManagerFactory.create(this)
    activityResultLauncher =
        registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result: ActivityResult ->
            if (result.resultCode != RESULT_OK) {
                Toast.makeText(this, "Update failed: ${result.resultCode}", Toast.LENGTH_SHORT).show()
                Log.d("Update", "Update flow failed! Result code: ${result.resultCode}")
            }
        }

    appUpdateManager.registerListener(listener)

    val appUpdateInfoTask = appUpdateManager.appUpdateInfo
    appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
        if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE &&
            appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)
        ) {

            // requesting for update
            appUpdateManager.startUpdateFlowForResult(
                appUpdateInfo,
                activityResultLauncher,
                AppUpdateOptions.newBuilder(AppUpdateType.FLEXIBLE).build()
            )
        }
    }
}

Step 5: Handle Update Completion

Now, you might have noticed we have registered a listener to out app update manager to listen for update complement. This will help us prompting the user to restart the app in order to finish pending installations.

First, create the listener

Java

private final InstallStateUpdatedListener listener = state -> {
    // Checks if the update has been downloaded
    if (state.installStatus() == InstallStatus.DOWNLOADED) {
        // Shows a Snackbar prompting the user to restart the app to complete the update
        popupSnackbarForCompleteUpdate();
    }
};

Kotlin

private val listener = InstallStateUpdatedListener { state ->
    if (state.installStatus() == InstallStatus.DOWNLOADED) {
        popupSnackbarForCompleteUpdate()
    }
}

Then, create the function for a snackbar prompting to restart the app and finish installation.

Java

private void popupSnackbarForCompleteUpdate() {
    Snackbar.make(
            binding.getRoot(),
            "Update ready to install",
            Snackbar.LENGTH_INDEFINITE
    ).setAction("Restart", v -> appUpdateManager.completeUpdate()).show();
}

Kotlin

private fun popupSnackbarForCompleteUpdate() {
    Snackbar.make(
        binding.root,
        "Update ready to install",
        Snackbar.LENGTH_INDEFINITE
    ).apply {
        setAction("Restart") { appUpdateManager.completeUpdate() }
        show()
    }
}

Step 6: Resume Pending Updates

Now, override the onResume() method to prompt user for the restart since the app will be temporarily paused due to the update. Also, remember to override the onStop() method to unregister the listener.

Java

@Override
protected void onStop() {
    super.onStop();
    appUpdateManager.unregisterListener(listener);
}

@Override
protected void onResume() {
    super.onResume();
    appUpdateManager.getAppUpdateInfo()
            .addOnSuccessListener(appUpdateInfo -> {
                if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
                    popupSnackbarForCompleteUpdate();
                }
            });
}

Kotlin

override fun onResume() {
    super.onResume()
    appUpdateManager.appUpdateInfo
        .addOnSuccessListener { appUpdateInfo ->
            if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
                popupSnackbarForCompleteUpdate()
            }
        }
}

override fun onStop() {
    super.onStop()
    appUpdateManager.unregisterListener(listener)
}

Step 7: Working with MainActivity

Here's the entire code for the MainActivity file.