Android 3.1 Platform

API Level: 12

For developers, the Android 3.1 platform is available as a downloadable component for the Android SDK. The downloadable platform includes an Android library and system image, as well as a set of emulator skins and more. The downloadable platform includes no external libraries.

To get started developing or testing against Android 3.1, use the Android SDK Manager to download the platform into your SDK. For more information, see Adding SDK Components. If you are new to Android, download the SDK Starter Package first.

For a high-level introduction to Android 3.1, see the Platform Highlights.

Reminder: If you've already published an Android application, please test and optimize your application on Android 3.0 and Android 3.1 as soon as possible. You should do so to be sure your application provides the best experience possible on the latest Android-powered devices. For information about what you can do, read Optimizing Apps for Android 3.0.

Revisions

To determine what revision of the Android 3.1 platform you have installed, refer to the "Installed Packages" listing in the Android SDK and AVD Manager.

Android 3.1, Revision 3 (July 2011)

Dependencies:

Requires SDK Tools r12 or higher.

Notes:

Improvements to the platform's rendering library to support the visual layout editor in the ADT Eclipse plugin. This revision allows for more drawing features in ADT and fixes several bugs in the previous rendering library. It also unlocks several editor features that were added in ADT 12.

Android 3.1, Revision 2 (May 2011)

Dependencies:

Requires SDK Tools r11 or higher.

Notes:

Fixes an issue with the visual layout editor rendering library that prevented Android 3.1 from running in ADT.

Android 3.1, Revision 1 (May 2011)

Dependencies:

Requires SDK Tools r11 or higher.

API Overview

The sections below provide a technical overview of what's new for developers in Android 3.1, including new features and changes in the framework API since the previous version.

USB APIs

Android 3.1 introduces powerful new APIs for integrating connected peripherals with applications running on the platform. The APIs are based on a USB (Universal Serial Bus) stack and services that are built into the platform, including support for both USB host and device interactions. Using the APIs, developers can create applications that are able to discover, communicate with, and manage a variety of device types connected over USB.

The stack and APIs distinguish two basic types of USB hardware, based on whether the Android-powered device is acting as host or the external hardware is acting as host:

  • A USB device is a piece of connected hardware that depends on the Android-powered device to serve as host. For example, most input devices, mice, and joysticks are USB devices, as are many cameras, hubs, and so on.
  • A USB accessory is a piece of connected hardware that has a USB host controller, provides power, and is designed to communicate with Android-powered devices over USB, A variety of peripherals can connect as accessories, from robotics controllers to musical equipment, exercise bicycles, and more.

For both types — USB devices and USB accessories — the platform's USB APIs support discovery by intent broadcast when attached or detached, as well as standard interfaces, endpoints, and transfer modes (control, bulk, and interrupt).

The USB APIs are available in the package android.hardware.usb. The central class is UsbManager, which provides helper methods for identifying and communicating with both USB devices and USB accessories. Applications can acquire an instance of UsbManager and then query for the list of attached devices or accessories and then communicate with or manage them. UsbManager also declares intent actions that the system broadcasts, to announce when a USB device or accessory is attached or detached.

Other classes include:

  • UsbDevice, a class representing external hardware connected as a USB device (with the Android-powered device acting as host).
  • UsbAccessory, representing external hardware connected as the USB host (with the Android-powered device acting as a USB device).
  • UsbInterface and UsbEndpoint, which provide access to standard USB interfaces and endpoints for a device.
  • UsbDeviceConnection and UsbRequest, for sending and receiving data and control messages to or from a USB device, sychronously and asynchronously.
  • UsbConstants, which provides constants for declaring endpoint types, device classes, and so on.

Note that although the USB stack is built into the platform, actual support for USB host and open accessory modes on specific devices is determined by their manufacturers. In particular, host mode relies on appropriate USB controller hardware in the Android-powered device.

Additionally, developers can request filtering on Google Play, such that their applications are not availabe to users whose devices do not provide the appropriate USB support. To request filtering, add one or both of the elements below to the application manifest, as appropriate:

  • If the application should only be visible to devices that support USB host mode (connection of USB devices), declare this element:

    <uses-feature android:name="android.hardware.usb.host" android:required="true">

  • If the application should only be visible to devices that support USB accessories (connection of USB hosts), declare this element:

    <uses-feature android:name="android.hardware.usb.accessory" android:required="true">

For complete information about how to develop applications that interact with USB accessories, please see the developer documentation.

To look at sample applications that use the USB host API, see ADB Test and Missile Launcher

MTP/PTP API

