diff --git a/Android.mk b/Android.mk index 840fda01c7cf5..73d805513dc72 100644 --- a/Android.mk +++ b/Android.mk @@ -1042,6 +1042,7 @@ LOCAL_DROIDDOC_OPTIONS:= \ -hdf android.whichdoc online \ $(sample_groups) \ -useUpdatedTemplates \ + -includePreview \ -hdf android.hasSamples true \ -samplesdir $(samples_dir) diff --git a/docs/html/preview/api-overview.jd b/docs/html/preview/api-overview.jd new file mode 100644 index 0000000000000..599dc1e48ee38 --- /dev/null +++ b/docs/html/preview/api-overview.jd @@ -0,0 +1,569 @@ +page.title=API Overview +page.keywords=preview,sdk,compatibility +page.tags=previewresources, androidm +sdk.platform.apiLevel=22-mnc +page.image=images/cards/card-api-overview_16-9_2x.png +@jd:body + + +
The M Developer Preview gives you an advance look at the upcoming release +for the Android platform, which offers new features for users and app +developers. This document provides an introduction to the most notable APIs.
+ ++ The M Developer Preview 3 release includes the final APIs for Android 6.0 (API level + 23). If you are preparing an app for use on Android 6.0, + download the latest SDK and to complete your + final updates and release testing. You can review the final APIs in the + API Reference and see the API differences in + the Android API Differences Report. +
+ + + +Important: + You may now publish apps that target Android 6.0 (API level 23) to the Google Play store. +
+ +Note: + If you have been working with previous preview releases and want to see the differences + between the final API and previous preview versions, download the additional difference + reports included in the preview docs + reference. +
+ +If you have previously published an app for Android, be aware that your app might be affected +by changes in the platform.
+ +Please see Behavior Changes for complete information.
+ +This preview enhances Android’s intent system by providing more powerful app linking. +This feature allows you to associate an app with a web domain you own. Based on this +association, the platform can determine the default app to use to handle a particular +web link and skip prompting users to select an app. To learn how to implement this feature, see +App Linking. + +
The system now performs automatic full data backup and restore for apps. For the +duration of the M Developer Preview program, all +apps are backed up, independent of which SDK version they target. After the final M SDK release, +your app must target M to enable this behavior; you do not need to add any additional code. If users +delete their Google accounts, their backup data is deleted as well. To learn how this feature +works and how to configure what to back up on the file system, see +Auto Backup for Apps.
+ +This preview offers new APIs to let you authenticate users by using their fingerprint scans on +supported devices, and check how recently the user was last authenticated using a device unlocking +mechanism (such as a lockscreen password). Use these APIs in conjunction with +the Android Keystore system.
+ +To authenticate users via fingerprint scan, get an instance of the new +{@link android.hardware.fingerprint.FingerprintManager} class and call the +{@link android.hardware.fingerprint.FingerprintManager#authenticate(android.hardware.fingerprint.FingerprintManager.CryptoObject, android.os.CancellationSignal, int, android.hardware.fingerprint.FingerprintManager.AuthenticationCallback, android.os.Handler) authenticate()} +method. Your app must be running on a compatible +device with a fingerprint sensor. You must implement the user interface for the fingerprint +authentication flow on your app, and use the standard Android fingerprint icon in your UI. +The Android fingerprint icon ({@code c_fp_40px.png}) is included in the +sample app. If you are developing multiple apps that use fingerprint +authentication, note that each app must authenticate the user’s fingerprint independently. +
+ +To use this feature in your app, first add the + {@link android.Manifest.permission#USE_FINGERPRINT} permission in your manifest.
+ ++<uses-permission + android:name="android.permission.USE_FINGERPRINT" /> ++
+
+To see an app implementation of fingerprint authentication, refer to the + + Fingerprint Dialog sample. For a demonstration of how you can use these authentication + APIs in conjunction with other Android APIs, see the video + + Fingerprint and Payment APIs.
+ +If you are testing this feature, follow these steps:
++adb -e emu finger touch <finger_id> ++
On Windows, you may have to run {@code telnet 127.0.0.1
Your app can authenticate users based on how recently they last unlocked their device. This +feature frees users from having to remember additional app-specific passwords, and avoids the need +for you to implement your own authentication user interface. Your app should use this feature in +conjunction with a public or secret key implementation for user authentication.
+ +To set the timeout duration for which the same key can be re-used after a user is successfully +authenticated, call the new +{@link android.security.keystore.KeyGenParameterSpec.Builder#setUserAuthenticationValidityDurationSeconds(int) setUserAuthenticationValidityDurationSeconds()} +method when you set up a {@link javax.crypto.KeyGenerator} or +{@link java.security.KeyPairGenerator}.
+ +Avoid showing the re-authentication dialog excessively -- your apps should try using the +cryptographic object first and if the the timeout expires, use the +{@link android.app.KeyguardManager#createConfirmDeviceCredentialIntent(java.lang.CharSequence, java.lang.CharSequence) createConfirmDeviceCredentialIntent()} +method to re-authenticate the user within your app. +
+ +To see an app implementation of this feature, refer to the + + Confirm Credential sample.
+ +
+
+This preview provides you with APIs to make sharing intuitive and quick for users. You can now +define direct share targets that launch a specific activity in your app. These direct share +targets are exposed to users via the Share menu. This feature allows users to share +content to targets, such as contacts, within other apps. For example, the direct share target might +launch an activity in another social network app, which lets the user share content directly to a +specific friend or community in that app.
+ +To enable direct share targets you must define a class that extends the +{@link android.service.chooser.ChooserTargetService} class. Declare your +service in the manifest. Within that declaration, specify the +{@link android.Manifest.permission#BIND_CHOOSER_TARGET_SERVICE} permission and an +intent filter using the +{@link android.service.chooser.ChooserTargetService#SERVICE_INTERFACE SERVICE_INTERFACE} action.
+The following example shows how you might declare the +{@link android.service.chooser.ChooserTargetService} in your manifest.
++<service android:name=".ChooserTargetService" + android:label="@string/service_name" + android:permission="android.permission.BIND_CHOOSER_TARGET_SERVICE"> + <intent-filter> + <action android:name="android.service.chooser.ChooserTargetService" /> + </intent-filter> +</service> ++ +
For each activity that you want to expose to
+{@link android.service.chooser.ChooserTargetService}, add a
+{@code
+<activity android:name=".MyShareActivity” + android:label="@string/share_activity_label"> + <intent-filter> + <action android:name="android.intent.action.SEND" /> + </intent-filter> +<meta-data + android:name="android.service.chooser.chooser_target_service" + android:value=".ChooserTargetService" /> +</activity> ++ +
+This preview provides a new voice interaction API which, together with +Voice Actions, +allows you to build conversational voice experiences into your apps. Call the +{@link android.app.Activity#isVoiceInteraction()} method to determine if a voice action triggered +your activity. If so, your app can use the +{@link android.app.VoiceInteractor} class to request a voice confirmation from the user, select +from a list of options, and more.
+ +Most voice interactions originate from a user voice action. A voice interaction activity can +also, however, start without user input. For example, another app launched through a voice +interaction can also send an intent to launch a voice interaction. To determine if your activity +launched from a user voice query or from another voice interaction app, call the +{@link android.app.Activity#isVoiceInteractionRoot()} method. If another app launched your +activity, the method returns {@code false}. Your app may then prompt the user to confirm that +they intended this action.
+ +To learn more about implementing voice actions, see the +Voice Actions developer site. +
+ ++This preview offers a new way for users to engage with your apps through an assistant. To use this +feature, the user must enable the assistant to use the current context. Once enabled, the user +can summon the assistant within any app, by long-pressing on the Home button.
+Your app can elect to not share the current context with the assistant by setting the +{@link android.view.WindowManager.LayoutParams#FLAG_SECURE} flag. In addition to the +standard set of information that the platform passes to the assistant, your app can share +additional information by using the new {@link android.app.assist.AssistContent} class.
+ +To provide the assistant with additional context from your app, follow these steps:
+ +This preview adds the following API changes for notifications:
+This preview provides improved support for user input using a Bluetooth stylus. Users can pair +and connect a compatible Bluetooth stylus with their phone or tablet. While connected, position +information from the touch screen is fused with pressure and button information from the stylus to +provide a greater range of expression than with the touch screen alone. Your app can listen for +stylus button presses and perform secondary actions, by registering +{@link android.view.View.OnContextClickListener} and +{@link android.view.GestureDetector.OnContextClickListener} objects in your activity.
+ +Use the {@link android.view.MotionEvent} methods and constants to detect stylus button +interactions:
++If your app performs performs Bluetooth Low Energy scans, use the new +{@link android.bluetooth.le.ScanSettings.Builder#setCallbackType(int) setCallbackType()} +method to specify that you want the system to notify callbacks when it first finds, or sees after a +long time, an advertisement packet matching the set {@link android.bluetooth.le.ScanFilter}. This +approach to scanning is more power-efficient than what’s provided in the previous platform version. +
+ ++This preview adds support for the Hotspot 2.0 Release 1 spec on Nexus 6 and Nexus 9 devices. To +provision Hotspot 2.0 credentials in your app, use the new methods of the +{@link android.net.wifi.WifiEnterpriseConfig} class, such as +{@link android.net.wifi.WifiEnterpriseConfig#setPlmn(java.lang.String) setPlmn()} and +{@link android.net.wifi.WifiEnterpriseConfig#setRealm(java.lang.String) setRealm()}. In the +{@link android.net.wifi.WifiConfiguration} object, you can set the +{@link android.net.wifi.WifiConfiguration#FQDN} and the +{@link android.net.wifi.WifiConfiguration#providerFriendlyName} fields. +The new {@link android.net.wifi.ScanResult#isPasspointNetwork()} method indicates if a detected +network represents a Hotspot 2.0 access point. +
+ +The platform now allows apps to request that the display resolution be upgraded to 4K rendering +on compatible hardware. To query the current physical resolution, use the new +{@link android.view.Display.Mode} APIs. If the UI is drawn at a lower logical resolution and is +upscaled to a larger physical resolution, be aware that the physical resolution the +{@link android.view.Display.Mode#getPhysicalWidth()} method returns may differ from the logical +resolution reported by {@link android.view.Display#getSize(android.graphics.Point) getSize()}.
+ +You can request the system to change the physical resolution in your app as it runs, by setting +the {@link android.view.WindowManager.LayoutParams#preferredDisplayModeId} property of your app’s +window. This feature is useful if you want to switch to 4K display resolution. While in 4K display +mode, the UI continues to be rendered at the original resolution (such as 1080p) and is upscaled to +4K, but {@link android.view.SurfaceView} objects may show content at the native resolution.
+ +Theme attributes are now supported in +{@link android.content.res.ColorStateList} for devices running the M Preview. The +{@link android.content.res.Resources#getColorStateList(int) getColorStateList()} and +{@link android.content.res.Resources#getColor(int) getColor()} methods have been deprecated. If +you are calling these APIs, call the new +{@link android.content.Context#getColorStateList(int) getColorStateList()} or +{@link android.content.Context#getColor(int) getColor()} methods instead. These methods are also +available in the v4 appcompat library via {@link android.support.v4.content.ContextCompat}.
+ +This preview adds enhancements to audio processing on Android, including:
+This preview adds new capabilities to the video processing APIs, including:
+This preview includes the following new APIs for accessing the camera’s flashlight and for +camera reprocessing of images:
+ +If a camera device has a flash unit, you can call the +{@link android.hardware.camera2.CameraManager#setTorchMode(java.lang.String, boolean) setTorchMode()} +method to switch the flash unit’s torch mode on or off without opening the camera device. The app +does not have exclusive ownership of the flash unit or the camera device. The torch mode is turned +off and becomes unavailable whenever the camera device becomes unavailable, or when other camera +resources keeping the torch on become unavailable. Other apps can also call +{@link android.hardware.camera2.CameraManager#setTorchMode(java.lang.String, boolean) setTorchMode()} +to turn off the torch mode. When the last app that turned on the torch mode is closed, the torch +mode is turned off.
+ +You can register a callback to be notified about torch mode status by calling the +{@link android.hardware.camera2.CameraManager#registerTorchCallback(android.hardware.camera2.CameraManager.TorchCallback, android.os.Handler) registerTorchCallback()} +method. The first time the callback is registered, it is immediately called with the torch mode +status of all currently known camera devices with a flash unit. If the torch mode is turned on or +off successfully, the +{@link android.hardware.camera2.CameraManager.TorchCallback#onTorchModeChanged(java.lang.String, boolean) onTorchModeChanged()} +method is invoked.
+ +The {@link android.hardware.camera2 Camera2} API is extended to support YUV and private
+opaque format image reprocessing. To determine if these reprocessing capabilities are available,
+call {@link android.hardware.camera2.CameraManager#getCameraCharacteristics(java.lang.String)
+getCameraCharacteristics()} and check for the
+{@link android.hardware.camera2.CameraCharacteristics#REPROCESS_MAX_CAPTURE_STALL} key. If a
+device supports reprocessing, you can create a reprocessable camera capture session by calling
+createReprocessableCaptureSession(),
+and create requests for input buffer reprocessing.
Use the {@link android.media.ImageWriter} class to connect the input buffer flow to the camera +reprocessing input. To get an empty buffer, follow this programming model:
+ +If you are using a {@link android.media.ImageWriter} object together with an +{@link android.graphics.ImageFormat#PRIVATE} image, your app cannot access the image +data directly. Instead, pass the {@link android.graphics.ImageFormat#PRIVATE} image directly to the +{@link android.media.ImageWriter} by calling the +{@link android.media.ImageWriter#queueInputImage(android.media.Image) queueInputImage()} method +without any buffer copy.
+ +The {@link android.media.ImageReader} class now supports +{@link android.graphics.ImageFormat#PRIVATE} format image streams. This support allows your app to +maintain a circular image queue of {@link android.media.ImageReader} output images, select one or +more images, and send them to the {@link android.media.ImageWriter} for camera reprocessing.
+ +This preview includes the following new APIs for Android for Work:
+
+A Profile or Device Owner can set a permission policy +for all runtime requests of all applications using +{@link android.app.admin.DevicePolicyManager#setPermissionPolicy(android.content.ComponentName, int) +setPermissionPolicy()}, to either prompt the user to grant the permission or automatically grant or +deny the permission silently. If the latter policy is set, the user cannot +modify the selection made by the Profile or Device Owner within the app’s permissions screen in +Settings.
+ For a detailed view of all API changes in the M Developer Preview, see the API Differences Report. +
diff --git a/docs/html/preview/behavior-changes.jd b/docs/html/preview/behavior-changes.jd new file mode 100644 index 0000000000000..cab4163416857 --- /dev/null +++ b/docs/html/preview/behavior-changes.jd @@ -0,0 +1,442 @@ +page.title=Behavior Changes +page.keywords=preview,sdk,compatibility +sdk.platform.apiLevel=MNC +@jd:body + +Along with new features and capabilities, the M Developer Preview includes a variety of +system changes and API behavior changes. This document highlights +some of the key changes that you should understand and account for in your apps.
+ +If you have previously published an app for Android, be aware that these changes in the +platform affect your app.
+ +This preview introduces a new permissions model, where users can now directly manage +app permissions at runtime. This model gives users improved visibility and control over +permissions, while streamlining the installation and auto-update processes for app developers. +Users can grant or revoke permissions individually for installed apps.
+ +On your apps that target the M Preview release or higher, make sure to check for and request +permissions at runtime. To determine if your app has been granted a permission, call the +new {@link android.content.Context#checkSelfPermission(java.lang.String) checkSelfPermission()} +method. To request a permission, call the new +{@link android.app.Activity#requestPermissions(java.lang.String[], int) requestPermissions()} +method. Even if your app is not targeting the M Preview release, you should test your app under +the new permissions model.
+ +For details on supporting the new permissions model in your app, see the + +Permissions developer preview page. For tips on how to assess the impact on your app, +see the Testing Guide
+ +This preview introduces new power-saving optimizations for idle devices and apps.
+To learn more about these power-saving changes, see +Power-Saving Optimizations.
+ ++With this preview, users can adopt external storage devices such as SD cards. Adopting an +external storage device encrypts and formats the device to behave like internal storage. This +feature allows users to move both apps and private data of those apps between storage devices. When +moving apps, the system respects the +{@code android:installLocation} +preference in the manifest.
+ +If your app accesses the following APIs or fields, be aware that the file paths they return +will dynamically change when the app is moved between internal and external storage devices. +When building file paths, it is strongly recommended that you always call these APIs dynamically. +Don’t use hardcoded file paths or persist fully-qualified file paths that were built previously.
+ +To debug this feature in the developer preview, you can enable adoption of a USB drive that is +connected to an Android device through a USB On-The-Go (OTG) cable, by running this command:
+ ++$ adb shell sm set-force-adoptable true ++ +
This preview removes support for the Apache HTTP client. If your app is using this client and +targets Android 2.3 (API level 9) or higher, use the {@link java.net.HttpURLConnection} class +instead. This API is more efficient because it reduces network use through transparent compression +and response caching, and minimizes power consumption. To continue using the Apache HTTP APIs, you +must first declare the following compile-time dependency in your {@code build.gradle} file: +
+
+android {
+ useLibrary 'org.apache.http.legacy'
+}
+
+Android is moving away from OpenSSL to the +BoringSSL +library. If you’re using the Android NDK in your app, don't link against cryptographic libraries +that are not a part of the NDK API, such as {@code libcrypto.so} and {@code libssl.so}. These +libraries are not public APIs, and may change or break without notice across releases and devices. +In addition, you may expose yourself to security vulnerabilities. Instead, modify your +native code to call the Java cryptography APIs via JNI or to statically link against a +cryptography library of your choice.
+ +Setting the volume directly or muting specific streams via the {@link android.media.AudioManager} +class is no longer supported. The {@link android.media.AudioManager#setStreamSolo(int,boolean) +setStreamSolo()} method is deprecated, and you should call the +{@link android.media.AudioManager#requestAudioFocus(android.media.AudioManager.OnAudioFocusChangeListener, int, int) requestAudioFocus()} +method instead. Similarly, the +{@link android.media.AudioManager#setStreamMute(int,boolean) setStreamMute()} method is +deprecated; instead, call the {@link android.media.AudioManager#adjustStreamVolume(int, int, int) +adjustStreamVolume()} method and pass in the direction value +{@link android.media.AudioManager#ADJUST_MUTE} or +{@link android.media.AudioManager#ADJUST_UNMUTE}.
+ ++This release removes the {@code Notification.setLatestEventInfo()} method. Use the +{@link android.app.Notification.Builder} class instead to construct notifications. To update a +notification repeatedly, reuse the {@link android.app.Notification.Builder} instance. Call the +{@link android.app.Notification.Builder#build()} method to get +updated {@link android.app.Notification} instances. +
+The {@code adb shell dumpsys notification} command no longer prints out your notification text. +Use the {@code adb shell dumpsys notification --noredact} command instead to print out the text +in a notification object.
+ +
+
+When users select text in your app, you can now display text selection actions such as +Cut, Copy, and Paste in a +floating toolbar. The user interaction implementation is similar to that +for the contextual action bar, as described in + +Enabling the contextual action mode for individual views.
+ +To implement a floating toolbar for text selection, make the following changes in your existing +apps:
+If you are using +Android Support Library revision 22.2, be aware that floating toolbars are not +backward-compatible and appcompat takes control over {@link android.view.ActionMode} objects by +default. This prevents floating toolbars from being displayed. To enable +{@link android.view.ActionMode} support in an +{@link android.support.v7.app.AppCompatActivity}, call +{@link android.support.v7.app.AppCompatActivity#getDelegate()}, then call +{@link android.support.v7.app.AppCompatDelegate#setHandleNativeActionModesEnabled(boolean) +setHandleNativeActionModesEnabled()} on the returned +{@link android.support.v7.app.AppCompatDelegate} object and set the input +parameter to {@code false}. This call returns control of {@link android.view.ActionMode} objects to +the framework. In devices running the M Preview, that allows the framework to support +{@link android.support.v7.app.ActionBar} or floating toolbar modes, while on pre-M Preview devices, +only the {@link android.support.v7.app.ActionBar} modes are supported.
+ +With this preview, the +Android Keystore provider no longer supports +DSA. ECDSA is still supported.
+ +Keys which do not require encryption at rest will no longer be deleted when secure lock screen +is disabled or reset (for example, by the user or a Device Administrator). Keys which require +encryption at rest will be deleted during these events.
+ +This preview introduces the following behavior changes to the Wi-Fi and networking APIs.
+In this preview, the model for accessing shared resources in the camera service has been changed +from the previous “first come, first serve” access model to an access model where high-priority +processes are favored. Changes to the service behavior include:
+The ART runtime now properly implements access rules for the +{@link java.lang.reflect.Constructor#newInstance(java.lang.Object...) newInstance()} method. This +change fixes a problem where Dalvik was checking access rules incorrectly in previous versions. +If your app uses the +{@link java.lang.reflect.Constructor#newInstance(java.lang.Object...) newInstance()} method and you +want to override access checks, call the +{@link java.lang.reflect.Constructor#setAccessible(boolean) setAccessible()} method with the input +parameter set to {@code true}. If your app uses the +v7 appcompat library or the +v7 recyclerview library, +you must update your app to use to the latest versions of these libraries. Otherwise, make sure that +any custom classes referenced from XML are updated so that their class constructors are accessible.
+ +This preview updates the behavior of the dynamic linker. The dynamic linker now understands the +difference between a library’s {@code soname} and its path +( +public bug 6670), and search by {@code soname} is now +implemented. Apps which previously worked that have bad {@code DT_NEEDED} entries +(usually absolute paths on the build machine’s file system) may fail when loaded.
+ +The {@code dlopen(3) RTLD_LOCAL} flag is now correctly implemented. Note that +{@code RTLD_LOCAL} is the default, so calls to {@code dlopen(3)} that didn’t explicitly use +{@code RTLD_LOCAL} will be affected (unless your app explicitly used {@code RTLD_GLOBAL}). With +{@code RTLD_LOCAL}, symbols will not be made available to libraries loaded by later calls to +{@code dlopen(3)} (as opposed to being referenced by {@code DT_NEEDED} entries).
+ + +To provide users with greater data protection, starting in this release, Android +removes programmatic access to the device’s local hardware identifier for +apps using the Wi-Fi and Bluetooth APIs. The +{@link android.net.wifi.WifiInfo#getMacAddress() WifiInfo.getMacAddress()} and the +{@link android.bluetooth.BluetoothAdapter#getAddress() BluetoothAdapter.getAddress()} methods +now return a constant value of {@code 02:00:00:00:00:00}.
+ +To access the hardware identifiers of nearby external devices via Bluetooth and Wi-Fi scans, +your app must now have the following permissions:
+Note: When a device running M Developer Preview initiates a +background Wi-Fi or Bluetooth scan, the operation is visible to external devices as +originating from a randomized MAC address.
+ +The platform now performs stricter validation of APKs. An APK is considered corrupt if a file is +declared in the manifest but not present in the APK itself. An APK must be re-signed if any of the +contents are removed.
+ +Device connections through the USB port are now set to charge-only mode by default. To access +the device and its content over a USB connection, users must explicitly grant permission for such +interactions. If your app supports user interactions with the device over a USB port, take into +consideration that the interaction must be explicitly enabled. +
+ +This preview includes the following behavior changes for Android for Work:
+EXTRA_PROVISIONING_RESET_PROTECTION_PARAMETERS is removed so NFC bump
+provisioning cannot programmatically unlock a factory reset protected device.BLUETOOTH_ONDEVELOPMENT_SETTINGS_ENABLEDMODE_RINGERNETWORK_PREFERENCEWIFI_ON+ The Android M Preview SDK includes development tools, Android system images, and library files to + help you test your app and the new APIs coming in the next release of the platform. This document + describes how to get the downloadable components of the preview for testing your app. +
+ + ++ With Developer Preview 3, the official Android 6.0 SDK is now available for download through the Android SDK Manager. For more information on + downloading and configuring the SDK, see Set Up the SDK. +
+ + ++ The developer documentation for Developer Preview 3 is released as Android 6.0 (API level 23) and + is available online, including the API level 23 + reference and diff report. The following + developer documentation download package provides additional, incremental difference reports + between the preview releases. +
+ +| Description | +Download / Checksums | +
|---|---|
| Android M Preview 3 Developer Docs |
+ m-preview-3-developer-docs.zip + MD5: d99b14b0c06d31c8dfecb25072654ca3 + SHA-1: 9cefeeda07676130da606a1796e1c00fffc667c1 + |
+
| Device | +Download / Checksums | +
|---|---|
| Nexus 5 (GSM/LTE) "hammerhead" |
+ hammerhead-MPA44I-preview-2ebbc049.tgz + MD5: 91a924fb0c9f8e716e3b4c9954fd0dbb + SHA-1: 2ebbc049b68c4da8baeee3e42bb94d7a965ba4a3 + |
+
| Nexus 6 "shamu" |
+ shamu-MPA44I-preview-62b9c486.tgz + MD5: ac6e58da86125073d9c395257fd42664 + SHA-1: 62b9c486fd7a5020e228d53ca5acd5c1857e48ff + |
+
| Nexus 9 "volantis" |
+ volantis-MPA44I-preview-5c30a6e2.tgz + MD5: 7f83768757913d3fea945a661020d185 + SHA-1: 5c30a6e2acd11a81f4105b12d23ff654f534f699 + |
+
| Nexus Player "fugu" |
+ fugu-MPA44I-preview-2860040a.tgz + MD5: 438da8d37da9e341a69cfb16a4001ac5 + SHA-1: 2860040a326582f1ff5f702bf9a1ef002717fc98 + |
+
+ In order to use a device image for testing, you must install it on a compatible device. Follow + the instructions below to install a system image: +
+ ++ Once you have installed a preview system image on a development device, the device is upgraded + automatically with the next preview release through over-the-air (OTA) updates. When the update + is available, the device displays notification that an update is available and allows you to + install it. You can also manually install the next preview image by repeating the procedure in + the previous section. +
+ ++ If you want to uninstall the preview and revert the device to factory specifications, go to + developers.google.com/android and + download the image you want to flash to for your device. Follow the instructions on that page to + flash the image to your device. +
+ + + + + + + + diff --git a/docs/html/preview/guide.jd b/docs/html/preview/guide.jd new file mode 100644 index 0000000000000..56bb4d994476d --- /dev/null +++ b/docs/html/preview/guide.jd @@ -0,0 +1,187 @@ +page.title=Testing Guide +page.image=images/cards/card-build_16x9_2x.png +page.keywords=previewresources,androidm,testing,permissions + +@jd:body + ++ The Android M Developer Preview gives you an opportunity to ensure your apps work with the next + version of the platform. This preview includes a number of APIs and behavior changes that can + impact your app, as described in the API + Overview and Behavior Changes. In testing + your app with the preview, there are some specific system changes that you should focus on to + ensure that users have a good experience. +
+ ++ This guide describes the what and how to test preview features with your app. You should + prioritize testing of these specific preview features, due to their high potential impact on your + app's behavior: +
+ + + ++ For more information about how to set up devices or virtual devices with a preview system image + for testing, see Set up the Preview SDK. +
+ + ++ The new Permissions model + changes the way that permissions are allocated to your app by the user. Instead of granting all + permissions during the install procedure, your app must ask the user for individual permissions + at runtime. For users this behavior provides more granular control over each app’s activities, as + well as better context for understanding why the app is requesting a specific permission. Users + can grant or revoke the permissions granted to an app individually at any time. This feature of + the preview is most likely to have an impact on your app's behavior and may prevent some of your + app features from working, or they may work in a degraded state. +
+ ++ This change affects all apps running on the new platform, even those not targeting the new + platform version. The platform provides a limited compatibility behavior for legacy apps, but you + should begin planning your app’s migration to the new permissions model now, with a goal of + publishing an updated version of your app at the official platform launch. +
+ + ++ Use the following test tips to help you plan and execute testing of your app with the new + permissions behavior. +
+ +adb shell pm list permissions -d -g+
adb shell pm [grant|revoke] <permission.name> ...+
+ The permissions change affects the structure and design of your app, as well as + the user experience and flows you provide to users. You should assess your app’s current + permissions use and start planning for the new flows you want to offer. The official release of + the platform provides compatibility behavior, but you should plan on updating your app and not + rely on these behaviors. +
+ ++ Identify the permissions that your app actually needs and uses, and then find the various code + paths that use the permission-protected services. You can do this through a combination of + testing on the new platform and code analysis. In testing, you should focus on opting in to + runtime permissions by changing the app’s {@code targetSdkVersion} to the preview version. For + more information, see Set up the Preview SDK. +
+ ++ Test with various combinations of permissions revoked and added, to highlight the user flows that + depend on permissions. Where a dependency is not obvious or logical you should consider + refactoring or compartmentalizing that flow to eliminate the dependency or make it clear why the + permission is needed. +
+ ++ For more information on the behavior of runtime permissions, testing, and best practices, see the + Permissions developer + preview page. +
+ + ++ The power saving features of Doze and App Standby limit the amount of background processing that + your app can perform when a device is in an idle state or while your app is not in focus. The + restrictions the system may impose on apps include limited or no network access, + suspended background tasks, suspended Notifications, ignored wake requests, and alarms. To ensure + that your app behaves properly with these power saving optimizations, you should test your app by + simulating these low power states. +
+ +To test Doze with your app:
+ ++$ adb shell dumpsys battery unplug +$ adb shell dumpsys deviceidle step +$ adb shell dumpsys deviceidle -h ++ +
To test the App Standby mode with your app:
+ ++$ adb shell am broadcast -a android.os.action.DISCHARGING +$ adb shell am set-idle <packageName> true ++ +
$ adb shell am set-idle <packageName> false+
If your app is persisting any device-specific identifiers, such as Google +Cloud Messaging registration ID, in internal storage, +make sure to follow best practices to exclude the storage +location from auto-backup, as described in Auto +Backup for Apps.
diff --git a/docs/html/preview/images/m-preview-timeline-crop.png b/docs/html/preview/images/m-preview-timeline-crop.png new file mode 100644 index 0000000000000..724a6af8bc513 Binary files /dev/null and b/docs/html/preview/images/m-preview-timeline-crop.png differ diff --git a/docs/html/preview/images/m-preview-timeline.png b/docs/html/preview/images/m-preview-timeline.png new file mode 100644 index 0000000000000..e9a339ef82764 Binary files /dev/null and b/docs/html/preview/images/m-preview-timeline.png differ diff --git a/docs/html/preview/index.jd b/docs/html/preview/index.jd new file mode 100644 index 0000000000000..5988706c2db1c --- /dev/null +++ b/docs/html/preview/index.jd @@ -0,0 +1,73 @@ +page.title=Android N Developer Preview +page.tags="preview", +meta.tags="preview, devpreview", androidm +fullpage=true +forcelocalnav=true +header.hide=1 +footer.hide=1 +@jd:body + + + ++To get started with the Android SDK Preview, you must agree to the following terms and conditions. +As described below, please note that this is a preview version of the Android SDK, subject to change, that you use at your own risk. The Android SDK Preview is not a stable release, and may contain errors and defects that can result in serious damage to your computer systems, devices and data. +
+ ++This is the Android SDK Preview License Agreement (the “License Agreement”). +
+Includes final SDK and near-final system images
++ Welcome to the Android M Developer Preview, a program that gives you + everything you need to test and optimize your apps for the next version of + Android. It's free, and you can get started right away just by downloading + the M Developer Preview tools. +
+ ++ Run and test your apps on Nexus 5, 6, 9, and Player (for TV), as well + as emulator. +
++ We’ll provide multiple updates during the Preview, so you’ll be testing + against the latest platform changes. +
++ You can get updates over-the-air, once you’ve flashed a + device to the initial preview. +
++ Start work early to support new platform behaviors such as + the new runtime permissions model and power-saving features. +
++ During the first several weeks we’ll give priority to developer-reported + issues, so test and give feedback as soon as possible. +
++ Report issues and give us feedback using our issue tracker. + Connect with other developers in the M Developer Community. + +
+
++ The M Developer Preview runs from May 28 until the final Android M public release planned for Q3 + 2015. +
+ ++ At key development milestones, we’ll deliver updates for your test devices. + The milestones are +
+ ++ These updates culminate in the official Android 6.0 SDK (now available), + which lets you build with the final APIs for the new version of Android, as well as + near-final system images to let you test system behaviors and features. +
+ ++ As you test and develop on Android M, we strongly recommend keeping + your development environment up-to-date as Preview updates are released. + To make the process easier, we'll deliver updates over-the-air + (OTA) to devices already flashed to a Preview build, as well as + providing system images that you can download and flash manually. +
++ Note: Developer Preview 3 includes final APIs and near-final + system images available by both download and OTA. At the full public release of + Android M later in Q3, final system images will be available by download only, + so you'll need to flash manually to + your test devices. +
+ ++ We’ll notify you when Preview updates are available via the Android Developers Blog, as + well as this site and the + Android M Developer Community. +
+ ++ The M Developer Preview includes everything you need to test your existing + apps on a variety of screen sizes, network technologies, CPU/GPU chipsets, + and hardware architectures. +
+ ++ You can download these components through the SDK Manager in Android Studio: +
+ ++ You can download these hardware system images for Nexus devices from the + Downloads page: +
+ ++ These documentation resources help you learn about the Preview: +
+ ++ Use these support resources as you test and develop on the M + Developer Preview: +
+ ++
With Developer Preview 3, the platform APIs are now official (API level 23) and the + official Android 6.0 SDK is now available. We recommend updating your environment + right away through Android Studio. Once you've updated your environment, you can target + the new API level, compile against the new platform, and publish at your convenience + to Google Play (including alpha, beta, or release channels). + +
If you want to opt out
+ of compatibility behaviors (which is strongly recommended),
+ you can target the Android 6.0 platform by setting your app's targetSdkVersion
+ to “23”.
+
Before releasing an app that targets API level 23, we strongly + recommend distributing it to a group of testers through the new + beta testing features available in the Google Play Developer Console. See the + Help + Center article for more information. +
+ ++ To get started testing your app with Android M: +
+ ++ Thank you for your participation in the Android M Developer Preview program! +
diff --git a/docs/html/preview/preview_toc.cs b/docs/html/preview/preview_toc.cs new file mode 100644 index 0000000000000..a6101cd896d06 --- /dev/null +++ b/docs/html/preview/preview_toc.cs @@ -0,0 +1,126 @@ + diff --git a/docs/html/preview/samples.jd b/docs/html/preview/samples.jd new file mode 100644 index 0000000000000..7d47e0ed0e04b --- /dev/null +++ b/docs/html/preview/samples.jd @@ -0,0 +1,70 @@ +page.title=Samples +page.image=images/cards/samples-new_2x.png +@jd:body + ++ The following code samples are provided for the M Developer Preview. To download + the samples in Android Studio, select the File > Import Samples menu option. +
+ ++ Note: These downloadable projects are designed + for use with Gradle and Android Studio. +
+ + ++ Android M changes the way system permissions work. Users are asked to approve permission + requests at runtime instead of during installation. This sample shows how to request these + permissions. +
+ + + ++ This sample demonstrates how to use device credentials as an authentication method in your app. +
+ + + ++ This sample demonstrates how to recognize registered fingerprints to authenticate the user + in your app. +
+ + + ++ Android M introduces automatic backup for app settings. This sample demonstrates how to add + filtering rules to an app in order to manage settings backup. +
+ + + +
+ Demonstrates how to use the Camera2 API to capture RAW camera buffers and save
+ them as DNG files.
+
+ This sample demonstrates how the
+ NotificationManager
+ can tell you how many notifications your app is currently showing.
+
With Developer Preview 3, the official Android 6.0 SDK is now available from the Android SDK +Manager. This document assumes that you are familiar with Android app development, such +as using the Android SDK Manager and creating projects. If you are new to +Android, see Building Your First +App training lesson first.
+ + ++ It is highly recommended that you install the Android Studio 1.3 to work best with + the Android 6.0 SDK. Please update your Android Studio installation to version 1.3 or + higher, or follow the instructions for + Installing Android Studio. +
+ + +To add the Android 6.0 SDK components to your development environment:
+ +On Mac OS X, you can find the Appearance & + Behavior panel + in Android Studio's Preferences window.
+After completing these steps, the preview components are available in your development + environment.
+ + ++ In order to use the preview APIs, you must create or update a development project to use + the preview components. +
+ + ++ We recommend using Android Studio to create a project with the preview. Follow the steps + described in Creating a Project + until you arrive at the Form Factors screen in the project wizard. Then perform + the following steps to create a project configured for the preview. +
+ +
+ For existing projects, if you are using Android 6.0 APIs (API level 23) you must
+ modify the project configuration. In your development environment, open the
+ build.gradle file for your module and
+ set these values as follows:
+
compileSdkVersion is set to '23'targetSdkVersion is set to '23'+ Testing an app with the preview requires that you have a device or virtual device configured with + the preview version of the platform. If you have a compatible device, you can install the preview + platform for testing. Otherwise, you can configure a virtual device for testing. +
+ ++ If you have a Nexus 5, Nexus 6, Nexus 9, or Android TV, you can install a preview + system image on these devices for testing your app. + You can set up a virtual device with the preview version of the platform from within Android Studio + using the Android Virtual Device Manager tool. +
+ ++ Important: Installing a preview image on a device removes all data from + it, so you should backup any data before installing a preview image. +
+ ++ You can set up virtual device with the preview version of the platform from within Android Studio + using the Android Virtual Device Manager tool. +
+ +To create an AVD with the AVD Manager:
+ ++ For more information about creating virtual devices for testing, see Managing Virtual Devices. +
diff --git a/docs/html/preview/support.jd b/docs/html/preview/support.jd new file mode 100644 index 0000000000000..cfd94671604fd --- /dev/null +++ b/docs/html/preview/support.jd @@ -0,0 +1,533 @@ +page.title=Support and Release Notes +page.tags="preview", "developer preview" +page.image=images/cards/card-support_16-9_2x.png + +@jd:body + +Includes final SDK and near-final system images
++ Two primary support channels are available to you when developing and testing + with the Android M Developer Preview. If you've encountered bugs or have + feedback about the M Developer Preview, you can create an issue on + our issue tracker. We'll triage the issue for further review and provide + updates as needed. +
+ ++ To discuss issues or ideas with other developers working with Android M, join + the M Developer Preview Google+ + community. +
+ +
+ Date: August 2015
+ Build: MPA44I
+ Hardware support: Nexus 5, 6, 9, Player
+ Emulator support: x86 & ARM 32/64-bit
+ Google Play services: 7.8
+
+ Developer Preview 3 is the final incremental update + to the Android M preview platform that was originally released in May 2015. + The update includes final APIs and the official Android 6.0 SDK, + as well as near-final system images for testing your apps. The + updated system images bring a variety of fixes and enhancements across + the system, including those related to issues reported by developers + through the external issue tracker. +
+ ++ If you are currently developing or testing on Android M, you should update + your environment as soon as possible, so that + you can begin final compatibility testing in preparation for + the public release to device manufacturers later this year.
+ +Updating to the Android 6.0 SDK and the latest + system images 3 ensures that you are building against final + platform APIs in API level 23 and testing + against final behaviors. If you are just getting started, + follow the instructions in Set up the Preview SDK. +
+ ++ Developer Preview 3 includes the official Android 6.0 + SDK as well as updated preview system images, documentation, + and samples for developing against the Android 6.0 + development platform. +
+ +shouldShowRequestPermissionRationale().
+ + For a complete list of changes, including renamed and removed APIs, see the API Diff report for + API level 22 to 23. +
+ ++ For a complete list of reported issues, please refer to the open issues list on the + Developer Preview issue tracker. +
+ ++ You can download the official Android 6.0 SDK platform and + Developer Preview 3 emulator images from the SDK Manager. +
+ ++ Developer Preview 3 system images for supported Nexus devices are available + by download and by over-the-air (OTA) update. The OTA update is available + only to supported devices that are currently running a Developer Preview build. + If your device is running a Developer Preview build, you should automatically receive + the OTA update within a few days of availability. +
+ ++ For instructions on how to download and flash your device to the latest Developer + Preview, see the links and instructions on the Downloads page. +
+ ++ For instructions on how to start developing and testing with Android 6.0 + Marshmallow, read Setting + up the SDK. +
+ +
+ Date: July 2015
+ Builds: MPZ79M (Nexus 5, 6, 9), MPZ79N (Nexus Player)
+ Hardware support: Nexus 5, 6, 9, Player
+ Emulator support: x86 & ARM 32/64-bit
+ Google Play services: 7.6
+
+ Android M Developer Preview 2 is an incremental update to + the Android M preview platform that was originally released in May 2015. The + update includes a variety of enhancements and bug fixes made across the + system, including those related to issues reported by developers through the + external issue tracker. +
+ ++ If you are currently developing or testing on Android M, you should + update your environment to Developer Preview 2 as soon as + possible. This ensures that you are building with the latest platform APIs + and testing against the latest behaviors. If you are just getting started + with the Android M Developer Preview SDK, follow the instructions in Set up the Preview SDK, then update your + environment for Developer Preview 2. +
+ ++ Developer Preview 2 includes an updated SDK with system images, + documentation, and samples for developing against the latest Android M + platform. +
+ +shouldShowRequestPermissionRationale().
+ android.permission.USE_FINGERPRINT permission now
+ has "normal" protection level, so it is no longer necessary to request
+ this permission directly from the user. The USE_FINGERPRINT
+ permission enables fingerprints to be enabled for authentication, but
+ does not give the requesting app access to the enrollment/fingerprint
+ administration flow.
+ android.permission.WRITE_EXTERNAL_STORAGE permission
+ has protection level "dangerous", meaning that apps wanting to write to
+ external storage will need to request permission from the user at
+ runtime. Both READ_EXTERNAL_STORAGE and
+ WRITE_EXTERNAL_STORAGE are members of the
+ STORAGE permission group.
+ android.permission.ACCESS_COARSE_LOCATION or
+ android.permission.ACCESS_FINE_LOCATION permission.
+ CONTACTS permissions group and others are removed or granted
+ based on account type. In particular,
+ android.permission.USE_CREDENTIALS,
+ android.permission.MANAGE_ACCOUNTS, and
+ android.permission.AUTHENTICATE_ACCOUNTS are ungrouped
+ pending further changes in a later release.
+ android.permission.CHANGE_WIFI_STATE,
+ android.permission.CHANGE_WIMAX_STATE, and
+ android.permission.CHANGE_WIFI_MULTICAST_STATE now have
+ protection level "normal".
+ android.permission.BLUETOOTH
+ and android.permission.BLUETOOTH_ADMIN now have protection
+ level "normal".
+ Activity.shouldShowRequestPermissionRationale(String), which
+ lets your app see whether users have previously rejected a permission
+ request. This lets you know that your app should explain the the user why
+ it needs that permission. For more information see the Permissions
+ developer guide.
+ android.app.AssistContent and
+ android.app.AssistStructure classes are moved into a new
+ package, android.app.assist.
+ View.OnStylusButtonPressListener class is renamed to
+ View.OnContextClickListener and
+ GestureDetector.OnStylusButtonPressListener class to
+ GestureDetector.OnContextClickListener.
+ + For a complete list of changes, including renamed and removed APIs, please + refer to the API Diff Reports included in the Developer Documentation download package. +
+ ++ For a complete list of reported issues, please refer to the open issues list on the + Developer Preview issue tracker. +
+ ++ You can download the Developer Preview 2 platform and emulator images from + the SDK Manager. +
+ ++ Developer Preview 2 system images for supported Nexus devices are available + by download and by over-the-air (OTA) update. The OTA update is available + only to supported devices that are currently running Developer Preview 1. If + your devices are running Developer Preview 1, you should automatically receive + the OTA update within a few days of availability. +
+ ++ If you are just getting started with Android M Developer Preview, and want + to receive Developer Preview 2 via OTA, download the appropriate + Developer Preview 1 + system image, and flash it to your device. Then, + leave the device powered on for several hours. It registers with the + OTA service, and receives Developer Preview 2 by OTA. +
+ ++ For instructions on how to download and flash your device to the Developer + Preview, see the links and instructions on the Downloads page. +
+ ++ For instructions on how to start developing and testing with Android M, read + Setting up the SDK. +
+ +
+ Date: May 2015
+ Build: MPZ44Q
+ Hardware support: Nexus 5, 6, 9, Player
+ Emulator support: x86 & ARM (32/64-bit)
+ Google Play services: 7.5
+
+ Initial release. +
+ +