page.title=Building for Billions
page.metaDescription=Best practices on how to optimize Android apps for low- and no-bandwidth and low-cost devices.
page.image=/distribute/images/billions-guidelines.png
@jd:body
<!-- table of contents -->
<div id="qv-wrapper"><div id="qv">
<h2><a href="#connectivity">Connectivity</a></h2>
<ol>
<li><a href="#images">Optimize images</a></li>
<li><a href="#network">Optimize networking</a></li>
<li><a href="#transfer">Fine-tune data transfer</a></li>
</ol>
<h2><a href="#capability">Device Capability</a></h2>
<ol>
<li><a href="#screens">Support varying screen sizes</a></li>
<li><a href="#compatibility">Backward compatibility</a></li>
<li><a href="#memory">Efficient memory usage</a></li>
</ol>
<h2><a href="#cost">Data Cost</a></h2>
<ol>
<li><a href="#appsize">Reduce app size</a></li>
<li><a href="#configurablenetwork">Offer configurable network usage</a></li>
</ol>
<h2><a href="#consumption">Battery Consumption</a></h2>
<ol>
<li><a href="#consumption-reduce">Reduce battery consumption</a></li>
<li><a href="#consumption-benchmark">Benchmark battery usage</a></li>
</ol>
<h2><a href="#contentsection">Content</a></h2>
<ol>
<li><a href="#content-responsive">Fast and responsive UI</a></li>
<li><a href="#ui">UI Best practices</a></li>
<li><a href="#localization">Localization</a></li>
</ol>
</div>
</div>
<!-- intro -->
<p>Internet use—and smartphone penetration—is growing fastest in markets with
low, intermittent, or expensive connectivity. Successful apps in these
markets need to perform across a variety of speeds and devices, as well as
conserve and share information about battery and data consumption.</p>
<p>To help you address these important considerations, we’ve compiled the
following checklist. These do not follow a particular order, and as
always it's a good idea to research particularities of any market or country
you're targeting.
</p>
<!-- connectivity -->
<div class="headerLine">
<h2 id="connectivity">Connectivity</h2>
</div>
<p>Over half of the users in the world still experience your app over 2G
connections. To improve their experience, optimize for no- and low-connection
speeds. For offline and slow connections: store data, queue requests, and handle
images for optimal performance.
</p>
<h3 id="images">Optimize images</h3>
<h4 id="images-format">Serve WebP images</h4>
<ul>
<li>Serve <a
href="https://developers.google.com/speed/webp/">WebP</a> files over the
network. WebP reduces image load times, saves network bandwidth, and often
results in smaller file sizes than its PNG and JPG counterparts, with at
least the same image quality. Even at lossy settings, WebP can produce a
nearly identical image. Android has had lossy <a
href="{@docRoot}guide/appendix/media-formats.html">WebP support</a> since
Android 4.0 (API level 14: Ice Cream Sandwich) and support for lossless /
transparent WebP since Android 4.2 (API level 17: Jelly Bean).</li>
</ul>
<h4 id="images-sizing">Dynamic image sizing</h4>
<ul>
<li>Have your apps request images at the targeted rendering size, and have
your server provide those images to fit; the target rendering size will
vary based on device specifications. Doing this minimizes the network
overhead and reduces the amount of memory needed to hold each image,
resulting in improved performance and user satisfaction.</li>
<li>Your user experience degrades when users are waiting for images to
download. Using appropriate image sizes helps to address these issues.
Consider making image size requests based on network type or network
quality; this size could be smaller than the target rendering size.</li>
<li>Dynamic placeholders like <a
href="{@docRoot}reference/android/support/v7/graphics/Palette.html">
pre-computed palette values</a> or low-resolution thumbnails can improve
the user experience while the image is being fetched.</li>
</ul>
<h4 id="images-libraries">Use image loading libraries</h4>
<ul>
<li>Your app should not have to fetch any image more than once. Image
loading libraries such as <a class="external-link"
href="https://github.com/bumptech/glide">Glide</a> and <a
class="external-link" href="http://square.github.io/picasso/">Picasso</a>
fetch the image, cache it, and provide hooks into your Views to show
placeholder images until the actual images are ready. Because images are
cached, these libraries return the local copy the next time they are
requested.</li>
<li>Image-loading libraries manage their cache, holding onto the most recent
images so that your app storage doesn’t grow indefinitely.</li>
</ul>
<h3 id="network">Optimize networking</h3>
<h4 id="network-offline">Make your app usable offline</h4>
<ul>
<li>In places like subways, planes, elevators, and parking garages, it is
common for devices to lose network connectivity. Creating a useful offline
state results in users being able to interact with the app at all times, by
presenting cached information. Ensure that your app is usable offline or
when network connectivity is poor by storing data locally, caching data,
and queuing outbound requests for when connectivity is restored.</li>
<li>Where possible, apps should not notify users that connectivity has
been lost. It is only when the user performs an operation where connectivity
is essential that the user needs to be notified.</li>
<li>When a device lacks connectivity, your app should batch up network
requests—on behalf of the user—that can be executed when
connectivity is restored. An example of this is an email client that allows
users to compose, send, read, move, and delete existing mails even when the
device is offline. These operations can be cached and executed when
connectivity is restored. In doing so, the app is able to provide a similar
user experience whether the device is online or offline.</li>
</ul>
<h4 id="network-arch">Use GcmNetworkManager and/or Content Providers</h4>
<ul>
<li>Ensure that your app stores all data on disk via a database or similar
structure so that it performs optimally regardless of network conditions
(for example, via SQLite + ContentProvider). The <a
href="https://developers.google.com/cloud-messaging/network-manager">
GCM Network Manager</a>
(<a href="https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmNetworkManager">
<code>GcmNetworkManager</code></a>) can result in a robust mechanism to
sync data with servers while <a
href="{@docRoot}guide/topics/providers/content-providers.html">content
providers</a> ({@link android.content.ContentProvider}) cache that data,
combining to provide an architecture that enables a useful offline state.</li>
<li>Apps should cache content that is fetched from the network. Before making
subsequent requests, apps should display locally cached data. This ensures
that the app is functional regardless of whether the device is offline or
on a slow/unreliable network.</li>
</ul>
<h4 id="network-duplicate">Deduplicate network requests</h4>
<ul>
<li>An offline-first architecture initially tries to fetch data from local
storage and, failing that, requests the data from the network. After being
retrieved from the network, the data is cached locally for future
retrieval. This helps to ensure that network requests for the same piece of
data only occur once—the rest of the requests are satisfied locally. To
achieve this, use a local database for long-lived data (usually
{@link android.database.sqlite} or
{@link android.content.SharedPreferences}).</li>
<li>An offline-first architecture always looks for data locally first, then
makes the request over the network. The response is cached and then returned
locally. Such an architecture simplifies an app’s flow between offline and
online states as one side fetches from the network to the cache, while the
other retrieves data from the cache to present to the user.</li>
<li>For transitory data, use a bounded disk cache such as a <a class="external-link"
href="https://github.com/JakeWharton/DiskLruCache"><code>DiskLruCache</code>
</a>. Data that doesn’t typically change should only be requested once over
the network and cached for future use. Examples of such data are images and
non-temporal documents like news articles or social posts.</li>
</ul>
<h3 id="transfer">Fine-tune data transfer</h3>
<h4 id="transfer-prioritize">Prioritize bandwidth</h4>
<ul>
<li>Writers of apps should not assume that any network that the device is
connected to is long-lasting or reliable. For this reason, apps should
prioritize network requests to display the most useful information to the
user as soon as possible.</li>
<li>Presenting users with visible and relevant information immediately is a
better user experience than making them wait for information that might not
be necessary. This reduces the time that the user has to wait and
increases the usefulness of the app on slow networks.</li>
<li>To achieve this, sequence your network requests such that text is
fetched before rich media. Text requests tend to be smaller, compress
better, and hence transfer faster, meaning that your app can display useful
content quickly. For more information on managing network requests, visit
the Android training on <a
href="{@docRoot}training/basics/network-ops/managing.html">Managing Network
Usage</a>.</li>
</ul>
<h4 id="network-bandwidth">Use less bandwidth on slower connections</h4>
<ul>
<li>The ability for your app to transfer data in a timely fashion is
dependent on the network connection. Detecting the quality of the network
and adjusting the way your app uses it can help provide an excellent user
experience.</li>
<li>You can use the following methods to detect the underlying network
quality. Using the data from these methods, your app should tailor its use
of the network to continue to provide a timely response to user actions:
<ul>
<li>{@link android.net.ConnectivityManager}>
{@link android.net.ConnectivityManager#isActiveNetworkMetered}</li>
<li>{@link android.net.ConnectivityManager}>
{@link android.net.ConnectivityManager#getActiveNetworkInfo}</li>
<li>{@link android.net.ConnectivityManager}>
{@link android.net.ConnectivityManager#getNetworkCapabilities}</li>
<li>{@link android.telephony.TelephonyManager}>
{@link android.telephony.TelephonyManager#getNetworkType}</li>
</ul>
</li>
<li>On slower connections, consider downloading only lower-resolution media
or perhaps none at all. This ensures that your users are still able to use
the app on slow connections. Where you don’t have an image or the image is
still loading, you should always show a placeholder. You can create a
dynamic placeholder by using the <a
href="{@docRoot}tools/support-library/features.html#v7-palette">
Palette library</a> to generate placeholder colors that match the target
image.</li>
<li>Prioritize network requests such that text is fetched before rich media.
Text requests tend to be smaller, compress better, and hence transfer
faster, meaning that your app can display useful content quickly. For more
information on adjusting bandwidth based on network connection, see the
Android training on <a
href="{@docRoot}training/basics/network-ops/managing.html">Managing Network
Usage</a>.</li>
<li>On devices powered by Android 7.0 (API level 24) and higher,
users can turn on the
<strong>Data Saver</strong> setting, which helps minimize data usage. Android 7.0
extends {@link android.net.ConnectivityManager} to detect <strong>Data Saver</strong>
settings. For more information about this feature, see
<a href="/training/basics/network-ops/data-saver.html">Data Saver.</a>
</li>
</ul>
<h4 id="network-behavior">Detect network changes, then change app behavior</h4>
<ul>
<li>Network quality is not static; it changes based on location, network
traffic, and local population density. Apps should detect changes in
network and adjust bandwidth accordingly. By doing so, your app can tailor
the user experience to the network quality. Detect network state using
these methods:
<ul>
<li>{@link android.net.ConnectivityManager}>
{@link android.net.ConnectivityManager#getActiveNetworkInfo}</li>
<li>{@link android.net.ConnectivityManager}>
{@link android.net.ConnectivityManager#getNetworkCapabilities}</li>
<li>{@link android.telephony.TelephonyManager}>
{@link android.telephony.TelephonyManager#getDataState}</li>
</ul>
</li>
<li>As the network quality degrades, scale down the number and size of
requests. As the connection quality improves, you can scale up your
requests to optimal levels.</li>
<li>On higher quality, unmetered networks, consider <a
href="{@docRoot}training/efficient-downloads/efficient-network-access.html#PrefetchData">
prefetching data</a> to make it available ahead of time. From a user
experience standpoint, this might mean that news reader apps only fetch
three articles at a time on 2G but fetch twenty articles at a time on
Wi-Fi. For more information on adjusting app behavior based on network changes,
visit the Android training on <a
href="{@docRoot}training/monitoring-device-state/connectivity-monitoring.html">
Monitoring the Connectivity Status</a>.</li>
<li>The broadcast <a
href="{@docRoot}reference/android/net/ConnectivityManager.html#CONNECTIVITY_ACTION">
<code>CONNECTIVITY_CHANGE</code></a> is sent when a change in network
connectivity occurs. When your app is in the foreground, you can call <a
href="{@docRoot}reference/android/content/Context.html#registerReceiver(android.content.BroadcastReceiver,%20android.content.IntentFilter)">
<code>registerReceiver</code></a> to receive this broadcast. After receiving
the broadcast, you should reevaluate the current network state and adjust
your UI and network usage appropriately. You should not declare this receiver
in your manifest, as that feature is unavailable in Android 7.0 (API level 24)
and higher.
For more information about this and other changes in Android 7.0,
see <a href="/about/versions/nougat/android-7.0-changes.html">
Android 7.0 Changes</a>.</li>
</ul>
<h3 class="rel-resources clearfloat">Related resources</h3>
<div class="resource-widget resource-flow-layout col-13"
data-query="collection:distribute/essentials/billionsquality/connectivity"
data-sortOrder="-timestamp"
data-cardSizes="6x3"
data-maxResults="6"></div>
<!-- capability -->
<div class="headerLine">
<h2 id="capability">Device Capability</h2>
</div>
<p>Reaching new users means supporting an increasing variety of Android
platform versions and device specifications. Optimize for common RAM and
screen sizes and resolutions to improve the user experience. </p>
<h3 id="screens">Support varying screen sizes</h3>
<h4 id="screens-dp">Use density-independent pixels (dp)</h4>
<ul>
<li>Defining layout dimensions with pixels is a problem because different
screens have different pixel densities, so the same number of pixels may
correspond to different physical sizes on different devices. The
density-independent pixel (dp) corresponds to the physical size of a pixel
at 160 dots per inch (mdpi density).</li>
<li>Defining layouts with dp ensures that the physical size of your user
interface is consistent regardless of device. Visit the Android
guide on <a
href="https://developer.android.com/guide/practices/screens_support.html">
Supporting Multiple Screens</a> for best practices using
density-independent pixels.</li>
</ul>
<h4 id="screens-density">Test graphics on ldpi/mdpi screen densities</h4>
<ul>
<li>Ensure that your app layouts work well on low- and medium-density
(ldpi/mdpi) screens because these are <a
href="https://developer.android.com/about/dashboards/index.html#Screens">
common densities</a>, especially in lower-cost devices. Testing on
lower-density screens helps to validate that your layouts are legible on
lower-density screens.</li>
<li>Lower-density screens can result in unclear text where the finer details
aren't visible. The Material Design guidelines describe <a
class="external-link" href="https://www.google.com/design/spec/layout/metrics-keylines.html">
metrics and keylines</a> to ensure that your layouts can scale across
screen densities.</li>
<li>Devices with lower-density screens tend to have lower hardware
specifications. To ensure that your app performs well on these devices,
consider reducing or eliminating heavy loads, such as animations and
transitions. For more information on supporting different densities, see
the Android training on <a
href="https://developer.android.com/training/multiscreen/screendensities.html">
Supporting Different Densities</a>.</li>
</ul>
<h4 id="screens-sizes">Test layouts on small/medium screen sizes</h4>
<ul>
<li>Validate that your layouts scale down by testing on smaller screens. As
screen sizes shrink, be very selective about visible UI elements, because
there is limited space for them.</li>
<li>Devices with smaller screens tend to have lower hardware specifications.
To ensure that your app performs well on these devices, try reducing or
eliminating heavy loads, such as animations or transitions. For more
information on supporting different screen sizes, see the Android
training on <a
href="https://developer.android.com/training/multiscreen/screendensities.html">
Supporting Different Screen Sizes</a>.</li>
</ul>
<h3 id="compatibility">Backward compatibility</h3>
<h4 id="compatibility-sdkversion">Set your targetSdkVersion and minSdkVersion
appropriately</h4>
<ul>
<li>Apps should build and target a recent version of Android to ensure most
current behavior across a broad range of devices; this still provides
backward compatibility to older versions. Here are the best practices for
targeting API levels appropriately:
<ul>
<li><a
href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">
{@code targetSdkVersion}</a> should be the latest version of Android.
Targeting the most recent version ensures that your app inherits newer
runtime behaviors when running newer versions of Android. Be sure to
test your app on newer Android versions when updating the
targetSdkVersion as it can affect app behavior.</li>
<li><a
href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">
{@code minSdkVersion}</a> sets the minimum supported Android version.
Use Android 4.0 (API level 14: Ice Cream Sandwich) or Android 4.1 (API
level 16: Jelly Bean)—these versions give maximum coverage for modern
devices. Setting {@code minSdkVersion} also results in the Android build
tools reporting incorrect use of new APIs that might not be available in
older versions of the platform. By doing so, developers are protected
from inadvertently breaking backward compatibility.</li>
</ul>
</li>
<li>Consult the <a
href="https://developer.android.com/about/dashboards/index.html#Platform">
Android dashboards</a>, the <a class="external-link"
href="https://play.google.com/apps/publish/">Google Play Developer
Console</a> for your app, and industry research in your target markets to
gauge which versions of Android to target, based on your target users.</li>
</ul>
<h4 id="compatibility-libraries">Use the Android Support libraries</h4>
<ul>
<li>Ensure your app provides a consistent experience across OS versions by
using the Google-provided support libraries such as AppCompat and the Design
Support Library. The Android Support Library package is a set of code
libraries that provides backward-compatible versions of Android framework
APIs as well as features that are only available through the library APIs.
</li>
<li>Some of the the highlights include:
<ul>
<li>v4 & v7 support library: Many framework APIs for older versions of
Android such as {@link android.support.v4.view.ViewPager},
{@link android.app.ActionBar},
{@link android.support.v7.widget.RecyclerView}, and
{@link android.support.v7.graphics.Palette}.</li>
<li><a href="{@docRoot}tools/support-library/features.html#design">Design
Support</a> library: APIs to support adding Material Design components
and patterns to your apps.</li>
<li><a href="{@docRoot}tools/support-library/features.html#multidex">
Multidex Support</a> library: provides support for large apps that have
more than 65K methods. This can happen if your app is using many
libraries.</li>
</ul>
</li>
<li>For more information on the available support libraries, see the <a
href="https://developer.android.com/tools/support-library/features.html">
Support Libraries Features</a> section of the Android Developer site.</li>
</ul>
<h4 id="compatibility-playservices">Use Google Play services</h4>
<ul>
<li>Google Play services brings the best of Google APIs independent of
Android platform version. Consider using features from Google Play services
to offer the most streamlined Google experience on Android devices.</li>
<li>Google Play services also include useful APIs such as <a
href="https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmNetworkManager">
<code>GcmNetworkManager</code></a>, which provides much of Android 5.0’s
{@link android.app.job.JobScheduler} API for older versions of Android. </li>
<li>Updates to Google Play services are distributed automatically by the
Google Play Store, and new versions of the client library are delivered
through the Android SDK Manager. </li>
</ul>
<h3 id="memory">Efficient memory usage</h3>
<h4 id="memory-footprint">Reduce memory footprint on low-cost devices</h4>
<ul>
<li>Adjusting your memory footprint dynamically helps to ensure compatibility
across devices with different RAM configurations.</li>
<li>Methods such as {@link android.app.ActivityManager#isLowRamDevice} and
{@link android.app.ActivityManager#getMemoryClass()} help determine memory
constraints at runtime. Based on this information, you can scale down your
memory usage. As an example, you can use lower resolution images on low memory
devices.</li>
<li>For more information on managing your app’s memory, see the Android
training on <a href="{@docRoot}training/articles/memory.html">Managing
Your App's Memory</a>.</li>
</ul>
<h4 id="memory-longprocesses">Avoid long-running processes</h4>
<ul>
<li>Long-running processes stay resident in memory and can result in slowing
down the device. In most situations, your app should wake up for a given
event, process data, and shut down. You should use <a
href="https://developers.google.com/cloud-messaging">Google Cloud Messaging
(GCM)</a> and/or <a
href="https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmNetworkManager">
<code>GcmNetworkManager</code></a> to avoid long running background
services and reduce memory pressure on the user’s device.</li>
</ul>
<h4 id="memory-benchmark">Benchmark memory usage</h4>
<ul>
<li>Android Studio provides memory benchmarking and profiling tools, enabling
you to measure memory usage at run time. Benchmarking your app’s memory
footprint enables you to monitor memory usage over multiple versions of
the app. This can help catch unintentional memory footprint growth. These
tools can be used in the following ways:
<ul>
<li>Use the <a
href="{@docRoot}tools/performance/memory-monitor/index.html">Memory
Monitor</a> tool to find out whether undesirable garbage collection (GC)
event patterns might be causing performance problems.</li>
<li>Run <a
href="{@docRoot}tools/performance/heap-viewer/index.html">Heap Viewer</a>
to identify object types that get or stay allocated unexpectedly or
unnecessarily.</li>
<li>Use <a
href="{@docRoot}tools/performance/allocation-tracker/index.html">
Allocation Tracker</a> to identify where in your code the problem might
be.</li>
</ul>
</li>
<li>For more information on benchmarking memory usage, see the <a
href="{@docRoot}tools/performance/comparison.html">
Memory Profilers</a> tools on the Android Developers site.</li>
</ul>
<h3 class="rel-resources clearfloat">Related resources</h3>
<div class="resource-widget resource-flow-layout col-13"
data-query="collection:distribute/essentials/billionsquality/capability"
data-sortOrder="-timestamp"
data-cardSizes="6x3"
data-maxResults="6"></div>
<!-- cost -->
<div class="headerLine">
<h2 id="cost">Data Cost</h2>
</div>
<p>Data plans in some countries can cost upwards of 10% of monthly income.
Conserve data and give control to optimize user experience. Reduce data
consumption and give users control over your app’s use of data.</p>
<h3 id="appsize">Reduce app size</h3>
<h4 id="appsize-graphics">Reduce APK graphical asset size</h4>
<ul>
<li>Graphical assets are often the largest contributor to the size of the
APK. Optimizing these can result in smaller downloads and thus faster
installation times for users.</li>
<li>For graphical assets like icons, use Scalable Vector Graphics (SVG)
format. SVG images are relatively tiny in size and can be rendered at
runtime to any resolution. The <a
href="{@docRoot}tools/support-library/index.html">Android Support</a>
library provides a backward-compatible implementation for vector resources as
far back as Android 2.1 (API level 7). Get started with vectors with <a
class="external-link"
href="https://medium.com/@chrisbanes/appcompat-v23-2-age-of-the-vectors-91cbafa87c88">
this Medium post</a>. </li>
<li>For non-vector images, like photos, use <a
href="https://developers.google.com/speed/webp/">WebP</a>. WebP reduces
image load times, saves network bandwidth, and is proven to result in
smaller file sizes than its PNG and JPG counterparts, with at least the
same image quality. Even at lossy settings, WebP can produce a nearly
identical image. Android has had lossy WebP support since Android 4.0 (API
level 14: Ice Cream Sandwich) and support for lossless / transparent WebP
since Android 4.2 (API level 17: Jelly Bean).</li>
<li>If you have many large images across multiple densities, consider
using <a href="{@docRoot}google/play/publishing/multiple-apks.html">Multiple
APK support</a> to split your APK by density. This results in builds
targeted for specific densities, meaning users with low-density devices
won’t have to incur the penalty of unused high-density assets.</li>
<li>For more information about reducing APK size, see
<a href="/topic/performance/reduce-apk-size.html">Reduce APK Size</a> and
<a href="/studio/build/shrink-code.html">Shrink Your Code and Resources</a>. In addition, you can
find a detailed guide on reducing APK size in this <a class="external-link"
href="https://medium.com/@wkalicinski/smallerapk-part-4-multi-apk-through-abi-and-density-splits-477083989006">
series of Medium posts</a>.</li>
</ul>
<h4 id="appsize-code">Reduce code size</h4>
<ul>
<li>Be careful about using external libraries because not all libraries are
meant to be used in mobile apps. Ensure that the libraries your app is
using are optimized for mobile use.</li>
<li>Every library in your Android project is adding potentially unused code
to your APK. There are also some libraries that aren’t designed with mobile
development in mind. These libraries can end up contributing to significant
APK bloat.</li>
<li>Consider optimizing your compiled code using a tool such as <a
href="{@docRoot}tools/help/proguard.html">ProGuard</a>. ProGuard identifies
code that isn’t being used and removes it from your APK. Also <a
class="external-link"
href="http://tools.android.com/tech-docs/new-build-system/resource-shrinking">
enable resource shrinking</a> at build time by setting
<code>minifyEnabled=true</code>, <code>shrinkResources=true</code> in
<code>build.gradle</code>—this automatically removes unused resources from
your APK.</li>
<li>When using Google Play services, you should <a
href="{@docRoot}google/play-services/setup.html#add_google_play_services_to_your_project">
selectively include</a> only the necessary APIs into your APK.</li>
<li>For more information on reducing code size in your APK, see the Android
training on how to <a
href="{@docRoot}training/articles/memory.html#DependencyInjection">Avoid
dependency injection frameworks</a>.</li>
</ul>
<h4 id="appsize-external">Allow app to be moved to external (SD) storage</h4>
<ul>
<li>Low-cost devices often come with little on-device storage. Users can
extend this with SD cards; however, apps need to explicitly declare that
they support being installed to external storage before users can move them.
</li>
<li>Allow your app to be installed to external storage using the <a
href="{@docRoot}guide/topics/manifest/manifest-element.html#install"><code>
android:installLocation</code></a> flag in your AndroidManifest. For more
information on enabling your app to be moved to external storage, see the
Android guide on <a
href="{@docRoot}guide/topics/data/install-location.html">App Install
Location</a>.</li>
</ul>
<h4 id="appsize-postinstall">Reduce post-install app disk usage</h4>
<ul>
<li>Keeping your app’s disk usage low means that users are less likely to
uninstall your app when the device is low on free space. When using caches,
it’s important to apply bounds around your caches—this prevents your app’s
disk usage from growing indefinitely. Be sure you put your cached data in
{@link android.content.Context#getCacheDir()}—the system can delete files
placed here as needed, so they won’t show up as storage committed to the
app.</li>
</ul>
<h3 id="configurablenetwork">Offer configurable network usage</h3>
<h4 id="configurablenetwork-onboarding">Provide onboarding experiences for
subjective user choices</h4>
<ul>
<li>Apps that allow users to reduce data usage are well received, even if
they demand heavy data requirements. If your app uses a considerable amount
of bandwidth (for example, video streaming apps), you can provide an
onboarding experience for users to configure network usage. For example,
you could allow the user to force lower-bitrate video streams on cellular
networks. </li>
<li>Additional settings for users to control data syncing, prefetching, and
network usage behavior (for example, prefetch all starred news categories on
Wi-Fi only), also help users tailor your app’s behavior to their needs.</li>
<li>For more information on managing network usage, see the Android training
on <a href="{@docRoot}training/basics/network-ops/managing.html">Managing
Network Usage</a>.</li>
</ul>
<h4 id="configurablenetwork-preferences">Provide a network preferences
screen</h4>
<ul>
<li>You can navigate to the app’s network settings from outside the app by
means of a network preferences screen. You can invoke this screen from
either the system settings screen or the system data usage screen.</li>
<li>To provide a network preferences screen that users can access from within
your app as well as from the system settings, in your app include an
activity that supports the
{@link android.content.Intent#ACTION_MANAGE_NETWORK_USAGE} action.</li>
<li>For further information on adding a network preferences screen, see the
Android training on <a
href="{@docRoot}training/basics/network-ops/managing.html#prefs">
Implementing a Preferences Activity</a>.</li>
</ul>
<h3 class="rel-resources clearfloat">Related resources</h3>
<div class="resource-widget resource-flow-layout col-13"
data-query="collection:distribute/essentials/billionsquality/cost"
data-sortOrder="-timestamp"
data-cardSizes="6x3"
data-maxResults="6"></div>
<!-- consumption -->
<div class="headerLine">
<h2 id="consumption">Battery Consumption</h2>
</div>
<p>Access to reliable power supplies varies, and outages can disrupt planned
charges. Defend your users' batteries against unnecessary drain by benchmarking
your battery use, avoiding wakelocks, scheduling tasks, and monitoring sensor
requests.</p>
<h3 id="consumption-reduce">Reduce battery consumption</h3>
<ul>
<li>Your app should do minimal activity when in the background and when the
device is running on battery power.</li>
<li>Sensors, like GPS, can also significantly drain your battery. For this
reason, we recommend that you use the <a
href="https://developers.google.com/android/reference/com/google/android/gms/location/FusedLocationProviderApi">
<code>FusedLocationProvider</code></a> API. The
<code>FusedLocationProvider</code> API manages the
underlying location technology and provides a simple API so that you can
specify requirements—like high accuracy or low power—at a high
level. It also optimizes the device's use of battery power by caching
locations and batching requests across apps. For more information about the
ideal ways to request location, see the <a
href="{@docRoot}training/location/retrieve-current.html">Getting the Last
Known Location</a> training guide.
</li>
<li><a href="{@docRoot}reference/android/os/PowerManager.WakeLock.html">Wake
locks</a> are mechanisms to keep devices on so that they can perform
background activities. Avoid using wake locks because they prevent the
device from going into low-power states.</li>
<li>To reduce the number of device wake-ups, batch network activity. For more
information on batching, see the Android training on <a
href="{@docRoot}training/efficient-downloads/efficient-network-access.html">
Optimizing Downloads for Efficient Network Access</a>.</li>
<li><a
href="https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmNetworkManager">
<code>GcmNetworkManager</code></a> schedules tasks and lets Google Play
services batch operations across the system. This greatly
simplifies the implementation of common patterns, such as waiting for
network connectivity, device charging state, retries, and backoff. Use
<code>GcmNetworkManager</code> to perform non-essential background activity
when the device is charging and is connected to an unmetered network.</li>
<li>For more information on how network activity can drain the battery, and
how to tackle this issue, see <a
href="/topic/performance/power/network/index.html">Reducing Network Battery Drain</a>.
</ul>
<h3 id="consumption-benchmark">Benchmark battery usage</h3>
<ul>
<li>Benchmarking your app’s usage in a controlled environment helps you
understand the battery-heavy tasks in your app. It is a good practice to
benchmark your app’s battery usage to gauge efficiency and track changes
over time.
</li>
<li><a
href="{@docRoot}tools/performance/batterystats-battery-historian/index.html">
Batterystats</a> collects battery data about your apps, and <a
href="{@docRoot}tools/performance/batterystats-battery-historian/index.html">
Battery Historian</a> converts that data into an HTML visualization. For
more information on reducing battery usage, see the Android training on <a
href="{@docRoot}training/monitoring-device-state/index.html">Optimizing
Battery Life</a>.</li>
</ul>
<h3 class="rel-resources clearfloat">Related resources</h3>
<div class="resource-widget resource-flow-layout col-13"
data-query="collection:distribute/essentials/billionsquality/consumption"
data-sortOrder="-timestamp"
data-cardSizes="6x3"
data-maxResults="6"></div>
<!-- content -->
<div class="headerLine">
<h2 id="contentsection">Content</h2>
</div>
<p>Make sure that your app works well on a variety of screens: offering good,
crisp graphics and appropriate layouts on low resolution and physically small
screens. Ensure that your app is designed to be easily localized by
accommodating the variations between languages: allow for spacing, density,
order, emphasis, and wording variations. Also make sure that date, time, and
the like are internationalized and displayed according to the phone’s
settings.</p>
<h3 id="content-responsive">Fast and responsive UI</h3>
<h4 id="content-feedback">Touch feedback on all touchable items</h4>
<ul>
<li>Touch feedback adds a tactile feeling to the user interface. You should
ensure your app provides touch feedback on all touchable elements to reduce
the perceived app latency as much as possible.
</li>
<li><a
href="https://www.google.com/design/spec/animation/responsive-interaction.html">
Responsive interaction</a> encourages deeper exploration of an app by
creating timely, logical, and delightful screen reactions to user input.
Responsive interaction elevates an app from an information-delivery service
to an experience that communicates using multiple visual and tactile
responses.</li>
<li>For more information, see the Android training on <a
href="{@docRoot}training/material/animations.html#Touch">Customizing Touch
Feedback</a>.</li>
</ul>
<h4 id="content-interactive">UI should always be interactive</h4>
<ul>
<li>Apps that are unresponsive when performing background activity feel slow
and reduce user satisfaction. Ensure your app always has a responsive UI
regardless of any background activity. Achieve this by performing network
operations or any heavy-duty operations in a background thread—keep the UI
thread as idle as you can.</li>
<li>Material Design apps use minimal visual changes when your app is loading
content by representing each operation with a single activity indicator.
Avoid blocking dialogs with <a
href="https://www.google.com/design/spec/components/progress-activity.html">
loading indicators</a>.</li>
<li><a
href="http://www.google.com/design/spec/patterns/empty-states.html">Empty
states</a> occur when the regular content of a view can’t be shown. It might
be a list that has no items or a search that returns no results. Avoid
completely empty states. The most basic empty state displays a
non-interactive image and a text tagline. Where you don’t have an image, or
the image is still loading, you should always show either a static
placeholder, or create a dynamic placeholder by using the <a
href="{@docRoot}tools/support-library/features.html#v7-palette">Palette
library</a> to generate placeholder colors that match the target image.</li>
<li>For more information, see the Android training on <a
href="{@docRoot}training/articles/perf-anr.html">Keeping Your App
Responsive</a>.</li>
</ul>
<h4 id="content-60fps">Target 60 frames per second on low-cost devices</h4>
<ul>
<li>Ensure that your app always runs fast and smoothly, even on low-cost
devices.</li>
<li>Overdraw can significantly slow down your app—it occurs when the pixels
are being drawn more than once per pass. An example of this is when you have
an image with a button placed on top of it. While some overdraw is
unavoidable, it should be minimized to ensure a smooth frame rate. Perform
<a href="{@docRoot}tools/performance/debug-gpu-overdraw/index.html">Debug
GPU overdraw</a> on your app to ensure it is minimized.</li>
<li>Android devices refresh the screen at 60 frames per second (fps), meaning
your app has to update the screen within roughly 16 milliseconds. <a
href="{@docRoot}tools/performance/profile-gpu-rendering/index.html">Profile
your app</a> using on-device tools to see if and when your app is not
meeting this 16-ms average.</li>
<li>Reduce or remove animations on low-cost devices to lessen the burden on
the device’s CPU and GPU. For more information, see the Android training on
<a href="{@docRoot}training/improving-layouts/index.html">Improving Layout
Performance</a>. </li>
<li>An efficient view hierarchy can speed up your app without increasing the
app's memory footprint. For more information, see
<a href="/topic/performance/optimizing-view-hierarchies.html">Performance
and View Hierarchies.</a>
</ul>
<h4 id="content-firstload">If anticipated start speed is low, use launch screen on first load</h4>
<ul>
<li>The launch screen is a user’s first experience of your application.
Launching your app while displaying a blank canvas increases its perceived
loading time, so consider using a placeholder UI or a branded launch screen
to reduce the perceived loading time.</li>
<li>A<a href="https://www.google.com/design/spec/patterns/launch-screens.html#launch-screens-types-of-launch-screens">
placeholder UI</a> is the most seamless launch transition, appropriate for
both app launches and in-app activity transitions.</li>
<li><a
href="https://www.google.com/design/spec/patterns/launch-screens.html#launch-screens-placeholder-ui">
Branded launch screens</a> provide momentary brand exposure, freeing the UI
to focus on content.</li>
<li>For more information on implementing splash screens, see the <a
href="https://www.google.com/design/spec/patterns/launch-screens.html">
Launch screens</a> section of the Material Design spec.</li>
<li>The best way to deal with slow start speeds is not to have them. <a
href="/topic/performance/launch-time.html">Launch-Time Performance</a> provides
information that may help you speed up your app's launch time.</li>
</ul>
<h3 id="ui">UI best practices</h3>
<ul>
<li><a
href="https://www.google.com/design/spec/material-design/introduction.html">
Material Design</a> is a visual language that synthesizes the classic
principles of good design with the innovation and possibility of technology
and science. Material Design aims to develop a single underlying system that
allows for a unified experience across platforms and device sizes. Consider
using key Material Design components so that users intuitively know how to
use your app.</li>
<li>Ready-to-use Material Design components are available via the <a
href="{@docRoot}tools/support-library/features.html#design">Design Support
library</a>. These components are supported in Android 2.1 (API level 7) and
above.</li>
</ul>
<h3 id="localization">Localization</h3>
<ul>
<li>Your users could be from any part of the world and their first language
may not be yours. If you don’t present your app in a language that your
users can read, it is a missed opportunity. You should therefore
localize your app for key regional languages.</li>
<li>To learn more, visit the Android training on <a
href="{@docRoot}training/basics/supporting-devices/languages.html">
Supporting Different Languages</a>.</li>
<li>Starting from Android 7.0 (API level 24), the Android framework
makes available a subset of the <a class="external-link"
href="http://userguide.icu-project.org/">ICU4J APIs</a>, which can
help you localize your app into multiple languages. For more
information, see <a href="/guide/topics/resources/icu4j-framework.html">
ICU4J Android Framework APIs.</a>
</ul>
<h3 class="rel-resources clearfloat">Related resources</h3>
<div class="resource-widget resource-flow-layout col-13"
data-query="collection:distribute/essentials/billionsquality/content"
data-sortOrder="-timestamp"
data-cardSizes="6x3"
data-maxResults="6"></div>