API Level: 21
Android 5.0 (Lollipop) offers new features for users and app developers. This document provides an introduction to the most notable new APIs.
As an app developer, you should download the Android 5.0 system image and SDK platform from the SDK Manager as soon as possible. If you don’t have a device running Android 5.0 on which to test your app, use the Android 5.0 system image to test your app on the Android emulator. Then build your apps against the Android 5.0 platform to begin using the latest APIs.
Update your target API level
To better optimize your app for devices running Android 5.0,
set your targetSdkVersion
to
"21"
, install your app on an Android
5.0 system image, test it, then publish the updated app with
this change.
You can use Android 5.0 APIs while also supporting older
versions by adding conditions to your code that check for the system API level
before executing APIs not supported by your minSdkVersion
.
To learn more about maintaining backward compatibility, read Supporting
Different Platform Versions.
For more information about how API levels work, read What is API Level?
Important Behavior Changes
If you have previously published an app for Android, be aware that your app might be affected by changes in Android 5.0.
If you haven't tested your app against the new Android Runtime (ART)...
The 4.4 release introduced a new, experimental Android runtime, ART. Under 4.4, ART was optional, and the default runtime remained Dalvik. With Android 5.0, ART is now the default runtime.
For an overview of ART's new features, see Introducing ART. Some of the major new features are:
- Ahead-of-time (AOT) compilation
- Improved garbage collection (GC)
- Improved debugging support
Most Android apps should just work without any changes under ART. However, some techniques that work on Dalvik do not work on ART. For information about the most important issues, see Verifying App Behavior on the Android Runtime (ART). Pay particular attention if:
- Your app uses Java Native Interface (JNI) to run C/C++ code.
- You use development tools that generate non-standard code (such as some obfuscators).
- You use techniques that are incompatible with compacting garbage collection. (ART does not currently implement compacting GC, but compacting GC is under development in the Android Open Source Project.)
If your app implements notifications...
Make sure your notifications take these Android 5.0 changes into account. To learn more about designing your notifications for Android 5.0 and higher, see the notifications design guide.
Material design style
Notifications are drawn with dark text atop white (or very light) backgrounds to match the new material design widgets. Make sure that all your notifications look right with the new color scheme. If your notifications look wrong, fix them:
- Use
setColor()
to set an accent color in a circle behind your icon image. - Update or remove assets that involve color. The system ignores all non-alpha channels in action icons and in the main notification icon. You should assume that these icons will be alpha-only. The system draws notification icons in white and action icons in dark gray.
Sound and vibration
If you are currently adding sounds and vibrations to your notifications by
using the Ringtone
, MediaPlayer
,
or Vibrator
classes, remove this code so that
the system can present notifications correctly in
priority mode. Instead, use
Notification.Builder
methods to add sounds and
vibration.
Setting the device to
RINGER_MODE_SILENT
now
causes the device to enter the new priority mode. The device stays in priority
mode when you leave silent mode.
Previously, Android used STREAM_MUSIC
as the master stream to control volume on tablet devices. In Android 5.0, the
master volume stream for both phone and tablet devices is now unified, and
is controlled by STREAM_RING
or
STREAM_NOTIFICATION
.
Lock screen visibility
By default, notifications now appear on the user's lock screen in Android 5.0.
Users can choose to protect sensitive information from being exposed, in which
case the system automatically redacts the text displayed by the notification. To
customize this redacted notification, use
setPublicVersion()
.
If the notification does not contain personal information, or if you want to
allow media playback control on the notification, call the
setVisibility()
method and set the notification's visibility level to
VISIBILITY_PUBLIC
.
![](../../images/android-5.0/hun-example.png)
Figure 1. Fullscreen activity showing a heads-up notification
Media playback
If you are implementing notifications that present media playback
status or transport controls, consider using the new
Notification.MediaStyle
template instead of a custom
RemoteViews.RemoteView
object. Whichever approach you
choose, make sure to set the notification's visibility to
VISIBILITY_PUBLIC
so that
your controls are accessible from the lock screen. Note that beginning in
Android 5.0, the system no longer shows
RemoteControlClient
objects on the lock screen. For more
information, see
If your app uses RemoteControlClient.
Heads-up notification
Notifications may now appear in a small floating window (also called a heads-up notification) when the device is active (that is, the device is unlocked and its screen is on). These notifications appear similar to the compact form of your notification, except that the heads-up notification also shows action buttons. Users can act on, or dismiss, a heads-up notification without leaving the current app.
Examples of conditions that may trigger heads-up notifications include:
- The user's activity is in fullscreen mode (the app uses
fullScreenIntent
) - The notification has high priority and uses ringtones or vibrations
If your app implements notifications under any of those scenarios, make sure that heads-up notifications are presented correctly.
If your app uses RemoteControlClient...
The RemoteControlClient
class is now deprecated. Switch
to the new MediaSession
API as
soon as possible.
Lock screens in Android 5.0 do not show transport controls for
your MediaSession
or
RemoteControlClient
. Instead, your app can provide
media playback control from the lock screen through a notification. This
gives your app more control over the presentation of media buttons, while
providing a consistent experience for users across locked and
unlocked devices.
Android 5.0 introduces a new
Notification.MediaStyle
template for this purpose.
Notification.MediaStyle
converts notification
actions that you added with
Notification.Builder.addAction()
into compact buttons embedded in your app's
media playback notifications. Pass your session token to the
setSession()
method to inform the system that this notification controls an
ongoing media session.
Make sure to set the notification's visibility to
VISIBILITY_PUBLIC
to mark the notification as safe to show on any lock screen (secure or
otherwise). For more information, see
Lock screen notifications.
To display media playback controls if your app is running on the
Android TV or
Wear platform, implement the
MediaSession
class. You should also implement
MediaSession
if your app needs to receive media
button events on Android devices.
If your app uses getRecentTasks()...
With the introduction of the new concurrent documents and activities
tasks feature in Android 5.0 (see Concurrent
documents and activities in the recents screen below),
the ActivityManager.getRecentTasks()
method is now deprecated to improve user
privacy. For backward compatibility, this method still returns a small subset of
its data, including the calling application’s own tasks and possibly some other
non-sensitive tasks (such as Home). If your app is using this method to retrieve
its own tasks, use getAppTasks()
instead to retrieve that information.
If you are using the Android Native Development Kit (NDK)...
Android 5.0 introduces support for 64-bit systems. The 64-bit enhancement increases address space and improves performance, while still supporting existing 32-bit apps fully. The 64-bit support also improves the performance of OpenSSL for cryptography. In addition, this release introduces new native media NDK APIs, as well as native OpenGL ES (GLES) 3.1 support.
To use the 64-bit support provided in Android 5.0, download and install NDK Revision 10c from the Android NDK page. Refer to the Revision 10c release notes for more information about important changes and bug fixes to the NDK.
If your app binds to a Service...
The
Context.bindService()
method now requires an explicit Intent
,
and throws an exception if given an implicit intent.
To ensure your app is secure, use an explicit intent when starting or binding
your Service
, and do not declare intent filters for the service.
User Interface
Material design support
The upcoming release adds support for Android's new material design style. You can create apps with material design that are visually dynamic and have UI element transitions that feel natural to users. This support includes:
- The material theme
- View shadows
- The
RecyclerView
widget - Drawable animation and styling effects
- Material design animation and activity transition effects
- Animators for view properties based on the state of the view
- Customizable UI widgets and app bars with color palettes that you control
- Animated and non-animated drawables based on XML vector graphics
To learn more about adding material design functionality to your app, see Material Design.
Concurrent documents and activities in the recents screen
In previous releases, the
recents screen
could only display only one task for each app that the user interacted with
most recently. Now your app can open more tasks as needed for additional
concurrent activities for documents. This feature facilitates multitasking by
letting users quickly switch between individual activities and documents from
the recents screen, with a consistent switching experience across all apps.
Examples of such concurrent tasks might include open tabs in a web
browser app, documents in a productivity app, concurrent matches in
a game, or chats in a messaging app. Your app can manage its tasks
through the ActivityManager.AppTask
class.
To insert a logical break so that the system treats your activity as a new
task, use FLAG_ACTIVITY_NEW_DOCUMENT
when
launching the activity with startActivity()
. You can also get this behavior by setting the
<activity>
element's documentLaunchMode
attribute to "intoExisting"
or
"always"
in your manifest.
To avoid cluttering the recents screen, you can set the maximum number of
tasks from your app that can appear in that screen. To do this, set the
<application>
attribute android:maxRecents
. The current
maximum that can be specified is 50 tasks per user (25 for low RAM devices).
Tasks in the recents screen can be set to persist across reboots. To control
the persistence behavior, use the
android:persistableMode
attribute. You can also change
the visual properties of an activity in the recents screen, such as the
activity’s color, label, and icon. To do this, make sure the
android:relinquishTaskIdentity
attribute of the task’s root activity is set
to true
. You can then use the
setTaskDescription()
method to set its appearance properties.
WebView updates
Android 5.0 updates the WebView
implementation to Chromium M37, bringing security and stability enhancements,
as well as bug fixes. The default user-agent string for a
WebView
running on Android 5.0 has
been updated to incorporate 37.0.0.0 as the version number.
This release introduces the PermissionRequest
class,
which allows your app to grant the WebView
permission
to access protected resources like the camera and microphone, through web APIs
such as getUserMedia(). Your app must have the appropriate
Android permissions for these resources in order to grant the permissions to the
WebView
.
With the new onShowFileChooser()
method,
you can now use an input form field in the WebView
,
and launch a file chooser to select images and files from the Android device.
Additionally, this release brings support for the WebAudio, WebGL, and WebRTC open standards. To learn more about the new features included in this release, see WebView for Android.
Screen capturing and sharing
Android 5.0 lets you add screen capturing and screen sharing capabilities to
your app with the new android.media.projection
APIs. This functionality
is useful, for example, if you want to enable screen sharing in a video
conferencing app.
The new createVirtualDisplay()
method
allows your app to capture the contents of the main screen (the default
display) into a Surface
object, which your app can then
send across the network. The API only allows capturing non-secure screen
content, and not system audio. To begin screen capturing, your app must first
request the user’s permission by launching a screen capture dialog using an
Intent
obtained through the
createScreenCaptureIntent()
method.
For an example of how to use the new APIs, see the MediaProjectionDemo
class in the ApiDemos
sample project.
Notifications
Lock screen notifications
Lock screens in Android 5.0 have the ability to present notifications. Users can choose via Settings whether to allow sensitive notification content to be shown over a secure lock screen.
Your app can control the level of detail visible when its notifications are
displayed over the secure lock screen. To control the visibility level, call
setVisibility()
and
specify one of these values:
VISIBILITY_PRIVATE
: Shows basic information, such as the notification’s icon, but hides the notification’s full content.VISIBILITY_PUBLIC
: Shows the notification’s full content.VISIBILITY_SECRET
: Shows nothing, excluding even the notification’s icon.
When the visibility level is VISIBILITY_PRIVATE
,
you can also provide a redacted version of the notification
content that hides personal details. For example, an SMS app might display a
notification that shows "You have 3 new text messages" but hides the message
content and senders. To provide this alternative notification, first create the
replacement notification using Notification.Builder
. When
you create the private notification object, attach the replacement notification
to it through the
setPublicVersion()
method.
Notifications metadata
Android 5.0 uses metadata associated with your app notifications
to sort the notifications more intelligently. To set the metadata, call the
following methods in Notification.Builder
when you
construct the notification:
setCategory()
: Tells the system how to handle your app notifications when the device is in priority mode (for example, if a notification represents an incoming call, instant message, or alarm).setPriority()
: Marks the notification as more or less important than normal notifications. Notifications with the priority field set toPRIORITY_MAX
orPRIORITY_HIGH
appear in a small floating window if the notification also has sound or vibration.addPerson()
: Enables you to add one or more people who are relevant to a notification. Your app can use this to signal to the system that it should group together notifications from the specified people, or rank notifications from these people as being more important.
Graphics
Support for OpenGL ES 3.1
Android 5.0 adds Java interfaces and native support for OpenGL ES 3.1. Key new functionality provided in OpenGL ES 3.1 includes:
- Compute shaders
- Separate shader objects
- Indirect draw commands
- Multisample and stencil textures
- Shading language improvements
- Extensions for advanced blend modes and debugging
- Backward compatibility with OpenGL ES 2.0 and 3.0
The Java interface for OpenGL ES 3.1 on Android is provided with
GLES31
. When using OpenGL ES 3.1, be sure that you
declare it in your manifest file with the
<uses-feature>
tag and the android:glEsVersion
attribute. For example:
<manifest> <uses-feature android:glEsVersion="0x00030001" /> ... </manifest>
For more information about using OpenGL ES, including how to check the device’s supported OpenGL ES version at runtime, see the OpenGL ES API guide.
Android Extension Pack
In addition to OpenGL ES 3.1, this release provides an extension pack with
Java interfaces and native support for advanced graphics functionality. These
extensions are treated as a single package by Android. (If the
ANDROID_extension_pack_es31a
extension is present, your app can
assume all extensions in the package are present and enable the shading language
features with a single #extension
statement.)
The extension pack supports:
- Guaranteed fragment shader support for shader storage buffers, images, and atomics (Fragment shader support is optional in OpenGL ES 3.1.)
- Tessellation and geometry shaders
- ASTC (LDR) texture compression format
- Per-sample interpolation and shading
- Different blend modes for each color attachment in a frame buffer
The Java interface for the extension pack is provided with
GLES31Ext
. In your app manifest, you can declare that
your app must be installed only on devices that support the extension pack.
For example:
<manifest> <uses-feature android:name=“android.hardware.opengles.aep” android:required="true" /> ... </manifest>
Media
Camera API for advanced camera capabilities
Android 5.0 introduces the new
android.hardware.camera2
API to facilitate fine-grain photo capture and image processing. You can now
programmatically access the camera devices available to the system with
getCameraIdList()
and connect to a specific device with
openCamera()
.
To start capturing images, create a CameraCaptureSession
and specify the Surface
objects to send captured images.
The CameraCaptureSession
can be configured to
take single shots or multiple images in a burst.
To be notified when new images are captured, implement the
CameraCaptureSession.CaptureCallback
listener
and set it in your capture request. Now when the system completes the image
capture request, your CameraCaptureSession.CaptureCallback
listener receives a call to
onCaptureCompleted()
,
providing you with the image capture metadata in a
CaptureResult
.
The CameraCharacteristics
class lets your
app detect what camera features are available on a device. The object's
INFO_SUPPORTED_HARDWARE_LEVEL
property represents the camera's level of functionality.
- All devices support at least the
INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY
hardware level, which has capabilities roughly equivalent to that of the deprecatedCamera
API. - Devices that support the
INFO_SUPPORTED_HARDWARE_LEVEL_FULL
hardware level are capable of manual control of capture and post-processing, and capturing high-resolution images at high frame rates.
To see how to use the updated
Camera
API, refer to the Camera2Basic
and Camera2Video
implementation
samples in this release.
Audio playback
This release includes the following changes to
AudioTrack
:
- Your app can now supply audio data in floating-point format
(
ENCODING_PCM_FLOAT
). This permits greater dynamic range, more consistent precision, and greater headroom. Floating-point arithmetic is especially useful during intermediate calculations. Playback endpoints use integer format for audio data, and with lower bit depth. (In Android 5.0, portions of the internal pipeline are not yet floating point.) - Your app can now supply audio data as a
ByteBuffer
, in the same format as provided byMediaCodec
. - The
WRITE_NON_BLOCKING
option can simplify buffering and multithreading for some apps.
Media playback control
Use the new notification and media APIs to ensure that the
system UI knows about your media playback and can extract and show album art.
Controlling media playback across a UI and a service is now easier with the new
MediaSession
and
MediaController
classes.
The new MediaSession
class replaces
the deprecated RemoteControlClient
class and provides a
single set of callback methods for handling transport controls and media buttons.
If your app provides media playback and runs on the Android
TV or
Wear platform, use the
MediaSession
class to handle your transport
controls using the same callback methods.
You can now build your own media controller app with the new
MediaController
class. This class provides
a thread-safe way to monitor and control media playback from your app's UI process.
When creating a controller, specify a MediaSession.Token
object so that your app can interact with the given MediaSession
.
By using the MediaController.TransportControls
methods,
you can send commands such as play()
,
stop()
,
skipToNext()
,
and setRating()
to control media playback on that session. With the controller, you can also
register a MediaController.Callback
object to
listen for metadata and state changes on the session.
In addition, you can create rich notifications that allow playback control
tied to a media session with the new Notification.MediaStyle
class.
Media browsing
Android 5.0 introduces the ability for apps to browse the media content
library of another app, through the new
android.media.browse
API. To expose the media content in your app, extend the
MediaBrowserService
class. Your implementation of
MediaBrowserService
should provide access to a
MediaSession.Token
so that apps can play media content
provided through your service.
To interact with a media browser service, use the
MediaBrowser
class. Specify the component
name for a MediaSession
when you create an
MediaBrowser
instance. Using that browser instance,
your app can then connect to the associated service and obtain a
MediaSession.Token
object to play content exposed
through that service.
Storage
Directory selection
Android 5.0 extends the Storage Access Framework to let users select an entire directory subtree, giving apps read/write access to all contained documents without requiring user confirmation for each item.
To select a directory subtree, build and send an
OPEN_DOCUMENT_TREE
intent. The system displays all
DocumentsProvider
instances that support subtree selection,
letting the user browse and select a directory. The returned URI represents
access to the selected subtree. You can then use buildChildDocumentsUriUsingTree()
and buildDocumentUriUsingTree()
along with
query()
to explore the subtree.
The new createDocument()
method lets you create new documents or directories anywhere
under the subtree. To manage existing documents, use
renameDocument()
and
deleteDocument()
.
Check COLUMN_FLAGS
to verify provider support for these calls before issuing them.
If you're implementing a DocumentsProvider
and want
to support subtree selection, implement isChildDocument()
and include FLAG_SUPPORTS_IS_CHILD
in your COLUMN_FLAGS
.
Android 5.0 also introduces new package-specific directories on
shared storage where your app can place media files for inclusion in
MediaStore
. The new
getExternalMediaDirs()
returns paths to these
directories on all shared storage devices. Similarly to
getExternalFilesDir()
,
no additional permissions are needed by your app to access the returned paths. The
platform periodically scans for new media in these directories, but you can also
use MediaScannerConnection
to explicitly scan for new
content.
Wireless & Connectivity
Multiple network connections
Android 5.0 provides new multi-networking APIs that let your app dynamically scan for available networks with specific capabilities, and establish a connection to them. This functionality is useful when your app requires a specialized network, such as an SUPL, MMS, or carrier-billing network, or if you want to send data using a particular type of transport protocol.
To select and connect to a network dynamically from your app, follow these steps:
- Create a
ConnectivityManager
. - Use the
NetworkRequest.Builder
class to create anNetworkRequest
object and specify the network features and transport type your app is interested in. - To scan for suitable networks, call
requestNetwork()
orregisterNetworkCallback()
, and pass in theNetworkRequest
object and an implementation ofConnectivityManager.NetworkCallback
. Use therequestNetwork()
method if you want to actively switch to a suitable network once it’s detected; to receive only notifications for scanned networks without actively switching, use theregisterNetworkCallback()
method instead.
When the system detects a suitable network, it connects to the network and
invokes the
onAvailable()
callback. You can use the Network
object from the callback to
get additional information about the network, or to direct traffic to use the
selected network.
Bluetooth Low Energy
Android 4.3 introduced platform support for Bluetooth Low Energy (Bluetooth LE) in the central role. In Android 5.0, an Android device can now act as a Bluetooth LE peripheral device. Apps can use this capability to make their presence known to nearby devices. For instance, you can build apps that allow a device to function as a pedometer or health monitor and communicate its data with another Bluetooth LE device.
The new android.bluetooth.le
APIs enable your apps to broadcast
advertisements, scan for responses, and form connections with nearby Bluetooth
LE devices. To use the new advertising and scanning features, add the
BLUETOOTH_ADMIN
permission in your manifest. When users update or download your app from the Play Store,
they are asked to grant the following permission to your app:
"Bluetooth connection information: Allows the app to control Bluetooth,
including broadcasting to or getting information about nearby Bluetooth devices."
To begin Bluetooth LE advertising so that other devices can discover
your app, call
startAdvertising()
and pass in an implementation of the
AdvertiseCallback
class. The callback object
receives a report of the success or failure of the advertising operation.
Android 5.0 introduces the ScanFilter
class so
that your app can scan for only the
specific types of devices it is interested in. To begin scanning for Bluetooth
LE devices, call startScan()
and pass in a list of filters. In the method call, you must also provide an
implementation of ScanCallback
to report when a
Bluetooth LE advertisement is found.
NFC enhancements
Android 5.0 adds these enhancements to enable wider and more flexible use of NFC:
- Android Beam is now available in the share menu.
- Your app can invoke the Android Beam on the user’s device to share data by
calling
invokeBeam()
. This avoids the need for the user to manually tap the device against another NFC-capable device to complete the data transfer. - You can use the new
createTextRecord()
method to create an NDEF record containing UTF-8 text data. - If you are developing a payment app, you now have the ability to
register an NFC application ID (AID) dynamically by calling
registerAidsForService()
. You can also usesetPreferredService()
to set the preferred card emulation service that should be used when a specific activity is in the foreground.
Project Volta
In addition to new features, Android 5.0 emphasizes improvements in battery life. Use the new APIs and tool to understand and optimize your app’s power consumption.
Scheduling jobs
Android 5.0 provides a new JobScheduler
API that lets you optimize battery life by defining jobs for the system to run
asynchronously at a later time or under specified conditions (such as when the
device is charging). Job scheduling is useful in such situations as:
- The app has non-user-facing work that you can defer.
- The app has work you'd prefer to do when the unit is plugged in.
- The app has a task that requires network access or a Wi-Fi connection.
- The app has a number of tasks that you want to run as a batch on a regular schedule.
A unit of work is encapsulated by a JobInfo
object.
This object specifies the scheduling criteria.
Use the JobInfo.Builder
class to configure how the
scheduled task should run. You can schedule the task to run under specific
conditions, such as:
- Start when the device is charging
- Start when the device is connected to an unmetered network
- Start when the device is idle
- Finish before a certain deadline or with a minimum delay
For example, you can add code like this to run your task on an unmetered network:
JobInfo uploadTask = new JobInfo.Builder(mJobId, mServiceComponent /* JobService component */) .setRequiredNetworkCapabilities(JobInfo.NetworkType.UNMETERED) .build(); JobScheduler jobScheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE); jobScheduler.schedule(uploadTask);
If the device has stable power (that is, it has been plugged in for more than 2 minutes and the battery is at a healthy level), the system will run any scheduled job that is ready to run, even if the job’s deadline has not expired.
To see an example of how to use the JobScheduler
API,
refer to the JobSchedulerSample
implementation sample in this release.
Developer tools for battery usage
The new dumpsys batterystats
command generates interesting
statistical data about battery usage on a device, organized by unique user ID
(UID). The statistics include:
- History of battery related events
- Global statistics for the device
- Approximate power use per UID and system component
- Per-app mobile ms per packet
- System UID aggregated statistics
- App UID aggregated statistics
Use the --help
option to learn about the various options for
tailoring the output. For example, to print battery usage
statistics for a given app package since the device was last charged, run this
command:
$ adb shell dumpsys batterystats --charged <package-name>
You can use the
Battery Historian
tool on the output of the dumpsys
command to
generate an HTML visualization of power-related events from the logs. This
information makes it easier for you to understand and diagnose any battery
related issues.
Android in the Workplace and in Education
Managed provisioning
![](../../images/android-5.0/managed_apps_launcher.png)
Figure 2. Launcher screen showing managed apps (marked with a lock badge)
Android 5.0 provides new functionality for running apps within an enterprise environment. A device administrator can initiate a managed provisioning process to add a copresent but separate managed profile to a device, if the user has an existing personal account. Apps that are associated with managed profiles appear alongside non-managed apps in the user’s Launcher, recents screen, and notifications.
To start the managed provisioning process, send
ACTION_PROVISION_MANAGED_PROFILE
in an Intent
. If the
call is successful, the system triggers the
onProfileProvisioningComplete()
callback.
You can then call setProfileEnabled()
to
enable this managed profile.
By default, only a small subset of apps are enabled in the managed profile.
You can install additional apps in the managed profile by calling
enableSystemApp()
.
If you are developing a Launcher app, you can use the new LauncherApps
class to get a list of launchable activities
for the current user and any associated managed profiles. Your Launcher can make
the managed apps visually prominent by appending a work badge to the icon
drawable. To retrieve the badged icon, call
getUserBadgedIcon()
.
To see how to use the new functionality, refer to the
BasicManagedProfile
implementation sample in this release.
Device owner
Android 5.0 introduces the ability to deploy a device owner app. A device
owner is a specialized type of
device administrator
that has the additional ability to create and remove secondary users and to
configure global settings on the device. Your device owner app can use the
methods in the DevicePolicyManager
class to take
fine-grain control of the configuration, security, and apps on managed devices.
A device can have only one active device owner at a time.
To deploy and activate a device owner, you must perform an NFC data transfer from a programming app to the device while the device is in its unprovisioned state. This data transfer sends the same information as in the provisioning intent described in Managed provisioning.
Screen pinning
Android 5.0 introduces a new screen pinning API that lets you temporarily restrict users from leaving your task or being interrupted by notifications. This could be used, for example, if you are developing an education app to support high stakes assessment requirements on Android, or a single-purpose or kiosk application. Once your app activates screen pinning, users cannot see notifications, access other apps, or return to the home screen, until your app exits the mode.
There are two ways to activate screen pinning:
- Manually: Users can enable screen pinning in Settings > Security > Screen Pinning, and select the tasks they want to pin by touching the green pin icon in the recents screen.
- Programmatically: To activate screen pinning
programmatically, call
startLockTask()
from your app. If the requesting app is not a device owner, the user is prompted for confirmation. A device owner app can call thesetLockTaskPackages()
method to enable apps to be pinnable without the user confirmation step.
When task locking is active, the following behavior happens:
- The status bar is blank, and user notifications and status information are hidden.
- The Home and Recent Apps buttons are hidden.
- Other apps cannot launch new activities.
- The current app can start new activities, as long as doing so does not create new tasks.
- When screen pinning is invoked by a device owner, the user remains locked
to your app until the app calls
stopLockTask()
. - If screen pinning is activity by another app that is not a device owner or by the user directly, the user can exit by holding both the Back and Recent buttons.
Printing Framework
Render PDF as bitmap
You can now render PDF document pages into bitmap images for printing by
using the new PdfRenderer
class. You must specify a
ParcelFileDescriptor
that is seekable (that is, the content
can be randomly accessed) on which the system writes the the printable content.
Your app can obtain a page for rendering with
openPage()
, then call
render()
to turn the opened PdfRenderer.Page
into a bitmap. You
can also set additional parameters if you only want to convert a portion of the
document into a bitmap image (for example, to implement
tiled rendering
to zoom in on the document).
For an example of how to use the new APIs, see the PdfRendererBasic
sample.
System
App usage statistics
You can now access app usage history on an Android device with the
new android.app.usage
API. This API provides more detailed usage
information than the deprecated
getRecentTasks()
method.
To use this API, you must first declare the
"android.permission.PACKAGE_USAGE_STATS"
permission in your manifest.
The user must also enable access for this app through Settings > Security > Apps
with usage access.
The system collects the usage data on a per-app basis, aggregating the data over daily, weekly, monthly, and yearly intervals. The maximum duration that the system keeps this data is as follows:
- Daily data: 7 days
- Weekly data: 4 weeks
- Monthly data: 6 months
- Yearly data: 2 years
For each app, the system records the following data:
- The last time the app was used
- The total length of time the app was in the foreground for that time interval (by day, week, month, or year)
- Timestamp capturing when a component (identified by a package and activity name) moved to the foreground or background during a day
- Timestamp capturing when a device configuration changed (such as when the device orientation changed because of rotation)
Testing & Accessibility
Testing and accessibility improvements
Android 5.0 adds the following support for testing and accessibility:
- The new
getWindowAnimationFrameStats()
andgetWindowContentFrameStats()
methods capture frame statistics for window animations and content. These methods let you write instrumentation tests to evaluate whether an app is rendering frames at a sufficient refresh frequency to provide a smooth user experience. - The new
executeShellCommand()
method lets you execute shell commands from your instrumentation test. The command execution is similar to runningadb shell
from a host connected to the device, allowing you to use shell-based tools such asdumpsys
,am
,content
, andpm
. - Accessibility services and test tools that use the accessibility APIs
(such as
UiAutomator
) can now retrieve detailed information about the properties of windows on the screen that sighted users can interact with. To retrieve a list ofAccessibilityWindowInfo
objects, call the newgetWindows()
method. - The new
AccessibilityNodeInfo.AccessibilityAction
class lets you define standard or customized actions to perform on anAccessibilityNodeInfo
. The newAccessibilityNodeInfo.AccessibilityAction
class replaces the actions-related APIs previously found inAccessibilityNodeInfo
. - Android 5.0 provides finer-grain control over text-to-speech synthesis in
your app. The new
Voice
class allows your app to use voice profiles associated with specific locales, quality and latency rating, and text-to-speech engine-specific parameters.
IME
Easier switching between input languages
Beginning in Android 5.0, users can more easily switch between
all input
method editors (IME) supported by the platform. Performing the designated
switching action (usually touching a Globe icon on the soft keyboard) cycles
through all such IMEs. This change in behavior is implemented by the
shouldOfferSwitchingToNextInputMethod()
method.
In addition, the framework now checks whether the next IME includes a
switching mechanism at all (and, thus, whether that IME supports switching to
the IME after it). An
IME with a switching mechanism will not cycle to an IME without one. This
change in behavior is implemented by the
switchToNextInputMethod()
method.
To see an example of how to use the updated IME-switching APIs, refer to the updated soft-keyboard implementation sample in this release. To learn more about how to implement switching between IMEs, see Creating an Input Method.
Manifest Declarations
Declarable required features
The following values are now supported in the
<uses-feature>
element, so you can ensure that your app is installed only on devices that
provide the features your app needs.
FEATURE_AUDIO_OUTPUT
FEATURE_CAMERA_CAPABILITY_MANUAL_POST_PROCESSING
FEATURE_CAMERA_CAPABILITY_MANUAL_SENSOR
FEATURE_CAMERA_CAPABILITY_RAW
FEATURE_CAMERA_LEVEL_FULL
FEATURE_GAMEPAD
FEATURE_LIVE_TV
FEATURE_MANAGED_USERS
FEATURE_LEANBACK
FEATURE_OPENGLES_EXTENSION_PACK
FEATURE_SECURELY_REMOVES_USERS
FEATURE_SENSOR_AMBIENT_TEMPERATURE
FEATURE_SENSOR_HEART_RATE_ECG
FEATURE_SENSOR_RELATIVE_HUMIDITY
FEATURE_VERIFIED_BOOT
FEATURE_WEBVIEW
User permissions
The following permissions are now supported in the
<uses-permission>
element to declare the permissions your app requires to access certain APIs.
BIND_DREAM_SERVICE
: When targeting API level 21 and higher, this permission is required by a Daydream service, to ensure that only the system can bind to it.READ_VOICEMAIL
: Required to allow your app to read voicemails in the system.WRITE_VOICEMAIL
: Required to allow your app to modify and remove existing voicemails in the system.
For a detailed view of all API changes in Android 5.0, see the API Differences Report.