Update code in android

Exploring in-app updates on Android

This was originally posted on joebirch.co:

Exploring in-app updates on Android

I’m sure there has often been a time when you’ve needed to send out an app update that has some form of urgency — maybe…

I’m sure there has often been a time when you’ve needed to send out an app update that has some form of urgency — maybe there’s a security issue or some bug which is causing a lot of issues for users. Previously, we’ve needed to roll out a new update on the Google play store and wait for our users to receive the update. And if they don’t have automatic updates installed, we rely on the user visiting the play store to update our application. At Google I/O this week we saw the announcement of In-App Updates for the Play Core library. In this post we’re going to learn more about this addition and how we can make use of it in our applications.

Supporting API level 21 and above, the Play Core library now allows us to offer in-app updates to our users — meaning we can show that an app update is available whilst the user is within the context of our application. 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.

The Flexible approach shows the user an upgrade dialog but performs the downloading of the update within the background. This means that the user can continue using our app whilst the update is being downloaded. For more crucial application updates we can make use of the Immediate flow — this is where a blocking UI is used to prompt the user to update the application, disallowing continued use until the app has been updated and restarted.

Checking an update is available

Before we can get started with either of these, we’re going to begin by checking whether there is an update that is available from the play store. The code for doing this looks like so:

We begin by creating an instance of the AppUpdateManager class — this will be responsible for handling the information around our application information. Using this, we’re going to fetch an AppUpdateInfo instance — this needs to make a remote request to do so, which is why you can see us accessing the result property above. This AppUpdateInfo contains a collection of data that can be used to determine whether we should trigger the update flow.

To begin with, it has a method availableVersionCode() — if there is an update that is either currently available or in progress of being updated, this will return that version value. As well as this, there is also an updateAvailability() method which returns a value that represents the update state. This can be either:

• UNKNOWN
• UPDATE_AVAILABLE
• UPDATE_IN_PROGRESS
• DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS

We first want to check that this is equal to UPDATE_AVAILABLE, followed by ensuring that the desired update type is supported by using the isUpdateTypeAllowed() function — passing in AppUpdateType type (either IMMEDIATE or FLEXIBLE) to ensure that the update type we want to use is supported.

Now that we have the information we need to determine whether or not an app update is available, we’re going to want to trigger the update flow. We can do this by making use of the startUpdateFlowForResult() method that comes with the AppUpdateManager class. When we call this we just need to pass:

• The AppUpdateInfo instance that we previously retrieved
• The AppUpdateType that we want to trigger (IMMEDIATE or FLEXIBLE)
• The context for the current component
• A request code so that cancellations / failures can be caught within the calling component

Calling this startUpdateFlowForResult() method will trigger a startActivityForResult() call and kick off the app update flow. In some cases, the request app update may be cancelled by the user (ActivityResult. RESULT_CANCELLED), or even fail (ActivityResult. RESULT_IN_APP_UPDATE_FAILED). In these cases we can catch the result in the onActivityResult() of our activity / fragment and handle the result accordingly.

Immediate in-app updates

Immediate in-app updates can be triggered by using the AppUpdateType.IMMEDIATE value — and as previously mentioned, this will trigger a blocking UI flow for the user until they have updated the app. This means that this UI will be shown during the entire time that the app is downloading and then installing, until the entire update process has completed. When the user leaves your app whilst the update is in process, the update will continue to download and then install in the background. However, if the user leaves and then returns to your app before the update process has completed, then you will need to ensure that we continue the update process.

For this we need to check whether or not the updateAvailability() returns the DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS state. If so then we need to trigger the update flow so that the update process can be resumed. If you do not implement this part of the flow then the user will be able to continue using your application without the immediate update in-effect.

For immediate updates we are not required to do any further work. The implementation will automatically restart our app once the update is downloaded, this is so that the update can be installed.

Flexible in-app updates

Flexible in-app updates can be triggered by using the AppUpdateType.FLEXIBLE value — and as previously mentioned, this will trigger a flow that displays an upgrade pop-up to the user and perform a download / install of the update in the background whilst the user can continue to use the application.

For this, we begin by launching the app update flow for a FLEXIBLE update:

Because this is all happening in the background, rather than creating a blocking UI like the immediate update, we need to add some monitoring so that we can keep a check on the state of the update install. For this we’re going to make use of the InstallStateUpdatedListener which will receive callbacks when the state of the flexible install changes. This contains a single callback, onStateUpdated(), which will pass us an instance of the InstallState class. From this we can make use of:

installStatus() — returns us a InstallStatus value that represents the current state of the update. This can be one of:

• UNKNOWN
• REQUIRES_UI_INTENT
• PENDING
• DOWNLOADING
• DOWNLOADED
• INSTALLING
• INSTALLED
• FAILED
• CANCELLED

installErrorCode() — returns us an InstallErrorCode that represents the error state of the install

• NO_ERROR
• NO_ERROR_PARTIALLY_ALLOWED
• ERROR_UNKOWN
• ERROR_API_NOT_AVAILABLE
• ERROR_INVALID_REQUEST
• ERROR_INSTALL_UNAVAILABLE
• ERROR_INSTALL_NOT_ALLOWED
• ERROR_DOWNLOAD_NOT_PRESENT
• ERROR_INTERNAL_ERROR

packageName() — returns us the package name that the install status applies to

Whilst there are a lot of options here for both the install status and the install error code, this gives us a lot of flexibility when it comes to handling the status. For example, if we are showing the user some specific UI to notify them of the current state, then we can customise the content within this based on the current status.

We can also have our activity implement this interface so that the callback can be overriden within the activity itself.

Now that we have the listener, we can register it with out AppUpdateManager instance using the registerListener() method. When finished with listener, we need to be sure to make use of the unregisterListener() method to remove any callbacks being triggered when they are no longer required.

Once we detect that the InstallStatus represents the DOWNLOADED state, we are required to restart the app so that the update can be installed. Whilst the immediate update method handles this for you, in the case of the flexible update we need to manually trigger this. In order to manually trigger this update we need to make use of the completeUpdate() method from our AppUpdateManager instance. When this is called, a full-screen UI will be displayed from the play core library and the app will be restarted in the background so that the update can be installed. The app will then be restarted with the update applied.

When this is called from the background, the app will still be updated but no fullscreen UI will be displayed and the app will not be relaunched once the update has been completed.

However, if the update is being carried out when the app is in the foreground then there is a chance that the user will leave and return to our app before the update has been downloaded and installed. In this case, when our activity hit onResume() we’re going to want to check the status from our AppUpdateManager so that we can determine if we need to complete the update process. We can determine this by checking if the InstallStatus is in a DOWNLOADED state. If so, we can go ahead and call the completeUpdate() method to finish the update process.

From this article we’ve learnt about the new approach to in-app updates that is provided by the play core library. I’m excited to use this in the applications that I work on and I really believe that this will greatly improve a range of experiences for both our users and developers when it comes to android application development. If you have any questions about the play core library or in-app updates then please do reach out.

In my next article i’ll be talking about the CameraX Jetpack library on Android. Follow me on Twitter to keep updated as to when this is released!

Источник

Android Application In-App Update Using Android Studio

December 30, 2020

As developers, we always want users to update their applications to the latest version quickly. We want everyone to use the latest features included in the updates. Google notifies Android users whenever updates are available for certain applications. However, this is mainly for users who have enabled the auto-update feature. It is, therefore, important for users to know when your application has a new update available.

Introduction

Suppose a user has your application installed on their mobile phone. Yet, you have added new critical features or fixed a bug to the app. The only way the user can access these functionalities is by updating the application. Some users lack the interest or time to open the Google Play store and update their applications. This means that they will take time before switching to the latest version.

To solve this problem, Google I/O introduced an in-app update API. This API alerts users whenever you have a new version on the Google Play store. The API introduces an update UI within your application to notify users to update to the newly available application version. Users do not have to open the Google Play store to initiate the update.

In this guide, we will learn about Google’s in-app updates and implement them in our applications. We will discuss the two methods to implement in-app updates: immediate and flexible.

Immediate

The immediate update introduces a blocking full-screen UI . When a user starts the update, he/she can’t use the application until the update is installed. The app will automatically restart when the update is completed. This method is preferred when the update introduces critical functionalities.

Flexible

A flexible update allows users to interact with the application while the update occurs in the background. Once the update is downloaded, the app will prompt the user to restart the application. The application will then install the update and open the app to the foreground. It is preferred when the update has minor changes that do not affect the application’s critical functionalities.

Prerequisites

This guide assumes you have prior knowledge of Android application development using Android Studio and Java.

To carry out testing, you will need:

• A Google Play Console account.
• An application already published in the Google Play store.

Requirements

• A device running Android 5.0 (API level 21) or higher.
• Google Play Core Library version 1.5.0 or higher.

Implementation

Add the following library on your app.gradle file.

Sync to download the library.

At the time of writing this guide, the Google Play Core version was 1.8.3 . It is recommended to have the latest version. Check for the latest version here.

Background

Setting the in-app update is simple. The Google Core API implements all major functionalities. A user does not have to activate auto-updates in the Google Play store. The API will handle the update flow in any application that has implemented this in-app update concept.

Before handling the update type, either flexible or immediate, you should understand how the API works. Let’s discuss some of the key classes and functions that help us to trigger an update flow.

To check if there is an update available in the Google Play store, we have to create an instance of appUpdateManager. It communicates with the AppUpdateInfo object. The object triggers a remote communication with the Google Play store. It holds the property results and status of any available update. The result is a collection of data for the update availability, such as the available app version. The data will then be used to determine whether the API should initiate the update flow.

AppUpdateInfo has the following methods:

updateAvailability() processes the following:

UPDATE_AVAILABLE : This checks whether an application has a new version available in the Google Play store.

DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS : This handles a case where a user-initiated the update process but closed the application while the update was in progress. updateAvailability() will return the state of the update progress.

installStatus() returns the value of the update milestone. installStatus() is an instance of installStateUpdatedListener hooked to the appUpdateManager . It returns the values of the update status, such as:

DOWNLOADED : When the user hits the update, the application will first download the APK. installStatus() sets the action that should be done when the APK has been downloaded.

INSTALLED — installStatus() sets the action when the newly available update has been installed.

To trigger the update flow, we first check the updateAvailability() to determine if there is an update available. The returned value should be UPDATE_AVAILABLE if the developer has pushed new features.

Next, we will validate whether the update type is allowed with the function isUpdateTypeAllowed() and pass AppUpdateType , which can be IMMEDIATE or FLEXIBLE .

We have determined whether an update is available or not (the state of the available update). If the update type is allowed, appUpdateManager will return the update status from the AppUpdateInfo values and trigger the update flow with startUpdateFlowForResult .

We pass the following parameters to startUpdateFlowForResult to start the update flow UI:

• The appUpdateInfo that we previously fetched from the Google Play store.
• The updated flow that we want to trigger. Previously passed to isUpdateTypeAllowed as AppUpdateType that can be IMMEDIATE or FLEXIBLE .
• The execution context in the current activity.
• A request code to catch Onactivity results such as: — If a user canceled the update. — If the update is OK. — If the update flow failed.

With that, we are ready to complete the update with completeUpdate() .

Implementing flexible update flow

This flow does not block a user from interacting with the application. When the update is available, the user downloads the update APK, which occurs in the background. When the download is complete, the user will be prompted to install the newly downloaded application to bring the new updates on board.

