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. 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 an even greater achievement.
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. This includes 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 is that it can be a great source of information when deciding on how best 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:
- Android versions.
- Screen size and density.
- OpenGL versions.
Google generates this information from devices that visited the Google Play Store within the last seven days, so you can rely on the dashboards to provide an accurate portrait of Android within the Google ecosystem.
Android versions
Choosing the right platform to target can lead to building simpler apps since you’re not preoccupied trying to backport features or trying to fallback gracefully for Android versions that don’t support your app’s features.
Screen size and density
Understanding the most common screen sizes and densities can help you decide to focus on the sizes users are using most. Keeping up with the latest trends here can help you shed unneeded assets and keep your APK size slim.
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 to make sure your app runs 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 the 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 that your app needs. This means your app is guaranteed to work, and you don’t need to consider any backward compatibility for Android versions that don’t support your target API.
The soft decline approach
The second option is to engineer your app so that it degrades 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 support 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, and 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.
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.