29.
Keeping Your App Up to Date
Written by Darryl Bayliss
Heads up... You're reading this book for free, with parts of this chapter shown beyond this point as text.
Building a great app requires hard work and determination. Continually updating your app requires not just a firm belief in the original vision, but the discipline to evolve your app as time passes.
Overnight success is a rare thing. Instead, it’s more likely that a trickle of users will download your app, some will uninstall it a few minutes later and a small few will genuinely find your app useful and use it regularly, perhaps even leaving reviews.
This last group contains the users to which you owe your attention and commitment.
The more you commit to your app, the more value your users will see in the product over time. Keeping your app up-to-date is an incentive for growing that important group of users. Publishing an app is an achievement, but supporting an app over the years to come is a labor of love.
This chapter covers what you need to know when it’s time to update your app, including:
- How to leverage data from Google to target what you should update.
- How to target the latest version of Android, including preview releases.
- How to decide when to drop support for older versions of Android.
Following Android trends
Data that can help you make an informed decision is invaluable in helping you make the most of your development time.
There are two sources you can draw on for high-quality data. The first option is the Google Play Console (https://developer.android.com/distribute/console).
Apart from being a portal for app distribution, the console provides metrics about devices that have downloaded your app. Down to the device type and version of Android your users are running.
You’ll dive deeper into the Google Play Console in the following chapters when you deploy your app to Google Play. What you need to know now is it’s a great source of information to decide how to keep your app up-to-date.
If you require less targeted data and prefer a snapshot of the whole distribution of Android devices in the world, Google offers a few dashboards at (https://developer.android.com/about/dashboards/index.html) that detail key metrics:
- Screen size and density.
- Vulkan versions.
- OpenGL versions.
Google generates the information from devices that visit the Google Play Store within the last seven days. You can rely on the dashboards to provide an accurate portrait of Android within the Google ecosystem.
Screen size and density
The screen size and density data show the distribution of devices with a particular screen size. This is useful to know to help decide what devices to focus on. By making decisions on screen sizes, you can shed unneeded assets and keep your APK size slim.
Vulkan Versions
The Vulkan version data shows the distribution of devices supporting different versions of Vulkan. Vulkan is an API designed for creating 3D apps like games and interactive media. It’s considered to be the next-generation version of OpenGL. If you wanted to build an app using Vulkan, this data will help you decide what versions are supported by devices.
OpenGL versions
OpenGL is a library used in games or graphically intensive apps to render 2D or 3D graphics. It’s incredibly popular due to its portability across platforms.
Managing Android updates
As a good developer, you want your app to run on the latest and greatest version of Android. Major updates to the Android OS occur on a yearly cycle and are announced at Google IO (https://events.google.com/io/), Google’s developer conference, where a range of new products and services across the company are showcased.
Working with older versions of Android
Although there is a lot of support in Android for backward compatibility, sometimes it makes sense to stop supporting old versions of Android and only develop for newer versions. This is a good strategy in some cases, but it comes at a cost.
The bleeding edge approach
The first option is to be ruthless and only support the versions of Android your app needs. This means your app is guaranteed to work, and you don’t need to consider backward compatibility for Android versions that don’t support your target API.
The soft decline approach
The second option is to engineer your app to degrade gracefully for older versions of Android. Newer Android users get the benefit of all your app’s features, while older Android users can still use your app with some functional limitations. This means you keep the market open for your app, and you don’t penalize users on older devices.
The backport approach
The third option is to rely on backported features. This involves leveraging third-party libraries or code you write yourself to support features that older devices wouldn’t normally have. This is the argument Google uses for persuading developers to use the AndroidX Libraries. Many third-party libraries backport their features for the very same reason. The benefits of supporting as many Android users as possible can’t be overstated.
Key Points
Keeping your app up to date is a natural part of building a great app. Your users will expect this of you, and failing to do so could lose that vital userbase an app needs. In this chapter, you learnt:
Where to go from here?
The decision to drop older versions of Android, or to invest the time to support them, depends entirely on the kind of app you make. What your user base looks like and the amount of effort you want to put into app development.