Keeping your app up-to-date on your users’ devices enables them to try new features, as well as benefit from performance improvements and bug fixes.

In-app updates is a Play Core library feature that introduces a new request flow to prompt active users to update your app.

In simple words, it provides an option to the user which notifies the user that an app update is available and the user can select if they are interested in updating the app or not.

Not only that, but it also provides an option to download the update of the app in the background, and once downloaded, install the update and restart the app and the user doesn’t have to do anything.

In-app updates work only with devices running Android 5.0 (API level 21) or higher and require you to use Play Core library 1.5.0 or higher. Additionally, in-app updates support apps running on only Android mobile devices and tablets, and Chrome OS devices.

The Play Core library offers us two different ways in which we can prompt our users that an update is available — either using the Flexible or Immediate approach. Let’s take a look at each of them one by one-

Flexible: A user experience that provides background download and installation with graceful state monitoring. This UX is appropriate when it’s acceptable for the user to use the app while downloading the update. For example, you want to urge users to try a new feature that’s not critical to the core functionality of your app.

Immediate: A full-screen user experience that requires the user to update and restart the app to continue using the app. This UX is best for cases where an update is critical for continued use of the app. After a user accepts an immediate update, Google Play handles the update installation and app restart.

Now we all have an understanding of both the types of In-app updates available we will start implementing it.

The very first step is to check for the update-

Before requesting an update, you need to check if an update is available or not and also the type of update available. We do not want users to have a bad experience. To check for an update you can use the AppUpdateManager.

val appUpdateManager: AppUpdateManager = AppUpdateManagerFactory.create(baseContext)

val appUpdateInfo = appUpdateManager.appUpdateInfo
// Creates instance of the manager.
val appUpdateManager = AppUpdateManagerFactory.create(context)

// Returns an intent object that you use to check for an update.
val appUpdateInfoTask = appUpdateManager.appUpdateInfo

// Checks that the platform will allow the specified type of update.
appUpdateInfo?.addOnSuccessListener { appUpdateInfo ->
    if ((appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE ||
            appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) &&
    appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)
) {
    btn_update.visibility = View.VISIBLE
    setUpdateAction(appUpdateManager, appUpdateInfo)
  }
}

Here we have created a button to show some UX experience. Whenever there will be a flexible update available we will show the update button to the users. As we have an update available of flexible types, we will start the update.

private fun setUpdateAction(manager: AppUpdateManager?, info: Task<AppUpdateInfo>) {
    // Before starting an update, register a listener for updates.

btn_update.setOnClickListener {
        installStateUpdatedListener = InstallStateUpdatedListener {
            btn_update.visibility = View.GONE
            // tv_status is a textview to display the update status      
            tv_status.visibility = View.VISIBLE
            when (it.installStatus()) {
                InstallStatus.FAILED, InstallStatus.UNKNOWN -> {
                    tv_status.text = getString(R.string.info_failed)
                    btn_update.visibility = View.VISIBLE
                }
                InstallStatus.PENDING -> {
                    tv_status.text = getString(R.string.info_pending)
                }
                InstallStatus.CANCELED -> {
                    tv_status.text = getString(R.string.info_canceled)
                }
                InstallStatus.DOWNLOADING -> {
                    tv_status.text = getString(R.string.info_downloading)
                }
                InstallStatus.DOWNLOADED -> {
                    tv_status.text = getString(R.string.info_downloaded)
                    popupSnackbarForCompleteUpdate(manager)
                }
                InstallStatus.INSTALLING -> {
                    tv_status.text = getString(R.string.info_installing)
                }
                InstallStatus.INSTALLED -> {
                    tv_status.text = getString(R.string.info_installed)
                    manager?.unregisterListener(installStateUpdatedListener)
                }
                else -> {
                    tv_status.text = getString(R.string.info_restart)
                }
            }
        }
        manager?.registerListener(installStateUpdatedListener)
        manager?.startUpdateFlowForResult(            info.result, AppUpdateType.FLEXIBLE,
            this, IN_APP_UPDATE_REQUEST_CODE
        )
    }
}

While doing the update, you can handle the update related failure or cancellation by using the onActivityResult() as follows:

/** This is needed to handle the result of the manager.startConfirmationDialogForResult request */
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    if (requestCode == IN_APP_UPDATE_REQUEST_CODE) {
        if (resultCode != RESULT_OK) {
            toastAndLog("Update flow failed! Result code: $resultCode")
            // If the update is cancelled or fails,
            // you can request to start the update again.
        }
    } else {
        super.onActivityResult(requestCode, resultCode, data)
    }
}

The following describes the different values you may receive from the onActivityResult() callback:

• RESULT_OK: The user has accepted the update. For immediate updates, you might not receive this callback because the update should already be completed by Google Play by the time the control is given back to your app.
• RESULT_CANCELED: The user has denied or canceled the update.
• ActivityResult.RESULT_IN_APP_UPDATE_FAILED: Some other error prevented either the user from providing consent or the update to proceed.

Install a Flexible Update

If you monitor the flexible update states and you detect the InstallStatus.DOWNLOADED state, you need to restart the app to install the update.

Unlike an immediate update, Google Play does not trigger an app restart for you. That’s because, during a flexible update, the user expects to keep using the app until they decide that they want to install the update.

So, it’s recommended that you provide the user some notification or UI indication to notify that an update is ready for installation and requests user confirmation to restart the app.

Here we will implement a snackbar to request the user confirmation to restart the app.

/* Displays the snackbar notification and call to action. */
private fun popupSnackbarForCompleteUpdate(appUpdateManager: AppUpdateManager?) {
    Snackbar.make(
        findViewById(R.id.mainLayoutParent),
        "Ready to INSTALL.", Snackbar.LENGTH_INDEFINITE
    ).apply {
        setAction("RESTART") { appUpdateManager?.completeUpdate() }
        setActionTextColor(ContextCompat.getColor(applicationContext, R.color.colorAccent))
        show()
    }
}

When you call appUpdateManager?.completeUpdate() in the foreground, the platform displays a full-screen UI which restarts the app in the background. After the platform installs the update, the app restarts into its main activity.

If you instead call appUpdateManager?.completeUpdate() when the app is in the background, the update is installed silently without obscuring the device UI.

When the user brings your app to the foreground, it’s recommended that you check that your app doesn’t have an update waiting to be installed. If your app has an update in the DOWNLOADED state, show the notification to request that the user install the update, as shown. Otherwise, the update data continues to occupy the user’s device storage.

// Checks that the update is not stalled during 'onResume()'.
// However, you should execute this check at all app entry points.
override fun onResume() {
    super.onResume()

    appUpdateManager.appUpdateInfo
        .addOnSuccessListener {
            if (it.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE || UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
                updateManager.startUpdateFlowForResult(
                    it,
                    IMMEDIATE,
                    this,
                    IN_APP_UPDATE_REQUEST_CODE)
            }
        }
    }
}

Handle an immediate update

If you are performing an immediate update, and the user consents to install the update, Google Play displays the update progress on top of your app’s UI across the entire duration of the update. During the update, if the user closes or terminates your app, the update should continue to download and install in the background without additional user confirmation.

appUpdateInfo?.addOnSuccessListener { appUpdateInfo ->
    if ((appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE ||
            appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) &&
    appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
) {
    updateManager.startUpdateFlowForResult(it, IMMEDIATE, this,  IN_APP_UPDATE_REQUEST_CODE)
  }
}

To check how to test In-app updates please refer: https://developer.android.com/guide/playcore/in-app-updates

Conclusion

In this blog, we’ve learned about the new approach to in-app updates that are provided by the play core library. You can also check out how to set the appUpdatePriority and clientVersionStalenessDays.

Do checkout my GitHub repo for the implementation

https://github.com/ashitaasati1608/InAppUpdate

If you have any questions about the play core library or in-app updates then please do reach out.

Happy Coding!!

Implementing In-App Updates in Android was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

What’s Navigation Component?

We all know that navigating between screens is one of the fundamental things in an Android application. Usually, we either achieve it through Intents or via Event Bus but what about the complex scenarios like navigation drawer or bottom navigation where you need to keep the selected tab highlighted in sync with the presented screen not to mention back-stack management? Isn’t it a bit complex to achieve this way?

Navigation component is the one-stop solution to all the problems for any type of navigation in an android app. The navigation component helps you to manage navigations, fragment transactions, back-stack management, animations, most importantly deep linking and many more. The JetPack Navigation component is a suite of libraries, tooling, and guidance that provides a robust navigation framework for in-app navigation.

The navigation component provides a new type of navigation in android development, where we have a navigation graph to see all the screens and the navigation between them.

Let’s talk about the key parts of the Navigation component. Navigation component consists of three key types

• Navigation graph: An XML resource that contains all navigation-related information in one centralized location. This includes all of the individual content areas within your app, called destinations, as well as the possible paths that a user can take through your app.
• NavHost: An empty container that displays destinations from your navigation graph.
• NavController: An object that manages app navigation within a NavHost. The NavController orchestrates the swapping of destination content in the NavHost as users move throughout your app.

I’ll explain two more terminologies here as we are going to use them very often-

• Destinations: Destinations are nothing but all content areas in your app like activities, fragments, dialogs, and so on.
• Actions: Action is used to create a navigation that has an attribute called destination, where we can mention the end screen id.

When we navigate through the app using the NavController, the NavController shows the appropriate destination in the NavHost.

The Navigation component provides several other benefits, including the following:

• Simplified setup for common navigation patterns
• Handling fragment transactions.
• Type safe when passing information while navigating
• Handles transition animations
• Centralizes and visualizes navigation
• Handling Up and Back actions correctly by default.
• Providing standardized resources for animations and transitions.
• Implementing and handling deep linking.

Okay, so we are now familiar with the Navigation component and benefits. Now it’s time to get our hands dirty with implementing a basic navigation flow.

So what are we going to build?

We will build a basic application with three screens(Main Activity with three fragments with two buttons each) and establish the navigation between them.

Let’s get started…

Prerequisites:

• Basic Kotlin knowledge
• Android Studio 3.2 or higher
• Emulator or device running API 14+

After creating the basic Android project, add the below dependency in the top-level build.gradle file.

def nav_version = "2.1.0"

dependencies {
    classpath "androidx.navigation:navigation-safe-args-gradle-plugin:$nav_version"
}

Now, add the below dependencies in your app-level build.gradle, and once done click on sync now!

apply plugin: "androidx.navigation.safeargs.kotlin"

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

kotlinOptions {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
}

def nav_version = "2.2.2"
dependencies {
implementation "androidx.navigation:navigation-fragment ktx:$nav_version"
implementation "androidx.navigation:navigation-ui-ktx:$nav_version"
}

Safe Arguments : Safe Args is a Gradle plugin used to pass data between destinations. The main advantage of using safe args is that some of the checks that happen at runtime will now be done at compile time.

You’re good to go now!!!

Firstly, we will create a Navigation Graph for our application.

The question arises here is how to create a navigation Graph???

As we learned earlier that a navigation graph is nothing but a resource file with all navigation related information, so we create a resource file under res directory with resource type as navigation.

Steps to creating a navigation graph:

1. In the Project window, right-click on the res directory and select New > Android Resource File under navigation directory. If you haven’t created then create one.
2. In the navigation directory, we’ll create a new navigation resource file. In this example, I’ve named it navigation but you can name it whatever you like.
3. Select Navigation from the Resource type drop-down list, and then click OK.

Now, we will modify out activity_main.xml and replace the default <TextView/> with the <fragment/> given below-

<fragment
    android:id="@+id/fragment"
    android:name="androidx.navigation.fragment.NavHostFragment"
    android:layout_width="0dp"
    android:layout_height="0dp"
    app:defaultNavHost="true"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:navGraph="@navigation/navigation" />

Once we’ve done that, we should see a host (activity_main) added to the Navigation graph (in navigation.xml)

Now we can add a new destination by clicking on the ‘Click to add a destination’ option in the center of the navigation graph. Then select ‘create new destination’ options, this will open Android New Component Dialog where we can create a new Fragment.

For this example, we’ll have two fragments namely — SignupFragment and LoginFragment. After creating these Fragments, click on the fragment and attach it to the other one. The navigation graph should look something like this —

navigation.xml will look something like this for the above Navigation Graph-

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/navigation_graph"
    app:startDestination="@id/signupFragment3">
    <fragment
        android:id="@+id/signupFragment3"
        android:name="com.navigation.view.SignupFragment"
        android:label="fragment_signup"
        tools:layout="@layout/fragment_signup" >
        <action
            android:id="@+id/action_signupFragment3_to_loginFragment3"
            app:destination="@id/loginFragment3" />
    </fragment>
    <fragment
        android:id="@+id/loginFragment3"
        android:name="com.navigation.view.LoginFragment"
        android:label="fragment_login"
        tools:layout="@layout/fragment_login" >
        <action
            android:id="@+id/action_loginFragment3_to_signupFragment3"
            app:destination="@id/signupFragment3" />
    </fragment>
</navigation>

Here the root tag will be navigation with startDestination attribute in which we mention the id of the fragment to be loaded initially followed by destinations, like fragments, dialogs and so on, with one of the attributes name, whose value will be the name of your destination.

Now we come to the navigation. We use a tag action under a specific destination — where we want to initiate the navigation. There’s also an attribute in which we mention the destination ID.

The SignupFragment layout will have two Buttons (with id’s as — signupBtn and gotoLoginBtn) and three EditText( with id — signupUsername, signupPassword, otherInfo).

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    gotoLoginBtn.setOnClickListener { onGotoLogin(it)

}

private fun onGotoLogin(v: View) {
    val action = SignupFragmentDirections.actionGoToLogin()
    Navigation.findNavController(v).navigate(action)
}

Type safe dependency will generate class in the format of name_of_file_Directions (In our case source fragment SignupFragmentDirections) which consists the <action></action> in navigation file (navigation).

Now we will try to create a Navigation Graph with multiple actions. Let me show you how the navigation graph will look with three fragments and multiple actions.

Now let’s take a look at the XML code in the navigation tab to create a graph like above:

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/navigation"
    app:startDestination="@id/signupFragment">

<fragment
        android:id="@+id/signupFragment"
        android:name="com.navigation.view.SignupFragment"
        android:label="fragment_signup"
        tools:layout="@layout/fragment_signup">
        <action
            android:id="@+id/actionGoToMain"
            app:destination="@id/mainFragment" />
        <action
            android:id="@+id/actionGoToLogin"
            app:destination="@id/loginFragment" />
    </fragment>
    <fragment
        android:id="@+id/loginFragment"
        android:name="com.navigation.view.LoginFragment"
        android:label="fragment_login"
        tools:layout="@layout/fragment_login">
        <action
            android:id="@+id/actionGoToMain"
            app:destination="@id/mainFragment" />
        <action
            android:id="@+id/actionGoToSignup"
            app:destination="@id/signupFragment" />
    </fragment>
    <fragment
        android:id="@+id/mainFragment"
        android:name="com.navigation.view.MainFragment"
        android:label="fragment_main"
        tools:layout="@layout/fragment_main">
        <action
            android:id="@+id/actionGoToSignup"
            app:destination="@id/signupFragment" />
    </fragment>
</navigation>

That’s it. Basic navigation is implemented in your app. You will be able to navigate to the LoginFragment with this.

Now as we have learned Basic implementation we will see how to implement Navigation With Arguments:

We can achieve this in two possible ways.

1. Using bundles
2. Using SafeArgs

Here I’ll implement it in both the ways and will also explain how passing data with SafeArgs is better than passing data through bundles.

Using Bundles: Pass data from the source fragment by getting the nav controller of view as

val bundle = bundleOf("username" to signupUsername.text.toString())
Navigation.findNavController(signupUsername).navigate(R.id.actionGoToMain, bundle)

bundleOf() is the extension method of androidx. For that, we need to add below dependency in the app-level build.gradle file:

implementation 'androidx.core:core-ktx:1.3.0-rc01'

Receive data in destination fragment as :

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

signoutBtn.setOnClickListener { onSignout() }
    usernameTV.text = "Hello "+ arguments?.getString("username")

observeViewModel()
}

This is how we achieve passing data through a bundle from one fragment to another. However, I’m sure this question must be popping up in your mind that if we can easily pass data through Bundle then why do we need SafeArgs? Why should we use it?

I agree that we can pass data through Bundle but Sometimes what happens is we try to get data in a destination that has never passed in as extra params of a bundle which causes the null pointer exception in runtime. To avoid this problem, architecture components provide a type-safe way.

How to use Safe Arguments for passing data-

As we have safe args plugin active in our project, let’s see how to use it.

First, mention the arguments required for the destination in navigation.xml, as shown below:

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/navigation"
    app:startDestination="@id/signupFragment">

<fragment
        android:id="@+id/signupFragment"
        android:name="com.navigation.view.SignupFragment"
        android:label="fragment_signup"
        tools:layout="@layout/fragment_signup">
        <action
            android:id="@+id/actionGoToMain"
            app:destination="@id/mainFragment" />
        <action
            android:id="@+id/actionGoToLogin"
            app:destination="@id/loginFragment" />
    </fragment>
    <fragment
        android:id="@+id/mainFragment"
        android:name="com.navigation.view.MainFragment"
        android:label="fragment_main"
        tools:layout="@layout/fragment_main">
        <argument
           android:name="username"
           app:argType="string"
           android:defaultValue="default"/>
        <action
            android:id="@+id/actionGoToSignup"
            app:destination="@id/signupFragment" />
    </fragment>
</navigation>

We send data as from source fragment as :

super.onViewCreated(view, savedInstanceState)
    signupBtn.setOnClickListener { onSignup() }
}

private fun onSignUp(){
val action = SignupFragmentDirections.actionGoToMain(signupUsername.text.toString())
Navigation.findNavController(signupUsername).navigate(action)
}

Receive data as in destination fragment as:

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

signoutBtn.setOnClickListener { onSignout() }
    deleteUserBtn.setOnClickListener { onDelete() }
    
    usernameTV.text = "Hello "+ MainFragmentArgs.fromBundle(requireArguments()).username

}

Type safe dependency will generate class in the format of name_of_file_Args (In our case destination fragment MainFragmentArgs) which consists the <arguments></arguments> in navigation file (navigation).

Yayyy!! And we are good to go.

You can also add Actions and Deep Links through the navigation graph.

Navigation With Deeplink:

In Android, a deep link is a link that takes you directly to a specific destination within an app. To add deep-link, click on the + icon in the Argument panel from the Deep Link section. In the Add deep link dialog, enter the URI.

That’s all folks!! Enjoy coding.

To see the complete project, do visit the GitHub link :

https://github.com/ashitaasati1608/NaviagtionComponent