Let’s handle the flow.

Before we check this, make sure you implement the update flow on your main launch application page—for example, a log-in activity. This will make sure that a user is alerted as soon they open the application.

An instance of AppUpdateManager

Create an instance of AppUpdateManager . Go ahead and declare AppUpdateManager right above onCreate .

Below onCreate , create the instance.

Check for the update

To implement the update flow, you need to check whether there is an updated application version in the Google Play store.

Create a function checkUpdate() and call it in the onCreate .

Here is what the function does:

It communicates with the Play store to check if an update is available.

• The update availability for the current application,
• An intent to start an update flow,
• And, if applicable, the state of updates currently in progress.

Register a listener to communicate with the appUpdateInfoTask . If the conditions check that UPDATE_AVAILABLE is true , check whether the update is allowed and set the update mode to FLEXIBLE . If these conditions are met, we will start the update flow with startUpdateFlow(appUpdateInfo) (we will look into this later).

In this case, our update mode is set to Flexible. The update is downloaded in the background. We then need to check the install status. If the status shows that the app is DOWNLOADED , we need to notify the user that the download has been completed. You can choose to use a Snackbar or an AlertDialog . In this tutorial, we will use a Snackbar .

Create a function named popupSnackBarForCompleteUpdate(). This method will be called when the installStatus() is equal to DOWNLOADED . The UI will react by nudging the user to install the downloaded APK.

Remember to press alt + enter on a PC and option + enter on a Mac to import the classes after copying and pasting the code blocks into your IDE.

Handling the update flow

Now create the startUpdateFlow(appUpdateInfo) function we passed above.

We have checked whether the update is available or not. We have also confirmed that the updated platform is supported, and we are, therefore, ready to request the update.

startUpdateFlowForResult() will request the update from AppUpdateInfo that holds the update information. To ensure the update flow kick-off as expected, we pass some parameters to startUpdateFlowForResult . They include:

AppUpdateType — the mode of the update flow we want to perform. In this case, we have set that to FLEXIBLE .

this — the execution context of the current activity requesting the update.

FLEXIBLE_APP_UPDATE_REQ_CODE — a request code that handles user actions onActivityResult . Make sure you declare FLEXIBLE_APP_UPDATE_REQ_CODE right above onCreate , as shown below.

Handling user actions

We need to handle onActivityResult to check the user’s action, such as instances where the update is canceled or has failed. FLEXIBLE_APP_UPDATE_REQ_CODE monitors the update request as implemented in the code below.

From the above code, there are several results:

• If a user canceled the installation, you could call checkUpdate() to restart the update flow.

You can do many things here, such as:

1. Popping up a dialog to inform the user that they need to update the application.
2. Inform them of the new features or the bugs that the update will fix.

If the user agrees, you can call checkUpdate() to reinitiate the update flow. You can also decide to close the application with finish() . Otherwise, do nothing and continue with the normal application flow.

RESULT_OK — shows that the update was successful. We can’t assign any action to it, as our goal is met. But you can choose to show a message to the user to thank them for taking the time to update the application to the latest version.

If the update failed, this could be an error such as poor internet connection. Request the update again by calling checkUpdate() to restart the update process.

Monitoring the update flow

As mentioned earlier, a flexible update flow occurs in the background. We need to monitor the update flow to know when the application download is complete and initiate an install process.

To do this, we need to register a listener to get the status of the update. The listener informs the app of every step in the update process.

Declare the listener.

Add the following code just below the appUpdateManager instance created inside the onCreate method.

The above code tracks down the update status.

• If the status is equal to DOWNLOADED , launch a snack bar to instruct the user to install the downloaded update.
• If the status is equal to INSTALLED , unregister the listener. When the update is installed, there is no need to register a listener anymore.

Complete the update flow

Since we have the download ready, it’s time to set the snack bar’s action. Create a function popupSnackBarForCompleteUpdate() .