Android 3.1 exposes a new MTP API that lets applications interact directly with connected cameras and other PTP devices. The new API makes it easy for an application to receive notifications when devices are attached and removed, manage files and storage on those devices, and transfer files and metadata to and from them. The MTP API implements the PTP (Picture Transfer Protocol) subset of the MTP (Media Transfer Protocol) specification.

The MTP API is available in the android.mtp package and provides these classes:

  • The MtpDevice encapsulates an MTP device that is connected over the USB host bus. An application can instantiate an object of this type and then use its methods to get information about the device and objects stored on it, as well as opening the connection and transferring data. Some of the methods include:
    • getObjectHandles() returns a list of handles for all objects on the device that match a specified format and parent. To get information about an object, an application can pass a handle to getObjectInfo().
    • importFile() lets an application copy data for an object to a file in external storage. This call may block for an arbitrary amount of time depending on the size of the data and speed of the devices, so should be made from a spearate thread.
    • open() lets an application open a connected MTP/PTP device.
    • getThumbnail() returns the thumbnail of the object as a byte array.
  • MtpStorageInfo holds information about about a storage unit on an MTP device, corresponding to the StorageInfo Dataset described in section 5.2.2 of the MTP specification. Methods in the class let an application get a storage unit’s description string, free space, maximum storage capacity, storage ID, and volume identifier.
  • MtpDeviceInfo holds information about an MTP device corresponding to the DeviceInfo Dataset described in section 5.1.1 of the MTP specification. Methods in the class let applications get a device’s manufacturer, model, serial number, and version.
  • MtpObjectInfo holds information about an object stored on an MTP device, corresponding to the ObjectInfo Dataset described in section 5.3.1 of the MTP specification. Methods in the class let applications get an object’s size, data format, association type, creation date, and thumbnail information.
  • MtpConstants provides constants for declaring MTP file format codes, association type, and protection status.

Support for new input devices and motion events

Android 3.1 extends the input subsystem to support new input devices and new types of motion events, across all views and windows. Developers can build on these capabilities to let users interact with their applications using mice, trackballs, joysticks, gamepads, and other devices, in addition to keyboards and touchscreens.

For handling mouse, scrollwheel, and trackball input, the platform supports two new motion event actions:

  • ACTION_SCROLL, which describes the pointer location at which a non-touch scroll motion, such as from a mouse scroll wheel, took place. In the MotionEvent, the value of the AXIS_HSCROLL and AXIS_VSCROLL axes specify the relative scroll movement.
  • ACTION_HOVER_MOVE, reports the current position of the mouse when no buttons are pressed, as well as any intermediate points since the last HOVER_MOVE event. Hover enter and exit notifications are not yet supported.

To support joysticks and gamepads, the InputDevice class includes these new input device sources:

To describe motion events from these new sources, as well as those from mice and trackballs, the platform now defines axis codes on MotionEvent, similar to how it defines key codes on KeyEvent. New axis codes for joysticks and game controllers include AXIS_HAT_X, AXIS_HAT_Y, AXIS_RTRIGGER, AXIS_ORIENTATION, AXIS_THROTTLE, and many others. Existing MotionEvent axes are represented by AXIS_X, AXIS_Y, AXIS_PRESSURE, AXIS_SIZE, AXIS_TOUCH_MAJOR, AXIS_TOUCH_MINOR, AXIS_TOOL_MAJOR, AXIS_TOOL_MINOR, and AXIS_ORIENTATION.

Additionally, MotionEvent defines a number of generic axis codes that are used when the framework does not know how to map a particular axis. Specific devices can use the generic axis codes to pass custom motion data to applications. For a full list of axes and their intended interpretations, see the MotionEvent class documentation.

The platform provides motion events to applications in batches, so a single event may contain a current position and multiple so-called historical movements. Applications should use getHistorySize() to get the number of historical samples, then retrieve and process all historical samples in order using getHistoricalAxisValue(). After that, applications should process the current sample using getAxisValue().

Some axes can be retrieved using special accessor methods. For example, instead of calling getAxisValue(), applications can call getX(). Axes that have built-in accessors include AXIS_X, AXIS_Y, AXIS_PRESSURE, AXIS_SIZE, AXIS_TOUCH_MAJOR, AXIS_TOUCH_MINOR, AXIS_TOOL_MAJOR, AXIS_TOOL_MINOR, and AXIS_ORIENTATION.

