leaderboard 1

Showing posts with label android 5.0. Show all posts
Showing posts with label android 5.0. Show all posts

Tuesday 29 September 2015

Android 5.0 Behavior Changes

Android 5.0 Behavior Changes


API Level: 21
Along with new features and capabilities, Android 5.0 includes a variety of system changes and API behavior changes. This document highlights some of the key changes that you should be understand and account for in your apps.
If you have previously published an app for Android, be aware that your app might be affected by these changes in Android 5.0.
For a high-level look at the new platform features, instead see the Android Lollipop highlights.

Android Runtime (ART)

In Android 5.0 the ART runtime replaces Dalvik as the platform default. The ART runtime was introduced in Android 4.4 on an experimental basis.
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.

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, orVibrator classes, remove this code so that the system can present notifications correctly in priority mode. Instead, useNotification.Builder methods to add sounds and vibration.
Setting the device to RINGER_MODE_SILENT causes the device to enter the new priority mode. The device leaves priority mode if you set it to RINGER_MODE_NORMAL or RINGER_MODE_VIBRATE.
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 orSTREAM_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.

Media playback

If you are implementing notifications that present media playback status or transport controls, consider using the newNotification.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.

Media Controls and 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 theMediaSession class. You should also implement MediaSession if your app needs to receive media button events on Android devices.

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.

64-Bit Support in the Android 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.

Binding 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.

WebView

Android 5.0 changes the default behavior for your app.
  • If your app targets API level 21 or higher:
    • The system blocks mixed content and third party cookies by default. To allow mixed content and third party cookies, use the setMixedContentMode() and setAcceptThirdPartyCookies() methods respectively.
    • The system now intelligently chooses portions of the HTML document to draw. This new default behavior helps to reduce memory footprint and increase performance. If you want to render the whole document at once, disable this optimization by calling enableSlowWholeDocumentDraw().
  • If your app targets API levels lower than 21: The system allows mixed content and third party cookies, and always renders the whole document at once.

Uniqueness Requirement for Custom Permissions

As documented in the Permissions overview, Android apps can define custom permissions as a means of managing access to components in a proprietary way, without using the platform’s pre-defined system permissions. Apps define custom permissions in <permission> elements declared in their manifest files.
There are a small number of scenarios where defining custom permissions is a legitimate and secure approach. However, creating custom permissions is sometimes unnecessary and can even introduce potential risk to an app, depending on the protection level assigned to the permissions.
Android 5.0 includes a behavior change to ensure that only one app can define a given custom permission, unless signed with the same key as other apps defining the permission.

Apps using duplicate custom permissions

Any app can define any custom permission it wants, so it can happen that multiple apps might define the same custom permission. For example, if two apps offer a similar capability, they might derive the same logical name for their custom permissions. Apps might also incorporate common public libraries or code examples that themselves include the same custom permission definitions.
In Android 4.4 and earlier, users were able to install multiple such apps on a given device, although the system assigned the protection level specified by the first-installed app.
Starting in Android 5.0, the system enforces a new uniqueness restriction on custom permissions for apps that are signed with different keys. Now only one app on a device can define a given custom permission (as determined by its name), unless the other app defining the permission is signed with the same key. If the user tries to install an app with a duplicate custom permission and is not signed with the same key as the resident app that defines the permission, the system blocks the installation.

Considerations for your app

In Android 5.0 and later, apps can continue to define their own custom permissions just as before and to request custom permissions from other apps through the <uses-permission> mechanism. However with the new requirement introduced in Android 5.0, you should carefully assess possible impacts on your app.
Here are some points to consider:
  • Does your app declare any <permission> elements in its manifest? If so, are they actually necessary to the proper function of your app or service? Or could you use a system default permission instead?
  • If you have <permission> elements in your app, do you know where they came from?
  • Do you actually intend for other apps to request your custom permissions through <uses-permission>?
  • Are you using boilerplate or example code in your app that includes <permission> elements? Are those permission elements actually necessary?
  • Do your custom permissions use names that are simple or based on common terms that other apps might share?

New installs and updates

As mentioned above, for new installs and updates of your app on devices running Android 4.4 or earlier are unaffected and there is no change in behavior. For new installs and updates on devices running Android 5.0 or later, the system prevents installation of your app if it defines a custom permission that is already defined by an existing resident app.

