If you're developing an Android application, Android 3.0 introduces several features that allow you to enhance your user's experience on tablets and similar devices. Any application you've already published is compatible with devices running Android 3.0, by default, because Android applications are forward-compatible. However, there are some simple changes you should make to optimize your application for tablet-type devices.
This document shows how you can optimize your existing application for Android 3.0 and maintain compatibility with older versions or upgrade your application completely with new APIs.
To get started:
When you have an existing application and want to maintain compatibility with older versions of Android.
When you want to upgrade your application to use APIs introduced in Android 3.0 or create a new application targeted to tablets and similar devices.
To start testing and developing your application on Android 3.0, set up your existing Android SDK with the new platform:
(If you don't have an existing Android SDK, download the SDK starter package now.)
Set the target to "Android 3.0" and the skin to "WXGA" (the default skin).
Because the Android emulator must simulate the ARM instruction set on your computer and the WXGA screen is significantly larger than a typical virtual device, emulator performance is much slower than a real device.
In particular, initializing the emulator can be slow and can take several minutes, depending on your hardware. When the emulator is booting, there is limited user feedback, so please be patient and wait until you see the home screen (or lock screen) appear.
However, you don't need to boot the emulator each time you rebuild your application—typically you only need to boot at the start of a session and keep it running. Also see the tip below for information about using a snapshot to drastically reduce startup time after the first initialization.
We're working hard to resolve the performance issues and it will improve in future tools releases. For the time being, the emulator is still best way to evaluate your application's appearance and functionality on Android 3.0 without a real device.
Tip: To improve the startup time for the emulator, enable snapshots for the AVD when you create it with the SDK and AVD Manager (there's a checkbox in the AVD creator to Enable snapshots). Then, start the AVD from the AVD manager and check Launch from snapshot and Save to snapshot. This way, when you close the emulator, a snapshot of the AVD state is saved and used to quickly relaunch the AVD next time. However, when you choose to save a snapshot, the emulator will be slow to close, so you might want to disable Save to snapshot after you've acquired an initial snapshot (after you close the AVD for the first time).
If you've already developed an application for an earlier version of Android, there are a few
things you can do to optimize it for a tablet-style experience on Android 3.0 without changing the
minimum version required (you don't need to change your manifest's android:minSdkVersion).
Note: All Android applications are forward-compatible, so there's nothing you have to do—if your application is a good citizen of the Android APIs, your app should work fine on devices running Android 3.0. However, in order to provide users a better experience when using your app on an Android 3.0 tablet or similar-size device, you should update your application to inherit the new system theme and provide some optimizations for larger screens.
Here are a few things you can do to optimize your application for devices running Android 3.0:
<uses-sdk> element to
set android:targetSdkVersion to "11". For example:
<manifest ... >
<uses-sdk android:minSdkVersion="4"
android:targetSdkVersion="11" />
<application ... >
...
<application>
</manifest>
By targeting the Android 3.0 platform, the system automatically applies the holographic theme to each activity when your application runs on an Android 3.0 device. The holographic theme provides a new design for widgets, such as buttons and text boxes, and restyles other visual elements. This is the standard theme in applications built for Android 3.0, so your application will look more at home by enabling the theme.
Additionally, the holographic theme enables the Action Bar in your activities when running on an Android 3.0 device. The Action Bar replaces the traditional title bar at the top of the activity window and provides the user access to the activity's Options Menu.
android:minSdkVersion,
but install it on the Android 3.0 AVD. Repeat your tests to be sure that your user interface works
well with the holographic theme.
Note: If you have applied other themes directly to your activities, they will override the inherited holographic theme. To resolve this, you can use the system version qualifier to provide an alternative theme for Android 3.0 devices that's based on the holographic theme. For more information, read how to select a theme based on platform version.
By providing alternative
resources when running on extra large screens (using the xlarge resource
qualifier), you can improve the user experience of your application on tablet-type devices without
using new APIs.
For example, here are some things to consider when creating a new layout for extra large screens:
You can specify landscape resources with the land resource
qualifier, but if you want alternative resources for an extra large landscape screen, you
should use both xlarge and land qualifiers. For example, res/layout-xlarge-land/. The order of the qualifier names is important; see
Providing Alternative Resources for more information.
sp units when setting font
sizes. This alone should ensure a readable experience on tablet-style devices. In some cases,
however, you might want to consider larger font sizes for xlarge configurations.In general, always be sure that your application follows the Best Practices for Screen Independence.
If you want to develop an application that's fully enhanced for tablet-type devices running Android 3.0, then you need to use new APIs in Android 3.0. This section introduces some of the new features you should use.
The first thing to do when you create a project for Android 3.0 is set your manifest's android:minSdkVersion
to "11". For example:
<manifest ... >
<uses-sdk android:minSdkVersion="11" />
<application ... >
...
<application>
</manifest>
By targeting the Android 3.0 platform, the system automatically applies the new holographic theme to each of your activities.
Additionally, the holographic theme enables the Action Bar for each activity.
The Action Bar is a widget for activities that replaces the traditional title bar at the top of the screen. By default, the Action Bar includes the application logo on the left side, followed by the activity title, and any available items from the Options Menu on the right side.
You can enable items from your activity's Options Menu to appear directly in the Action Bar as
"action items" by adding showAsAction="ifRoom" to specific items in your menu resource. You can also add
navigation features to the Action Bar, such as tabs, and use the application icon to navigate to
your application's "home" activity or "up" the activity hierarchy.
For more information, read Using the Action Bar.
A fragment represents a behavior or a portion of user interface in an activity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities. You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running.
For example, a news application can use one fragment to show a list of articles on the left and another fragment to display an article on the right—both fragments appear in one activity, side by side, and each fragment has its own set of lifecycle callback methods and handles its own input events. Thus, instead of using one activity to select an article and another activity to read the article, the user can select an article and read it all within the same activity.
For more information, read the Fragments document.
An all new flexible animation framework allows you to animate arbitrary properties of any object (View, Drawable, Fragment, Object, or anything else). You can define several animation aspects (such as duration, repeat, interpolation, and more) for an object's int, float, and hexadecimal color values, by default. That is, when an object has a property field for one of these types, you can change its value over time to affect an animation.
The View class also provides new APIs that leverage the new animation
framework, allowing you to easily apply 2D and 3D transformations to views in your activity layout.
New transformations are made possible with a set of object properties that define the view's layout
position, orientation, transparency and more.
For more information, read the Property Animation document.
You can now enable the OpenGL renderer for your application by setting android:hardwareAccelerated="true" in your manifest's <application>
element or for individual <activity> elements. Hardware acceleration results in smoother animations, smoother
scrolling, and overall better performance and response to user interaction. When enabled, be sure
that you thoroughly test your application on a device that supports hardware acceleration.
App widgets allow users to access information from your application directly from the Home
screen and interact with ongoing services (such as preview their email and control music playback).
Android 3.0 enhances these capabilities by enabling collections, created with widgets such as
ListView, GridView, and the new StackView. These widgets allow you to create more interactive app
widgets, such as one with a scrolling list, and can automatically update their data through a RemoteViewsService.
Additionally, you should create a preview image of your app widget using the Widget Preview
application (pre-installed in an Android 3.0 AVD) and reference it with the android:previewImage attribute, so that users
can see what the app widget looks like before adding it to their Home screen.
Android 3.0 introduces many more APIs that you might find valuable for your application, such as drag and drop APIs, new Bluetooth APIs, a system-wide clipboard framework, a new graphics engine called Renderscript, and more.
To learn more about the APIs mentioned above and more, see the Android 3.0 Platform document.
You should also decide whether your application is only for tablet-type devices (specifically, xlarge devices) or for all types of screen sizes.
If you want your application to be available to all screen sizes (for example, for all
phones and tablets), there's nothing you need to do. By default, an application with android:minSdkVersion set to "4" or higher will resize to fit any screen size.
If your application is only for xlarge screens, include the <supports-screens> element in your manifest and declare that the application supports
only xlarge screens, by declaring all other sizes "false". For example:
<manifest ... >
...
<supports-screens android:smallScreens="false"
android:normalScreens="false"
android:largeScreens="false"
android:xlargeScreens="true" />
<application ... >
...
<application>
</manifest>
With this declaration, you indicate that your application does not support any screen size except extra large. External services such as Android Market may then use this information to filter your application from devices that do not have an extra large screen.
Many of the new features and APIs that are described in the Android 3.0 Platform Preview also have accompanying
samples that can help you understand how to use them. To get the samples, download them from the SDK
repository using the Android SDK Manager. After downloading the samples ("Samples for SDK API 11"),
you can find them in <sdk_root>/samples/android-11/. The links below can help you
find samples for the features you are interested in: