Key Developer Features
- User Experience
- Autofill framework
- Picture-in-Picture mode
- Emoji compatibility
- Downloadable Fonts
- Fonts in XML
- Autosizing TextView
- Adaptive icons
- Color management
- WebView APIs
- Pinning shortcuts and widgets
- Maximum screen aspect ratio
- Multi-display support
- Unified layout margins and padding
- Pointer capture
- App categories
- Android TV launcher
- Media enhancements
- Security & Privacy
- Runtime & Tools
- Android enterprise
Android O introduces a variety of new features and capabilities for users and developers. This document highlights what's new for developers.
Make sure to check out Android O Behavior Changes to learn about areas where platform changes may affect your apps.
In Android O, we've redesigned notifications to provide an easier and more consistent way to manage notification behavior and settings. These changes include:
- Notification channels: Android O introduces notification channels that allow you to create a user-customizable channel for each type of notification you want to display. The user interface refers to notification channels as notification categories. To learn how to implement notification channels, see the Notification Channels guide.
- Notification badges: Android O introduces support for displaying notification badges on app launcher icons. Notification badges reflect the presence of notifications associated with an app, which the user has not yet dismissed or acted on. Notification badges are also known as notification dots. To learn how to adjust notification badges, see the Notification Badges guide.
- Snoozing: Users can snooze notifications to reappear at a later time. Notifications reappear with the same level of importance they first appeared with. Apps can remove or update a snoozed notification, but updating a snoozed notification does not cause it to reappear.
- Notification timeouts: You can now set a timeout when creating a
Notification.Builder.setTimeout(). You can use this method to specify a duration after which a notification should be cancelled. If required, you can cancel a notification before the specified timeout duration elapses.
- Notification settings: You can call
setSettingsText()to set text to appear when you create a link to your app's notification settings from a notification using the
Notification.INTENT_CATEGORY_NOTIFICATION_PREFERENCESintent. The system may provide the following extras with the intent to filter the settings your app must display to users:
- Notification dismissal: The system now distinguishes whether a
notification is dismissed by a user, or removed by an app. To check how
notifications are dismissed, you should implement the new
onNotificationRemoved()method of the
- Background colors: You can now set and enable a background color for a
notification. You should only use this feature in notifications for
ongoing tasks which are critical for a user to see at a glance. For
example, you could set a background color for notifications related to
driving directions, or a phone call in progress. You can also set the
desired background color using
Notification.Builder.setColor(). Doing so allows you to use
Notification.Builder.setColorized()to enable the use of a background color for a notification.
- Messaging style: Notifications that use the
MessagingStyleclass now display more content in their collapsed form. You should use the
MessagingStyleclass for notifications that are messaging-related. You can also use the new
addHistoricMessage()method to provide context to a conversation by adding historic messages to messaging related notifications.
Account creation, login, and credit card transactions take time and are prone to errors. Users can easily get frustrated with apps that require these types of repetitive tasks.
Android O makes filling out forms, such as login and credit card forms, easier with the introduction of the Autofill Framework. Existing and new apps work with Autofill Framework after the user opts in to autofill.
You can take some steps to optimize how your app works with the framework. For more information, see Autofill Framework Overview.
Android O allows activities to launch in picture-in-picture (PIP) mode. PIP is a special type of multi-window mode mostly used for video playback. PIP mode is already available for Android TV; Android O makes the feature available on other Android devices.
When an activity is in PIP mode, it is in the paused state, but should
continue showing content. For this reason, you should make sure your app
does not pause playback in its
handler. Instead, you should pause video in
onStop(), and resume playback in
onStart(). For more information, see
To specify that your activity can use PIP mode, set
android:supportsPictureInPicture to true in the manifest.
(Beginning with Android O, you do not need to set
android:resizeableActivity to true if you are supporting PIP mode,
either on Android TV or on other Android devices; you only need to set
android:resizeableActivity if your activity supports other
Android O introduces a new object,
which you pass to PIP methods to specify how an activity should behave
when it is in PIP mode. This object specifies properties such as the
activity's preferred aspect ratio.
The existing PIP methods described in Adding Picture-in-picture can now be used on all Android devices, not just on Android TV. In addition, Android O provides the following methods to support PIP mode:
Activity.enterPictureInPictureMode(): Places the activity in picture-in-picture mode. The activity's aspect ratio and other configuration settings are specified by args. If any fields in args are empty, the system uses the values set the last time you called
The specified activity is placed in a corner of the screen; the rest of the screen is filled with the previous activity that was on screen. The activity entering PIP mode goes into the paused state, but remains started. If the user taps the PIP activity, the system shows a menu for the user to interact with; no touch events reach the activity while it is in the PIP state.
Activity.setPictureInPictureArgs()Updates an activity's PIP configuration settings. If the activity is currently in PIP mode, the settings are updated; this is useful if activity's aspect ratio changes. If the activity is not in PIP mode, these configuration settings are used regardless of the
enterPictureInPictureMode()method that you call.
EmojiCompat support library prevents your app from showing
missing emoji characters. Your app users do not need to wait for Android OS
updates to get the latest emoji. The library provides classes to implement
backward-compatible emoji support on devices running Android 4.4
(API level 19) and higher.
For more information about using the
EmojiCompat support library,
Android O and Android Support Library 26 let you request fonts from a provider application instead of bundling fonts into the APK or letting the APK download fonts. This feature reduces your APK size, increases the app installation success rate, and allows multiple apps to share the same font.
For more information about downloading fonts, refer to Downloadable Fonts.
Fonts in XML
Android O introduces a new feature, Fonts in XML, which
lets you use fonts as resources. This means, there is no need to bundle fonts
as assets. Fonts are compiled in
R file and are automatically
available in the system as a resource. You can then access these fonts with the
help of a new resource type,
The Support Library 26 provides full support to this feature on devices running API versions 14 and higher.
For more information, about using fonts as resources and retrieving system fonts, see Fonts in XML.
Android O lets you set the size of your text expand or contract automatically based on the size of the TextView. This means, it is much easier to optimize the text size on different screens or with dynamic content. For more information, about autosizing TextView in Android O, see Autosizing TextView.
Android O introduces adaptive launcher icons. Adaptive icons support visual effects, and can display a variety of shapes across different device models. To learn how to create adaptive icons, see the Adaptive Icons preview feature guide.
Android developers of imaging apps can now take advantage of new devices that have a wide-gamut color capable display. To display wide gamut images, apps will need to enable a flag in their manifest (per activity) and load bitmaps with an embedded wide color profile (AdobeRGB, Pro Photo RGB, DCI-P3, etc.).
Android O provides several APIs to help you manage
WebView objects that display web content in your app.
These APIs, which improve your app's stability and security, include the
- Version API
- Google SafeBrowsing API
- Termination Handle API
- Renderer Importance API
To learn more about how to use these APIs, see Managing WebViews.
Pinning shortcuts and widgets
Android O introduces in-app pinning of shortcuts and widgets. In your app, you can create pinned shortcuts and widgets for supported launchers, subject to user permission.
For more information, see the Pinning Shortcuts and Widgets preview feature guide.
Maximum screen aspect ratioApps that target Android 7.1 (API level 25) or lower have a default maximum screen aspect ratio of 1.86. Apps targeting Android O or higher do not have a default maximum aspect ratio. If your app needs to set a maximum aspect ratio, use the maxAspectRatio attribute in the manifest file that defines your Activity.
Beginning with Android O, the platform offers enhanced support for multiple displays. If an activity supports multi-window mode and is running on a device with multiple displays, users can move the activity from one display to another. When an app launches an activity, the app can specify which display the activity should run on.
Note: If an activity supports multi-window mode, Android O automatically enables multi-display support for that activity. You should test your app to make sure it works adequately in a multi-display environment.
Only one activity at a time can be in the resumed state, even if the app has multiple displays. The activity with focus is in the resumed state; all other visible activities are paused, but not stopped. For more information on the activity lifecycle when several activities are visible, see Multi-Window Lifecycle.
When a user moves an activity from one display to another, the system resizes the activity and issues runtime changes as necessary. Your activity can handle the configuration change itself, or it can allow the system to destroy the process containing your activity and recreate it with the new dimensions. For more information, see Handling Configuration Changes.
ActivityOptions provides two new methods to support
- Specifies which display the activity should be shown on when it is launched.
- Returns the activity's current launch display.
The adb shell is extended to support multiple displays.
shell start command can now be used to launch an activity,
and to specify the activity's target display:
adb shell start <activity_name> --display <display_id>
Unified layout margins and padding
Android O makes it easier for you to specify situations where opposite sides
View element use the same margin or padding.
Specifically, you can now use the following attributes in your layout XML
layout_marginVertical, which defines
layout_marginBottomat the same time.
layout_marginHorizontal, which defines
layout_marginRightat the same time.
paddingVertical, which defines
paddingBottomat the same time.
paddingHorizontal, which defines
paddingRightat the same time.
Note: If you customize your app's logic to
languages and cultures, including text direction, keep in mind that these
attributes don't affect the values of
paddingEnd. You can set these values yourself, in addition to
the new vertical and horizontal layout attributes, to create layout behavior
that depends on the text direction.
Some apps, such as games, remote desktop, and virtualization clients, greatly benefit from getting control over the mouse pointer. Pointer capture is a new feature in Android O that provides such control by delivering all mouse events to a focused view in your app.
Starting in Android O, a
View in your app can request
pointer capture and define a listener to process captured pointer events. The
mouse pointer is hidden while in this mode. The view can release pointer capture
when it doesn't need the mouse information anymore. The system can also release
pointer capture when the view loses focus, for example, when the user opens
For information on how to use this feature in your app, see Pointer capture.
Android O allows each app to declare a category that it fits
into, when relevant. These categories are used to cluster together apps of similar
purpose or function when presenting them to users, such as in Data Usage, Battery Usage, or
Storage Usage. You can define a category for your app by setting the
android:appCategory attribute in your
Android TV launcher
Android O includes a new content-centric, Android TV home screen experience, which is available with the Android TV emulator and Nexus Player device image for Android O. The new home screen organizes video content in rows corresponding to channels, which are each populated with programs by an app on the system. Apps can publish multiple channels, and users can configure which channels that they wish to see on the home screen. The Android TV home screen also includes a Watch Next row, which is populated with programs from apps, based on the viewing habits of the user. Apps can also provide video previews, which are automatically played when a user focuses on a program. The APIs for populating channels and programs are part of the TvProvider APIs, which are distributed as a Android Support Library module with Android O.
Starting in Android O, the
AnimatorSet API now supports seeking and playing in
reverse. Seeking lets you set the position of the animation set to a specific
point in time. Playing in reverse is useful if your app includes animations
for actions that can be undone. Instead of defining two separate animation
sets, you can play the same one in reverse.
New StrictMode detectors
Android O adds three new StrictMode detectors to help identify potential bugs in your app:
detectUnbufferedIo()will detect when your app reads or writes data without buffering, which can drastically impact performance.
detectContentUriWithoutPermission()will detect when your app accidentally forgets to grant permissions to another app when starting an Activity outside your app.
detectUntaggedSockets()will detect when your app performs network traffic without using
setThreadStatsTag(int)to tag your traffic for debugging purposes.
Android O gives better guidance and behaviors around cached data. Each
app is now given a disk space quota for cached data, as returned by
When the system needs to free up disk space, it will start by deleting cached files from apps that are the most over their allocated quota. Thus, if you keep your cached data under your allocated quota, your cached files will be some of the last on the system to be cleared when necessary. When the system is deciding what cached files to delete inside your app, it will consider the oldest files first (as determined by modified time).
There are also two new behaviors that you can enable on a per-directory basis to control how the system frees up your cached data:
StorageManager.setCacheBehaviorAtomic()can be used to indicate that a directory and all of its contents should be deleted as a single atomic unit.
setCacheBehaviorTombstone(File, boolean)can be used to indicate that instead of deleting files inside a directory, they should be truncated to be 0 bytes in length, leaving the empty file intact.
Finally, when you need to allocate disk space for large files, consider using the new
allocateBytes(FileDescriptor, long) API, which will automatically clear
cached files belonging to other apps (as needed) to meet your request. When deciding if the
device has enough disk space to hold your new data, call
getAllocatableBytes(UUID) instead of using
getUsableSpace(), since the former will consider any cached
data that the system is willing to clear on your behalf.
Content provider paging
We've updated content providers to include support for loading a large dataset one page at a time. For example, a photo app with many thousands of images can query for a subset of the data to present in a page. Each page of results returned by a content provider is represented by a single Cursor object. Both a client and a provider must implement paging to make use of this feature.
Content refresh requests
You can add custom content refreshing logic by extending
ContentProvider. Make sure that you override the
refresh() method to return
true, indicating to your provider's clients that you've attempted
to refresh the data yourself.
Your client app can explicitly request refreshed content by calling a
different method, also called
refresh(). When calling this
method, pass in the URI of the data to refresh.
Note: Because you may be requesting data over a network,
you should invoke
the client side only when there's a strong indication that the content is stale.
The most common reason to perform this type of content refresh is in response to
gesture, explicitly requesting the current UI to display up-to-date content.
Android O introduces a number of improvements to
JobScheduler. These improvements make it easier for your app
to comply with the new background
execution limits, since you can generally use scheduled jobs to replace
the now-restricted background services or implicit broadcast receivers.
You can now associate a work queue with a scheduled job. To add a work item to
a job's queue, call
JobScheduler.enqueue(). When the job is running, it can take pending work off the queue and process it. This functionality handles many of the use cases that previously would have called for starting a background service, particulary services that implement
You can now call
JobInfo.Builder.setClipData()to associate a
ClipDatawith a job. This option enables you to associate URI permission grants with a job, similarly to how these permissions can be propogated to
Context.startService(). You can also use URI permission grants with intents on work queues.
Scheduled jobs now support several new constraints:
- Job does not run if the device's available storage is low.
- Job does not run if the battery level is at or below the criticial threshold; this is the level at which the device shows the Low battery warning system dialog.
- Job requires a metered network connection, like most cellular data plans.
Custom data store
Android O lets you provide a custom data store to your preferences, which can be useful if your app stores the preferences in a cloud or local database, or if the preferences are device-specific. For more information about implementing the data store, refer to Custom Data Store.
findViewById() signature change
All instances of the
findViewById() method now return
<T extends View> T instead of
View. This change
has the following implications:
- This may result in existing code now having ambiguous return type,
for example if there is both
someMethod(TextView)that takes the result of a call to
- When using Java 8 source language, this requires an explicit cast to
Viewwhen the return type is unconstrained (for example,
- Overrides of non-final
findViewById()methods (for example,
Activity.findViewById()) will need their return type updated.
There is a new VolumeShaper class. You can use it to perform short automated volume transitions like fade-ins, fade-outs, and cross fades.
Audio Focus Enhancements
Audio apps share the audio output on a device by requesting and abandoning audio focus.
An app handles changes in focus by starting or stopping playback, or ducking its volume.
There is a new
With this class, apps have new capabilites
when handling changes in audio focus:
automatic ducking and
delayed focus gain.
getMetrics() method returns a
object containing configuration
and performance information, expressed as a map of attributes and values.
getMetrics() method is defined for these media classes:
Metrics are collected separately for each instance and persist for the lifetime of the instance. If no metrics are available the method returns null. The actual metrics returned depend on the class.
Android O adds several new methods to the MediaPlayer class. These methods can improve your app's handling of media playback in several ways:
- MediaRecorder now supports the MPEG2_TS format which is useful for
MediaMuxercan now handle any number of audio and video streams. You are no longer limited to one audio track and/or one video track. Use
addTrack()to mix as many tracks as you like.
MediaMuxercan also add one or more metadata tracks containing user-defined per-frame information. The format of the metadata is defined by your application. The metadata track is only supported for MP4 containers.
Metadata can be useful for offline processing. For example, gyro signals from the sensor could be used to perform video stabilization.
When adding a metadata track, the track's mime format must start with the prefix
"application/". Writing metadata is the same as writing video/audio data except
that the data does not come from a
MediaCodec. Instead, the app passes a
ByteBuffer with an associated timestamp to the
The timestamp must be in the same time base as the video and audio tracks.
The generated MP4 file uses the
TextMetaDataSampleEntry defined in section
220.127.116.11 of the ISOBMFF to signal the metadata's mime format. When using
MediaExtractor to extract the file with metadata track, the mime
format of the metadata will be extracted into
Audio playback control
Android O allows you to query and request how a device is producing sound. The following aspects of control over audio playback make it easier for your service to produce sound only under favorable device conditions.
New audio usage type for Google Assistant
Changes to device audio playback
If you want your service to begin producing sound only when a specific device
audio configuration is active, you can use the
AudioManager class to register an instance of
onPlaybackConfigChanged() method helps you identify the currently-active set
of audio attributes.
Explicit requests for audio focus
Your service can submit a more fine-grained request for receiving device-wide
audio focus by using the
requestAudioFocus() method. Pass in an
which you create using
AudioFocusRequest.Builder. In this builder
class, you can specify the following options:
- The type of focus you wish to gain, such as
- Whether your service should continue more quietly or pause completely when another audio service takes over device focus.
- Whether your service can wait to gain focus until the device is ready.
Note: When building your instance of
you indicate that your service can wait to produce sound by calling
setAcceptsDelayedFocusGain(), you must also call
setOnAudioFocusChangeListener() so that your service knows when it
can begin producing sound.
Improved media file access
Storage Access Framework (SAF) allows apps to expose a custom
DocumentsProvider, which can provide access to files
in a data source to other apps. In fact, a
documents provider can even provide access to files
that reside on network storage or that use a protocol like
Media Transfer Protocol (MTP).
However, accessing large media files from a remote data source introduces some challenges:
- Media players require seekable access to a file from a documents provider. In cases where a large media file resides on a remote data source, the documents provider must fetch all of the data in advance and create a snapshot file descriptor. The media player cannot play the file without the file descriptor, thus playback cannot begin until the documents provider finishes downloading the file.
- Media collection managers, such as photo apps, must traverse a series of access URIs to reach media that's stored on an external SD card via scoped folders. This access pattern makes mass operations on media—such as moving, copying, and deleting—quite slow.
- Media collection managers cannot determine a document's location given its URI. This makes it difficult for these types of apps to allow users to choose where to save a media file.
Android O addresses each of these challenges by improving the Storage Access Framework.
Custom document providers
Starting in Android O, the Storage Access Framework allows custom documents providers to create seekable file descriptors for files residing in a remote data source. The SAF can open a file to get a native seekable file descriptor. The SAF then delivers discrete bytes requests to the documents provider. This feature allows a documents provider to return the exact range of bytes that a media player app has requested instead of caching the entire file in advance.
To use this feature, you need to call the new
StorageManager.openProxyFileDescriptor() method. The
openProxyFileDescriptor() method accepts a
ProxyFileDescriptorCallback object as a callback. The SAF invokes
the callback any time a client application performs file operations on the
file descriptor returned from the documents provider.
Direct document access
As of Android O, you can use the
getDocumentUri() method to
get a URI that references the same document as the given
However, because the returned URI is backed by a
DocumentsProvider, media collection managers can access
the document directly, without having to traverse trees of scoped directories.
As a result, the media managers can perform file operations on the document
significantly more quickly.
getDocumentUri() method only locates media files; it doesn't grant apps
permission to access those files. To learn more about how to obtain access
permission to media files, see the reference documentation.
Paths to documents
When using the Storage Access Framework in Android O, you can use the
findDocumentPath() method, available in both
classes, to determine the path from the root of a file system given a document's
ID. The method returns this path in a
DocumentsContract.Path object. In cases where a file
system has multiple defined paths to the same document, the method returns the
path that is used most often to reach the document with the given ID.
This functionality is particularly useful in the following scenarios:
- Your app uses a "save as" dialog that displays the location of a particular document.
- Your app shows folders in a search results view and must load the child documents that are within a particular folder if the user selects that folder.
Note: If your app has permission to access only some of the documents
in the path, the return value of
findDocumentPath() includes only
the folders and documents that your app can access.
Android O adds support for Wi-Fi Aware, which is based on the Neighbor Awareness Networking (NAN) specification. On devices with the appropriate Wi-Fi Aware hardware, apps and nearby devices can discover and communicate over Wi-Fi without an Internet access point. We're working with our hardware partners to bring Wi-Fi Aware technology to devices as soon as possible. For information on how to integrate Wi-Fi Aware into your app, see Wi-Fi Aware.
Android O enriches the platform's Bluetooth support by adding the following features:
- Support for the AVRCP 1.4 standard, which enables song-library browsing.
- Support for the Bluetooth Low-Energy (BLE) 5.0 standard.
- Integration of the Sony LDAC codec into the Bluetooth stack.
Companion device pairing
Android O provides APIs that allow you to customize the pairing request dialog when trying to pair with companion devices over Bluetooth, BLE, and Wi-Fi. For more information, see Companion Device Pairing.
For more information about using Bluetooth on Android, see the Bluetooth guide. For changes to Bluetooth that are specific to Android O, see the Bluetooth section of the Android O Behavior Changes page.
Android O learns about users' personalized sharing preferences and better understands for each type of content which are the right apps to share with. For example, if a user takes a photo of a receipt, Android O can suggest an expense-tracking app; if the user takes a selfie, a social media app can better handle the image. Android O automatically learns all these patterns according to users' personalized preferences.
Smart sharing works for types of content other than
image, such as
To enable Smart sharing, add an
ArrayList of up to three
string annotations to the intent that shares the content. The annotations should
describe the major components or topics in the content. The following code example
shows how to add annotations to the intent:
ArrayList<String> annotations = new ArrayList<>(); annotations.add("topic1"); annotations.add("topic2"); annotations.add("topic3"); intent.putStringArrayListExtra( Intent.EXTRA_CONTENT_ANNOTATIONS, annotations );
For detailed information about Smart sharing annotations, see
Smart text selection
On compatible devices, Android O enables apps to help users interact with text in more meaningful ways. When users long-press on a word in an entity—a recognized format like an address or restaurant name, for example—the system selects the whole entity. The user sees a floating toolbar that might include an app that can handle the selected text entity. For example, if the system recognizes an address, it can direct the user towards the Maps app.
Entities recognized by the system include addresses, URLs, telephone numbers,
and email addresses. For more information, see
Android O supports the following accessibility features for developers who create their own accessibility services. To learn more about how to make your app more accessible, see Accessibility.
Your accessibility service can now request that an
accessibility button appear within the system's navigation area,
which gives users a quick way to activate your service's functionality from
anywhere on their device. To do so, add the
flag in an
android:accessibilityFlags attribute. You can then register
Note: This feature is available only on devices that
provide a software-rendered navigation area. Always use
isAccessibilityButtonAvailable(), and respond to changes based on the
availability of the accessibility button by implementing
onAvailabilityChanged(). That way, users can always access your service's
functionality, even if the accessibility button isn't supported or becomes
Independent volume adjusting
Android O introduces the
STREAM_ACCESSIBILITY volume category, which
allows you to control the volume of your accessibility service's audio output
independently of other sounds on the device.
To use this new stream type to control accessibility volume, set the
option within your accessibility service. You can then change the device's
accessibility audio volume using
Your accessibility service can also respond to an alternative input mechanism, directional swipes (up, down, left, and right) along a device's fingerprint sensor. To receive callbacks about these interactions, complete the following sequence of steps:
- Declare the
USE_FINGERPRINTpermission and the
- Set the
AccessibilityServiceInfo.FLAG_CAPTURE_FINGERPRINT_GESTURESflag within the
- Register for callbacks using
Keep in mind that not all devices include fingerprint sensors. You can use
method to identify whether a device supports the sensor. Even on devices that
include a fingerprint sensor, your service can use the sensor only when it's
not in use for authentication purposes. To identify when the sensor is
available, call the
method and implement the
To determine the locations of visible characters in a
TextView object, you can pass in
as the first argument into
Bundle object, which you provide as the second argument
is then updated to include a parcelable array of
Rect object represents the bounding box
of a particular character.
If your service uses a
TextToSpeech object to
dictate the content that appears on-screen, you can obtain more precise timing
information about when text-to-speech engines begin speaking individual
synthesized words, as long as the text-to-speech engine provides this
information. When an engine expects to begin playing audio for a specific
range of text, the text-to-speech API notifies your service that speech for
the range of text is beginning using the
Standardized one-sided range values
Some instances of
AccessibilityNodeInfo use an instance of
AccessibilityNodeInfo.RangeInfo to indicate that a UI element can take on a
range of values. When creating a range using
RangeInfo.obtain(), or when retrieving the extreme values of the range
getMax(), keep in mind that Android O has standardized definitions of
- For ranges with no minimum,
Float.NEGATIVE_INFINITYrepresents the minimum value.
- For ranges with no maximum,
Float.POSITIVE_INFINITYrepresents the maximum value.
Android O includes several methods for interacting with a text-editable object's hint text:
setShowingHintText()methods indicate and set, respectively, whether the node's current text content represents the node's hint text. If the node doesn't contain editable text, it should never contain hint text.
- To access the hint text itself, use
getHintText(). Even if an object isn't currently displaying hint text, a call to
Continued gesture dispatch
Your service can now specify sequences of strokes that belong to the same
programmatic gesture by using the final argument,
Security & Privacy
Android O introduces several new permissions related to telephony:
ANSWER_PHONE_CALLSpermission allows your app to answer incoming phone calls programmatically. To handle an incoming phone call in your app, you can use the
READ_PHONE_NUMBERSpermission grants your app read access to the phone numbers stored in a device.
New account access and discovery APIs
Android O introduces several improvements to how apps get access to user accounts. For the accounts that they manage, authenticators can use their own policy to decide whether to hide accounts from, or reveal accounts to, an app. The Android system tracks applications which can access a particular account.
In previous versions of Android, apps that wanted to track the list of
user accounts had to get updates about all accounts, including accounts with
unrelated types. Android O adds the
addOnAccountsUpdatedListener(android.accounts.OnAccountsUpdateListener, android.os.Handler, boolean, java.lang.String)
method, which lets apps specify a list of account types
for which account changes should be received.
AccountManager provides six new methods to help authenticators manage which apps can see an account:
setAccountVisibility(android.accounts.Account, java.lang.String, int): Sets the level of visibility for a specific user account and package combination.
getAccountVisibility(android.accounts.Account, java.lang.String): Gets the level of visibility for a specific user account and package combination.
getAccountsAndVisibilityForPackage(java.lang.String, java.lang.String): Allows authenticators to get the accounts and levels of visibility for a given package.
getPackagesAndVisibilityForAccount(android.accounts.Account): Allows authenticators to get stored visibility values for a given account.
addAccountExplicitly(android.accounts.Account, java.lang.String, android.os.Bundle, java.util.Map<java.lang.String, java.lang.Integer>): Allows authenticators to initialize the visibility values of an account.
addOnAccountsUpdatedListener(android.accounts.OnAccountsUpdateListener, android.os.Handler, boolean, java.lang.String): Adds an
OnAccountsUpdateListenerlistener to the
AccountManagerobject. The system calls this listener whenever the list of accounts on the device changes.
Android O introduces two special Package Name values to specify visibility
levels for applications which were not set using the
setAccountVisibility(android.accounts.Account, java.lang.String, int)
visibility value is applied to apps that have the
permission, and target versions of
Android lower than Android O, or whose
signatures match the authenticator targeting any Android version.
provides a default visibility value for
apps which were not set previously and for which
PACKAGE_NAME_KEY_LEGACY_VISIBLE is not
Google Safe Browsing API
Android O provides the following pieces of additional support for your app's instrumentation tests.
Run against non-default app processes
You can now specify that a particular instrumentation test should run against a process outside your app's default process. This configuration is useful if your app contains multiple activities that run in different processes.
To define non-default process instrumentation, navigate to your manifest
file, then to the desired
<instrumentation> element. Add the
android:targetProcess attribute, and set its value to one of
- The name of a particular process.
- A comma-separated list of process names.
- A wildcard (
"*"), which allows the instrumentation to run against any launched process that executes code in the package specified in the
While your instrumentation test is executing, you can check which process
it's testing by calling
Report results during a test
You can now report results while your instrumentation test is executing,
rather than afterward, by calling
Mock intents for tests
To make it easier to create isolated, independent UI tests for your app's
activities, Android O introduces the
ActivityMonitor.onMatchIntent() method. You override this method in a custom subclass of the
Instrumentation.ActivityMonitor class to handle a particular
intent that your test class invokes.
When your test class invokes the intent, the method returns a stub
Instrumentation.ActivityResult object instead of executing
the intent itself. By using this mock intent logic in your tests, you can focus
on how your activity prepares and handles the intent that you pass to a
different activity or to an entirely different app.
Runtime & Tools
Android O brings runtime and other optimizations to the platform that result in a number of performance improvements. These optimizations include concurrent-compaction garbage collection, more efficient use of memory, and code locality.
These optimizations result in faster boot times, as well as better performance in both the OS and apps.
Updated Java Support
Android O adds support for several additional OpenJDK Java APIs:
To learn more about the classes and methods within these newly-added packages, see the API reference documentation.
Updated ICU4J Android Framework APIs
Android O extends the
ICU4J Android Framework
APIs—which is a subset of the ICU4J APIs—for app developers to
use under the
android.icu package. These APIs use localization data
present on the device, so you can reduce your APK footprint by not compiling the
ICU4J libraries in your APK.
|Android API level||ICU version||CLDR version||Unicode version|
|Android 7.0 (API level 24), Android 7.1 (API level 25)||56||28||8.0|
New enterprise features and APIs have been introduced for devices running Android O. Highlights include the following:
- Work profiles on fully managed devices let enterprises separate work from personal data, while managing both.
- API delegation allows device owners and profile owners to assign app management to other applications.
- User experience improvements in the provisioning flow (including new customization options) reduce the setup time.
- New controls over Bluetooth, Wi-Fi, backup, and security let enterprises manage more of the device. Network activity logging help enterprises track down problems.
To learn more about these and other new Android enterprise APIs and features, see Android in the Enterprise.