Each input device has a unique, system-assigned ID and may also provide multiple sources. When a device provides multiple sources, more than one source can provide axis data using the same axis. For example, a touch event coming from the touch source uses the X axis for screen position data, while a joystick event coming from the joystick source will use the X axis for the stick position instead. For this reason, it's important for applications to interpret axis values according to the source from which they originate. When handling a motion event, applications should use methods on the InputDevice class to determine the axes supported by a device or source. Specifically, applications can use getMotionRanges() to query for all axes of a device or all axes of a given source of the device. In both cases, the range information for axes returned in the InputDevice.MotionRange object specifies the source for each axis value.

Finally, since the motion events from joysticks, gamepads, mice, and trackballs are not touch events, the platform adds a new callback method for passing them to a View as "generic" motion events. Specifically, it reports the non-touch motion events to Views through a call to onGenericMotionEvent(), rather than to onTouchEvent().

The platform dispatches generic motion events differently, depending on the event source class. SOURCE_CLASS_POINTER events go to the View under the pointer, similar to how touch events work. All others go to the currently focused View. For example, this means a View must take focus in order to receive joystick events. If needed, applications can handle these events at the level of Activity or Dialog by implementing onGenericMotionEvent() there instead.

To look at a sample application that uses joystick motion events, see GameControllerInput and GameView.

RTP API

Android 3.1 exposes an API to its built-in RTP (Real-time Transport Protocol) stack, which applications can use to manage on-demand or interactive data streaming. In particular, apps that provide VOIP, push-to-talk, conferencing, and audio streaming can use the API to initiate sessions and transmit or receive data streams over any available network.

The RTP API is available in the android.net.rtp package. Classes include:

  • RtpStream, the base class of streams that send and receive network packets with media payloads over RTP.
  • AudioStream, a subclass of RtpStream that carries audio payloads over RTP.
  • AudioGroup, a local audio hub for managing and mixing the device speaker, microphone, and AudioStream.
  • AudioCodec, which holds a collection of codecs that you define for an AudioStream.

To support audio conferencing and similar usages, an application instantiates two classes as endpoints for the stream:

The simplest usage involves a single remote endpoint and local endpoint. For more complex usages, please refer to the limitations described for AudioGroup.

To use the RTP API, applications must request permission from the user by declaring <uses-permission android:name="android.permission.INTERNET"> in their manifest files. To acquire the device microphone, the <uses-permission android:name="android.permission.RECORD_AUDIO"> permission is also required.

Resizable app widgets

Starting in Android 3.1, developers can make their homescreen widgets resizeable — horizontally, vertically, or on both axes. Users touch-hold a widget to show its resize handles, then drag the horizontal and/or vertical handles to change the size on the layout grid.

Developers can make any Home screen widget resizeable by defining a resizeMode attribute in the widget's AppWidgetProviderInfo metadata. Values for the resizeMode attribute include "horizontal", "vertical", and "none". To declare a widget as resizeable horizontally and vertically, supply the value "horizontal|vertical".

Here's an example: 

<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:minWidth="294dp"
    android:minHeight="72dp"
    android:updatePeriodMillis="86400000"
    android:previewImage="@drawable/preview"
    android:initialLayout="@layout/example_appwidget"
    android:configure="com.example.android.ExampleAppWidgetConfigure"
    android:resizeMode="horizontal|vertical" >
</appwidget-provider>

For more information about Home screen widgets, see the App Widgets documentation.

Animation framework

  • New ViewPropertyAnimator class
    • A new ViewPropertyAnimator class provides a convenient way for developers to animate select properties on View objects. The class automaties and optimizes the animation of the properties and makes it easier to manage multiple simulataneous animations on a View object.

      Using the ViewPropertyAnimator is straightforward. To animate properties for a View, call animate() to construct a ViewPropertyAnimator object for that View. Use the methods on the ViewPropertyAnimator to specify what property to animate and how to animate it. For example, to fade the View to transparent, call alpha(0);. The ViewPropertyAnimator object handles the details of configuring the underlying Animator class and starting it, then rendering the animation.

  • Animation background color
    • New getBackgroundColor() and setBackgroundColor(int) methods let you get/set the background color behind animations, for window animations only. Currently the background must be black, with any desired alpha level.
  • Getting animated fraction from ViewAnimator
    • A new getAnimatedFraction() method lets you get the current animation fraction — the elapsed/interpolated fraction used in the most recent frame update — from a ValueAnimator.

UI framework