This notifies the user that the update APK is downloaded and ready to be installed. When the user clicks Install , the appUpdateManager automatically installs the downloaded APK. This will bring the newly updated features onboard.

Unregister the listener

We have now achieved the update installation. We don’t need the installStateUpdatedListener anymore.

To unregister it, create a function removeInstallStateUpdateListener() and call it when installStatus() is equal to INSTALLED .

This prevents the callbacks from being triggered when they are no longer required. Unregistering the listener also helps to avoid memory leaks.

Implementing immediate updates

When the AppUpdateType is set to IMMEDIATE , appUpdateManager initiates a blocking UI . It blocks the user from interacting with the application until the update is complete.

Immediate updates are similar to the flow of events discussed while implementing the flexible mode. To avoid repeating the detailed explanation we have done above, we will state the update flow that implements an immediate update.

Create an instance of appUpdateManager

Check for the update

Create a checkUpdate() function and call it the onCreate .

The app will communicate with the play store and check whether the update is available.

If the update is available, check whether the update type is allowed. In this case, we are checking if the IMMEDIATE mode is allowed to start the update flow. If yes, we call startUpdateFlow(appUpdateInfo) .

If the user initiated the update and closed the app before the process was over, set the UpdateAvailability to DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS . The user can resume the update process by initiating startUpateFlow(appUpdateInfo) .

Handling the update flow

Initiate the update flow and set the AppUpdateType to IMMEDIATE in the current activity context. Again, remember to pass a result code that will track the user’s actions, such as canceling the update.

Handling user action

OnActivityResult handles the action a user takes when prompted to install an update. This is comprised of three main actions, including:

• RESULT_CANCELED — when a user cancels an update, you may choose an action that follows that decision. checkUpdate() to force the application to restart the update. Or call finish() to close the application whenever the user cancels an update.
• RESULT_OK — shows that a user has accepted the update to be installed.
• RESULT_IN_APP_UPDATE_FAILED — If an update fails with an error, you would want the app to reinitiate the update flow again. For that reason, call checkUpdate() , and the update flow will start again.

Testing

Testing an in-app update is not straightforward. It can be a little tricky to perform a test.

How to test

Generate a signed app bundle/APK. Note that the APK signing key and the applicationId should be the same as the already published application.

Share the generated APK with a tester. To do that, select the published application in the Google console, navigate to Internal App Sharing , and upload the generated APK there. Check how to use Google Internal App Sharing.

Copy the upload’s shareable link and share it with a tester. In this case, the tester should have an Android mobile phone.

Open the shared link on the phone’s browser. You will be redirected to the Play store.

Download the app and wait for the installation to complete.

Once done, generate another signed app bundle/APK. This time change versionCode and versionName in your app.gradle file to a higher version. If, for example, in the first generated APK, the values were:

Change these values to a higher version. For example:

To be sure that the update will take place, on your activity.xml replace android:text=»Hello World!» with android:text=»Congratulations, you now have the newest version of this app installed.» .

Once you have generated the app bundle/APK, head to App Internal Sharing and upload it.

Again, copy the shareable link generated by this upload and open it with the tester. When the link launches on the Google Play store, you will get an update button, do not click update.

Close the Google Play store and open the application we installed earlier. This will launch an update UI that will prompt you to update the application. The UI may differ depending on your update type (either flexible or immediate).

Code setup and output

Flexible

Immediate

Conclusion

I hope this guide helps you implement in-app updates, both immediate and flexible, within your application context.

Peer Review Contributions by: Michael Barasa

About the author

Joseph Chege is an undergraduate student taking a Bachelor in Business Information Technology, a 4th-year student at Dedan Kimathi University of Technology. Joseph is fluent in Android Mobile Application Development and has a lot of passion for back-end development.

Want to learn more about the EngEd Program?

Discover Section’s community-generated pool of resources from the next generation of engineers.

Источник