Existing installs with Android 5.0 system update

If your app uses custom permissions and is widely distributed and installed, there’s a chance that it will be affected when users receive update their devices to Android 5.0. After the system update is installed, the system revalidates installed apps, including a check of their custom permissions. If your app defines a custom permission that is already defined by another app that has already been validated, and your app is not signed with the same key as the other app, the systemdoes not re-install your app.

Recommendations

On devices running Android 5.0 or later, we recommend that you examine your app immediately, make any adjustments needed, and publish the updated version as soon as possible to your users.
  • If you are using custom permissions in your app, consider their origin and whether you actually need them. Remove all<permission> elements from your app, unless you are certain that they are required for proper function of your app.
  • Consider replacing your custom permissions with system default permissions where possible.
  • If your app requires custom permissions, rename your custom permissions to be unique to your app, such as by appending them to the full package name of your app.
  • If you have a suite of apps signed with different keys and the apps access a shared component by means of a custom permission, make sure that the custom permission is only defined once, in the shared component. Apps that use the shared component should not define the custom permission themselves, but should instead request access through the <uses-permission> mechanism.
  • If you have a suite of apps are signed with the same key, each app can define the same custom permission(s) asneeded — the system allows the apps to be installed in the usual way.

TLS/SSL Default Configuration Changes

Android 5.0 introduces changes the default TLS/SSL configuration used by apps for HTTPS and other TLS/SSL traffic:
  • TLSv1.2 and TLSv1.1 protocols are now enabled,
  • AES-GCM (AEAD) cipher suites are now enabled,
  • MD5, 3DES, export, and static key ECDH cipher suites are now disabled,
  • Forward Secrecy cipher suites (ECDHE and DHE) are preferred.
These changes may lead to breakages in HTTPS or TLS/SSL connectivity in a small number of cases listed below.
Note that the security ProviderInstaller from Google Play services already offers these changes across Android platform versions back to Android 2.3.

Server does not support any of the enabled ciphers suites

For example, a server might support only 3DES or MD5 cipher suites. The preferred fix is to improve the server’s configuration to enable stronger and more modern cipher suites and protocols. Ideally, TLSv1.2 and AES-GCM should be enabled, and Forward Secrecy cipher suites (ECDHE, DHE) should be enabled and preferred.
An alternative is to modify the app to use a custom SSLSocketFactory to communicate with the server. The factory should be designed to create SSLSocket instances which have some of the cipher suites required by the server enabled in addition to default cipher suites.

App is making wrong assumptions about cipher suites used to connect to server

For example, some apps contain a custom X509TrustManager that breaks because it expects the authType parameter to be RSA but encounters ECDHE_RSA or DHE_RSA.

Server is intolerant to TLSv1.1, TLSv1.2 or new TLS extensions

For example, the TLS/SSL handshake with a server is erroneously rejected or stalls. The preferred fix is to upgrade the server to comply with the TLS/SSL protocol. This will make the server successfully negotiate these newer protocols or negotiate TLSv1 or older protocols and ignore TLS extensions it does not understand. In some cases disabling TLSv1.1 and TLSv1.2 on the server may work as a stopgap measure until the server software is upgraded.
An alternative is to modify the app to use a custom SSLSocketFactory to communicate with the server. The factory should be designed to create SSLSocket instances with only those protocols enabled which are correctly supported by the server.

Support for Managed Profiles

Device administrators can add a managed profile to a device. This profile is owned by the administrator, giving the administrator control over the managed profile while leaving the user's personal profile, and its storage space, under the user's control. This change can affect the behavior of your existing app in the following ways.

Handling intents

Device administrators can restrict access to system applications from the managed profile. In this case, if an app fires an intent from the managed profile that would ordinarily be handled by that application, and there is no suitable handler for the intent on the managed profile, the intent causes an exception. For example, the device administrator can restrict apps on the managed profile from accessing the system's camera application. If your app is running on the managed profile and calls startActivityForResult() for MediaStore.ACTION_IMAGE_CAPTURE, and there is no app on the managed profile that can handle the intent, this results in an ActivityNotFoundException.
You can prevent this by checking that there is at least one handler for any intent before firing it. To check for a valid handler, call Intent.resolveActivity(). You can see an example of this being done in Take Photos Simply: Take a Photo with the Camera App.

Sharing files across profiles

Each profile has its own file storage. Since a file URI refers to a specific location in the file storage, this means that a file URI that is valid on one profile is not valid on the other one. This is not ordinarily a problem for an app, which usually just accesses the files it creates. However, if an app attaches a file to an intent, it is not safe to attach a file URI, since in some circumstances, the intent might be handled on the other profile. For example, a device administrator might specify that image capture events should be handled by the camera app on the personal profile. If the intent is fired by an app on the managed profile, the camera needs to be able to write the image to a location where the managed profile's apps can read it.
To be safe, when you need to attach a file to an intent that might cross from one profile to the other, you should create and use a content URI for the file. For more information about sharing files with content URIs, see Sharing Files. For example, the device administrator might whitelist ACTION_IMAGE_CAPTURE to be handled by the camera in the personal profile. The firing intent's EXTRA_OUTPUT should contain a content URI specifying where the photo should be stored. The camera app can write the image to the location specified by that URI, and the app that fired the intent would be able to read that file, even if the app is on the other profile.

Lockscreen widget support removed

Android 5.0 removes support for lockscreen widgets; it continues to support widgets on the home screen.

Portions of this page are reproduced from work created and shared by the Android Open Source Project and used according to terms described in theCreative Commons 2.5 Attribution License.

Original Page Direct link:
http://developer.android.com/about/versions/android-5.0-changes.html
Posted by at No comments:
Labels: , , ,

Android 5.0 APIs

Android 5.0 APIs



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.
If you have a published app, make sure to check out the Android 5.0 Behavior Changes that you should account for in your app. These behavior changes may affect your app on Android 5.0 devices, even if you are not using new APIs or targeting new functionality.
For a high-level look at the new platform features, instead see the Android Lollipop highlights.

Start developing

To start building apps for Android 5.0, you must first get the Android SDK. Then use the SDK Manager to download the Android 5.0 SDK Platform and System Images.

Update your target API level

To better optimize your app for devices running Android 5.0, set yourtargetSdkVersion 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.
Please see Android 5.0 Changes for complete information.

User Interface

Material design support

Android 5.0 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'sdocumentLaunchMode 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 theandroid: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, by calling the setTaskDescription() method.

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 newandroid.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 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 to PRIORITY_MAX or PRIORITY_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 theANDROID_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, yourCameraCaptureSession.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'sINFO_SUPPORTED_HARDWARE_LEVEL property represents the camera's level of functionality.
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 by MediaCodec.
  • 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 andMediaController 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 AndroidTV 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 aMediaSession.Token object so that your app can interact with the given MediaSession. By using theMediaController.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 aMediaController.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 newNotification.MediaStyle class.

Media browsing

Android 5.0 introduces the ability for apps to browse the media content library of another app, through the newandroid.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 MediaSessionwhen 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 allDocumentsProvider 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() andbuildDocumentUriUsingTree() 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 MediaScannerConnectionto 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:
  1. Create a ConnectivityManager.
  2. Use the NetworkRequest.Builder class to create an NetworkRequest object and specify the network features and transport type your app is interested in.
  3. To scan for suitable networks, call requestNetwork() or registerNetworkCallback(), and pass in theNetworkRequest object and an implementation of ConnectivityManager.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 the registerNetworkCallback() 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 theBLUETOOTH_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 use setPreferredService() 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

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 callsetProfileEnabled() 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 callsstopLockTask().
  • 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() and getWindowContentFrameStats() 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 running adb shell from a host connected to the device, allowing you to use shell-based tools such as dumpsys, am, content, and pm.
  • 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 new getWindows() method.
  • The new AccessibilityNodeInfo.AccessibilityAction class lets you define standard or customized actions to perform on an AccessibilityNodeInfo. The new AccessibilityNodeInfo.AccessibilityAction class replaces the actions-related APIs previously found in AccessibilityNodeInfo.
  • 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.

User permissions

The following permission is 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.

Portions of this page are reproduced from work created and shared by the Android Open Source Project and used according to terms described in theCreative Commons 2.5 Attribution License.

Original Page Direct link:
http://developer.android.com/about/versions/android-5.0.html
Posted by at No comments:
Labels: , , , , ,
Subscribe to: Posts (Atom)