Graphics

  • Helpers for managing bitmaps
    • setHasAlpha(boolean) lets an app indicate that all of the pixels in a Bitmap are known to be opaque (false) or that some of the pixels may contain non-opaque alpha values (true). Note, for some configs (such as RGB_565) this call is ignored, since it does not support per-pixel alpha values. This is meant as a drawing hint, as in some cases a bitmap that is known to be opaque can take a faster drawing case than one that may have non-opaque per-pixel alpha values.
    • getByteCount() gets a Bitmap's size in bytes.
    • getGenerationId() lets an application find out whether a Bitmap has been modified, such as for caching.
    • sameAs(android.graphics.Bitmap) determines whether a given Bitmap differs from the current Bitmap, in dimension, configuration, or pixel data.
  • Setting camera location and rotation

Network

  • High-performance Wi-Fi lock
    • A new high-performance Wi-Fi lock lets applications maintain high-performance Wi-Fi connections even when the device screen is off. Applications that stream music, video, or voice for long periods can acquire the high-performance Wi-Fi lock to ensure streaming performance even when the screen is off. Because it uses more power, applications should acquire the high-performance Wi-Fi when there is a need for a long-running active connection.

      To create a high-performance lock, pass WIFI_MODE_FULL_HIGH_PERF as the lock mode in a call to createWifiLock().

  • More traffic stats
    • Applications can now access statistics about more types of network usage using new methods in TrafficStats. Applications can use the methods to get UDP stats, packet count, TCP transmit/receive payload bytes and segments for a given UID.
  • SIP auth username

Download Manager

IME framework

Media

  • New streaming audio formats
    • The media framework adds built-in support for raw ADTS AAC content, for improved streaming audio, as well as support for FLAC audio, for highest quality (lossless) compressed audio content. See the Supported Media Formats document for more information.

Launch controls on stopped applications

Starting from Android 3.1, the system's package manager keeps track of applications that are in a stopped state and provides a means of controlling their launch from background processes and other applications.

Note that an application's stopped state is not the same as an Activity's stopped state. The system manages those two stopped states separately.

The platform defines two new intent flags that let a sender specify whether the Intent should be allowed to activate components in stopped application.

When neither or both of these flags is defined in an intent, the default behavior is to include filters of stopped applications in the list of potential targets.

Note that the system adds FLAG_EXCLUDE_STOPPED_PACKAGES to all broadcast intents. It does this to prevent broadcasts from background services from inadvertently or unnecessarily launching components of stoppped applications. A background service or application can override this behavior by adding the FLAG_INCLUDE_STOPPED_PACKAGES flag to broadcast intents that should be allowed to activate stopped applications.

Applications are in a stopped state when they are first installed but are not yet launched and when they are manually stopped by the user (in Manage Applications).

Notification of application first launch and upgrade

The platform adds improved notification of application first launch and upgrades through two new intent actions:

  • ACTION_PACKAGE_FIRST_LAUNCH — Sent to the installer package of an application when that application is first launched (that is, the first time it is moved out of a stopped state). The data contains the name of the package.
  • ACTION_MY_PACKAGE_REPLACED — Notifies an application that it was updated, with a new version was installed over an existing version. This is only sent to the application that was replaced. It does not contain any additional data. To receive it, declare an intent filter for this action. You can use the intent to trigger code that helps get your application back in proper running shape after an upgrade.

    This intent is sent directly to the application, but only if the application was upgraded while it was in started state (not in a stopped state).

Core utilities

  • LRU cache
    • A new LruCache class lets your applications benefit from efficient caching. Applications can use the class to reduce the time spent computing or downloading data from the network, while maintaining a sensible memory footprint for the cached data.LruCache is a cache that holds strong references to a limited number of values. Each time a value is accessed, it is moved to the head of a queue. When a value is added to a full cache, the value at the end of that queue is evicted and may become eligible for garbage collection.
  • File descriptor as int

WebKit

  • File scheme cookies
    • The CookieManager now supports cookies that use the file: URI scheme. You can use setAcceptFileSchemeCookies() to enable/disable support for file scheme cookies, before constructing an instance of WebView or CookieManager. In a CookieManager instance, you can check whether file scheme cookies is enabled by calling allowFileSchemeCookies().
  • Notification of login request
    • To support the browser autologin features introduced in Android 3.0, the new method onReceivedLoginRequest() notifies the host application that an autologin request for the user was processed.
  • Removed classes and interfaces
    • Several classes and interfaces were removed from the public API, after previously being in deprecated state. See the API Differences Report for more information.

Browser

The Browser application adds the following features to support web applications:

  • Support for inline playback of video embedded in HTML5 <video> tag. Playback is hardware-accelerated where possible.
  • Layer support for fixed position elements for all sites (mobile and desktop).

New feature constants

The platform adds new hardware feature constants that developers can declare in their application manifests, to inform external entities such as Google Play of the application's requirement for new hardware capabilities supported in this version of the platform. Developers declare these and other feature constants in <uses-feature> manifest elements.

Google Play filters applications based on features declared in <uses-feature> manifest elements. For more information about declaring features in an application manifest, read Google Play Filters.

API Differences Report

For a detailed view of all API changes in Android 3.1 (API Level 12), see the API Differences Report.

API Level

The Android 3.1 platform delivers an updated version of the framework API. The Android 3.1 API is assigned an integer identifier — 12 — that is stored in the system itself. This identifier, called the "API Level", allows the system to correctly determine whether an application is compatible with the system, prior to installing the application.

To use APIs introduced in Android 3.1 in your application, you need compile the application against the Android library that is provided in the Android 3.1 SDK platform. Depending on your needs, you might also need to add an android:minSdkVersion="12" attribute to the <uses-sdk> element in the application's manifest.

For more information about how to use API Level, see the API Levels document.

Built-in Applications

The system image included in the downloadable platform provides these built-in applications:

  • API Demos
  • Browser
  • Calculator
  • Camera
  • Clock
  • Contacts
  • Custom Locale
  • Dev Tools
  • Downloads
  • Email
  • Gallery
  • Gestures Builder
  • Messaging
  • Music
  • Search
  • Settings
  • Spare Parts
  • Speech Recorder
  • Widget Preview

Locales

The system image included in the downloadable SDK platform provides a variety of built-in locales. In some cases, region-specific strings are available for the locales. In other cases, a default version of the language is used. The languages that are available in the Android 3.0 system image are listed below (with language_country/region locale descriptor).

  • Arabic, Egypt (ar_EG)
  • Arabic, Israel (ar_IL)
  • Bulgarian, Bulgaria (bg_BG)
  • Catalan, Spain (ca_ES)
  • Czech, Czech Republic (cs_CZ)
  • Danish, Denmark(da_DK)
  • German, Austria (de_AT)
  • German, Switzerland (de_CH)
  • German, Germany (de_DE)
  • German, Liechtenstein (de_LI)
  • Greek, Greece (el_GR)
  • English, Australia (en_AU)
  • English, Canada (en_CA)
  • English, Britain (en_GB)
  • English, Ireland (en_IE)
  • English, India (en_IN)
  • English, New Zealand (en_NZ)
  • English, Singapore(en_SG)
  • English, US (en_US)
  • English, South Africa (en_ZA)
  • Spanish (es_ES)
  • Spanish, US (es_US)
  • Finnish, Finland (fi_FI)
  • French, Belgium (fr_BE)
  • French, Canada (fr_CA)
  • French, Switzerland (fr_CH)
  • French, France (fr_FR)
  • Hebrew, Israel (he_IL)
  • Hindi, India (hi_IN)
  • Croatian, Croatia (hr_HR)
  • Hungarian, Hungary (hu_HU)
  • Indonesian, Indonesia (id_ID)
  • Italian, Switzerland (it_CH)
  • Italian, Italy (it_IT)
  • Japanese (ja_JP)
  • Korean (ko_KR)
  • Lithuanian, Lithuania (lt_LT)
  • Latvian, Latvia (lv_LV)
  • Norwegian bokmål, Norway (nb_NO)
  • Dutch, Belgium (nl_BE)
  • Dutch, Netherlands (nl_NL)
  • Polish (pl_PL)
  • Portuguese, Brazil (pt_BR)
  • Portuguese, Portugal (pt_PT)
  • Romanian, Romania (ro_RO)
  • Russian (ru_RU)
  • Slovak, Slovakia (sk_SK)
  • Slovenian, Slovenia (sl_SI)
  • Serbian (sr_RS)
  • Swedish, Sweden (sv_SE)
  • Thai, Thailand (th_TH)
  • Tagalog, Philippines (tl_PH)
  • Turkish, Turkey (tr_TR)
  • Ukrainian, Ukraine (uk_UA)
  • Vietnamese, Vietnam (vi_VN)
  • Chinese, PRC (zh_CN)
  • Chinese, Taiwan (zh_TW)
    		•

    Note: The Android platform may support more locales than are included in the SDK system image. All of the supported locales are available in the Android Open Source Project.

    Emulator Skins

    The downloadable platform includes the following emulator skin:

    • WXGA (1280x800, medium density, xlarge screen)

    For more information about how to develop an application that displays and functions properly on all Android-powered devices, see Supporting Multiple Screens.

    ↑ Go to top