diff --git a/core/java/android/nfc/cardemulation/HostApduService.java b/core/java/android/nfc/cardemulation/HostApduService.java
index ad34e61..9aa4062 100644
--- a/core/java/android/nfc/cardemulation/HostApduService.java
+++ b/core/java/android/nfc/cardemulation/HostApduService.java
@@ -20,9 +20,9 @@
  *
  * <div class="special reference">
  * <h3>Developer Guide</h3>
- * For a general introduction into the topic of card emulation,
- * please read the <a href="{@docRoot}guide/topics/nfc/ce.html">
- * NFC card emulation developer guide.</a></p>
+ * For a general introduction to card emulation, see
+ * <a href="{@docRoot}guide/topics/connectivity/nfc/hce.html">
+ * Host-based Card Emulation</a>.</p>
  * </div>
  *
  * <h3>NFC Protocols</h3>
diff --git a/docs/html-intl/intl/es/index.jd b/docs/html-intl/intl/es/index.jd
index 985ace3..66f9bf0 100644
--- a/docs/html-intl/intl/es/index.jd
+++ b/docs/html-intl/intl/es/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html-intl/intl/ja/index.jd b/docs/html-intl/intl/ja/index.jd
index 1176bf5..755ec62 100644
--- a/docs/html-intl/intl/ja/index.jd
+++ b/docs/html-intl/intl/ja/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html-intl/intl/ko/index.jd b/docs/html-intl/intl/ko/index.jd
index ee43ab4..01c8587 100644
--- a/docs/html-intl/intl/ko/index.jd
+++ b/docs/html-intl/intl/ko/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html-intl/intl/pt-br/index.jd b/docs/html-intl/intl/pt-br/index.jd
index 5aaa60a..f5e1569 100644
--- a/docs/html-intl/intl/pt-br/index.jd
+++ b/docs/html-intl/intl/pt-br/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html-intl/intl/ru/index.jd b/docs/html-intl/intl/ru/index.jd
index d3dd99e..e917a8d 100644
--- a/docs/html-intl/intl/ru/index.jd
+++ b/docs/html-intl/intl/ru/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html-intl/intl/zh-cn/index.jd b/docs/html-intl/intl/zh-cn/index.jd
index ec27765..ca3a84b 100644
--- a/docs/html-intl/intl/zh-cn/index.jd
+++ b/docs/html-intl/intl/zh-cn/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html-intl/intl/zh-tw/index.jd b/docs/html-intl/intl/zh-tw/index.jd
index d3fe838..a5772ef 100644
--- a/docs/html-intl/intl/zh-tw/index.jd
+++ b/docs/html-intl/intl/zh-tw/index.jd
@@ -22,7 +22,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html/design/downloads/index.jd b/docs/html/design/downloads/index.jd
index e37b305..bcdd8e0 100644
--- a/docs/html/design/downloads/index.jd
+++ b/docs/html/design/downloads/index.jd
@@ -31,10 +31,10 @@
   </div>
   <div class="col-4">
   <a class="download-button"  onClick="ga('send', 'event', 'Design', 'Download', 'Wear Toolkit AI');"
-    href="{@docRoot}downloads/design/Android_Wear_Toolkit_20140722.ai">Adobe&reg; Illustrator&reg; Toolkit</a>
+    href="{@docRoot}downloads/design/Android_Wear_Toolkit_371.ai">Adobe&reg; Illustrator&reg; Toolkit</a>
 
   <a class="download-button"  onClick="ga('send', 'event', 'Design', 'Download', 'Wear Toolkit PDF');"
-    href="{@docRoot}downloads/design/Android_Wear_Toolkit_20140722.pdf">PDF Toolkit</a>
+    href="{@docRoot}downloads/design/Android_Wear_Toolkit_371.pdf">PDF Toolkit</a>
   </div>
 </div>
 
@@ -155,4 +155,4 @@
   <a class="download-button"  onClick="ga('send', 'event', 'Design', 'Download', 'Wear Watch Face Example Specifications');"
     href="{@docRoot}downloads/design/Slide_IconExample.psd">Adobe&reg; Photoshop&reg; Icon</a>
   </div>
-</div>
\ No newline at end of file
+</div>
diff --git a/docs/html/google/play/billing/billing_admin.jd b/docs/html/google/play/billing/billing_admin.jd
index 383ef5d..ff7acc9 100644
--- a/docs/html/google/play/billing/billing_admin.jd
+++ b/docs/html/google/play/billing/billing_admin.jd
@@ -155,8 +155,8 @@
     application.</p>
   </li>
   <li><strong>Title</strong>
-    <p>The title is a short descriptor for the item. For example, "Sleeping potion." Titles must be
-    unique across an application's namespace. Every item must have a title. The title is visible to
+    <p>The title is a short descriptor for the item. For example, "Sleeping potion."
+    Every item must have a title. The title is visible to
     users during checkout. For optimum appearance, titles should be no longer than 25 characters;
     however, titles can be up to 55 characters in length.</p>
   </li>
@@ -201,7 +201,7 @@
 <p>To add a batch of items to a product list using a CSV file, you first need to create your CSV
 file. The data values that you specify in the CSV file represent the same data values you specify
 manually through the In-app Products UI (see <a href="#billing-form-add">Adding items one at a time
-to a product list</a>). 
+to a product list</a>).
 
 <p>If you are importing and exporting CSV files with in-app products, please
 keep tax-inclusive pricing in mind. If you use auto-fill, you can provide a
diff --git a/docs/html/guide/topics/manifest/uses-feature-element.jd b/docs/html/guide/topics/manifest/uses-feature-element.jd
index 1ab1041..5472453 100755
--- a/docs/html/guide/topics/manifest/uses-feature-element.jd
+++ b/docs/html/guide/topics/manifest/uses-feature-element.jd
@@ -553,12 +553,27 @@
        <th>Comments</th>
     </tr>
     <tr>
-       <td>Audio</td>
-       <td><code>android.hardware.audio.low_latency</td>
+       <td rowspan="4">Audio</td>
+       <td><code>android.hardware.audio.low_latency</code></td>
        <td>The application uses a low-latency audio pipeline on the device and
-is sensitive to delays or lag in sound input or output.</td>
-<td>
-</td>
+           is sensitive to delays or lag in sound input or output.</td>
+       <td></td>
+    </tr>
+    <tr>
+       <td><code>android.hardware.audio.pro</code></td>
+       <td>The application uses high-end audio functionality and performance.</td>
+       <td></td>
+    </tr>
+    <tr>
+       <td><code>android.hardware.microphone</code></td>
+       <td>The application records audio via a microphone.</td>
+       <td></td>
+    </tr>
+    </tr>
+       <td><code>android.hardware.output</code></td>
+       <td>The application produces at least one form of audio output, such as speakers, audio jack
+           or streaming over bluetooth.</td>
+       <td></td>
     </tr>
     <tr>
        <td rowspan="2">Bluetooth</td>
@@ -944,6 +959,12 @@
   support Live Wallpapers.</td>
 </tr>
 <tr>
+  <td>MIDI</td>
+  <td><code>android.software.midi</code></td>
+  <td>The application connects to musical instruments or outputs sound
+  using the Musical Instrument Digital Interface (MIDI) protocol.</td>
+</tr>
+<tr>
   <td rowspan="2">SIP/VOIP</td>
   <td><code>android.software.sip</code></td>
   <td>The application uses SIP service on the device and should be installed only on devices that
diff --git a/docs/html/index.jd b/docs/html/index.jd
index 129564c..2f67c58 100644
--- a/docs/html/index.jd
+++ b/docs/html/index.jd
@@ -23,7 +23,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for the next version of Android!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
diff --git a/docs/html/jd_collections.js b/docs/html/jd_collections.js
index 31539da..bedbd2e 100644
--- a/docs/html/jd_collections.js
+++ b/docs/html/jd_collections.js
@@ -149,6 +149,7 @@
   "preview/landing/more": {
     "title": "",
     "resources": [
+      "https://www.youtube.com/watch?v=CsulIu3UaUM",
       "preview/features/multi-window.html",
       "preview/features/notification-updates.html",
       "preview/features/background-optimization.html",
diff --git a/docs/html/jd_extras.js b/docs/html/jd_extras.js
index e108d13..75b51fb 100644
--- a/docs/html/jd_extras.js
+++ b/docs/html/jd_extras.js
@@ -3281,6 +3281,18 @@
     "type":"distribute"
   },
   {
+    "title":"What’s New in Android N Developer Preview",
+    "titleFriendly":"",
+    "summary":"Learn all about the new features in the Android N Preview.",
+    "url":"https://www.youtube.com/watch?v=CsulIu3UaUM",
+    "group":"",
+    "keywords": ["n preview"],
+    "tags": [],
+    "image":"https://i1.ytimg.com/vi/CsulIu3UaUM/maxresdefault.jpg",
+    "lang":"en",
+    "type":"Video"
+  },
+  {
     "title":"Developing for Android 6.0 (Marshmallow)",
     "titleFriendly":"",
     "summary":"This video covers how to get started with the preview, important APIs to test and how to provide feedback on the preview.",
diff --git a/docs/html/preview/api-overview.jd b/docs/html/preview/api-overview.jd
index e6a90bb..d316faf 100644
--- a/docs/html/preview/api-overview.jd
+++ b/docs/html/preview/api-overview.jd
@@ -14,24 +14,26 @@
       <ul style="list-style-type:none;">
         <li><a href="#multi-window_support">Multi-window support</a></li>
         <li><a href="#notification_enhancements">Notifications</a></li>
-        <li><a href="#tile_api">Quick Settings Tile API</a></li>
-        <li><a href="#data_saver">Data Saver</a></li>
-        <li><a href="#multi-locale_languages">Locales and languages</a></li>
-        <li><a href="#icu4">ICU4J APIs in Android</a></li>
-        <li><a href="#android_tv_recording">Android TV recording</a></li>
-        <li><a href="#number-blocking">Number-blocking</a></li>
-        <li><a href="#call_screening">Call screening</a></li>
-        <li><a href="#direct_boot">Direct Boot</a></li>
-        <li><a href="#key_attestation">Key Attestation</a></li>
-        <li><a href="#network_security_config">Network Security Config</a></li>
-        <li><a href="#default_trusted_ca">Default Trusted CA</a></li>
-        <li><a href="#scoped_directory_access">Scoped directory access</a></li>
-        <li><a href="#android_for_work">Android for Work</a></li>
         <li><a href="#jit_aot">JIT/AOT compilation</a></li>
         <li><a href="#quick_path_to_app_install">Quick path to app install</a></li>
         <li><a href="#doze_on_the_go">Doze on the go</a></li>
         <li><a href="#background_optimizations">Background optimizations</a></li>
-        <li><a href="#gles_32">OpenGLTM ES 3.2 API</a></li>
+        <li><a href="#data_saver">Data Saver</a></li>
+        <li><a href="#tile_api">Quick Settings Tile API</a></li>
+        <li><a href="#number-blocking">Number-blocking</a></li>
+        <li><a href="#call_screening">Call screening</a></li>
+        <li><a href="#multi-locale_languages">Locales and languages</a></li>
+        <li><a href="#icu4">ICU4J APIs in Android</a></li>
+        <li><a href="#gles_32">OpenGL ES 3.2 API</a></li>
+        <li><a href="#android_tv_recording">Android TV recording</a></li>
+        <li><a href="#android_for_work">Android for Work</a></li>
+        <li><a href="#accessibility_enhancements">Accessibility</a></li>
+        <li><a href="#direct_boot">Direct Boot</a></li>
+        <li><a href="#key_attestation">Key Attestation</a></li>
+        <li><a href="#network_security_config">Network Security Config</a></li>
+        <li><a href="#default_trusted_ca">Default Trusted CA</a></li>
+        <li><a href="apk_signature_v2">APK signature scheme v2</a></li>
+        <li><a href="#scoped_directory_access">Scoped directory access</a></li>
       </ol>
 </div>
 </div>
@@ -70,17 +72,14 @@
 interacts with other apps. See below for more information. </li>
   </ul>
 
-
-
 <div class="col-4of10">
-<img src="{@docRoot}preview/images/mw-portrait.png" alt="" style="height:460px"
+<img src="{@docRoot}preview/images/mw-portrait.png" alt="" style="height:460px;padding-left:1em;"
     id="img-split-screen" />
 <p class="img-caption">
-  <strong>Figure 1.</strong> Two apps running in split-screen mode.
+  <strong>Figure 1.</strong> Apps running in split-screen mode.
 </p>
   </div>
 
-
 <p>Especially on tablets and other larger-screen devices, multi-window support
 gives you new ways to engage users. You can even enable drag-and-drop in
 your app to let users conveniently drag content to or from your app &mdash; a great
@@ -115,7 +114,7 @@
     together, for example by message topic, and display the group. A user can
     take actions, such as Dismiss or Archive, on them in place. If you’ve
     implemented notifications for Android Wear, you’ll already be familiar with
-    this model. with this model.
+    this model.
   </li>
 
   <li>
@@ -156,46 +155,121 @@
   guide.</p>
 
 
-<h2 id="tile_api">Quick Settings Tile API</h2>
+
+<h2 id="jit_aot">Profile-guided JIT/AOT compilation</h2>
+
+<p>In Android N, we've added a Just in Time (JIT) compiler with code profiling to
+ART, which lets it constantly improve the performance of Android apps as they
+run. The JIT compiler complements ART's current Ahead of Time (AOT) compiler
+and helps improve runtime performance, save storage space, and speed up app
+updates and system updates.</p>
+
+<p>Profile-guided compilation lets ART manage the AOT/JIT compilation for each app
+according to its actual usage, as well as conditions on the device. For
+example, ART maintains a profile of each app's hot methods and can precompile
+and cache those methods for best performance. It leaves other parts of the app
+uncompiled until they are actually used.</p>
+
+<p>Besides improving performance for key parts of the app, profile-guided
+compilation helps reduce an app's overall RAM footprint, including associated
+binaries. This feature is especially important on low-memory devices.</p>
+
+<p>ART manages profile-guided compilation in a way that minimizes impact on the
+device battery. It does precompilation only when then the device is idle and
+charging, saving time and battery by doing that work in advance.</p>
+
+<h2 id="quick_path_to_app_install">Quick path to app install</h2>
+
+<p>One of the most tangible benefits of ART's JIT compiler is the speed of app
+installs and system updates. Even large apps that required several minutes to
+optimize and install in Android 6.0 can now install in just a matter of
+seconds. System updates are also faster, since there's no more optimizing step. </p>
+
+<h2 id="doze_on_the_go">Doze on the go...</h2>
+
+<p>Android 6.0 introduced Doze, a system mode that saves battery by deferring
+apps' CPU and network activities when the device is idle, such as when it's
+sitting on a table or in a drawer. </p>
+
+<p>Now in Android N, Doze takes a step further and saves battery while on the go.
+Any time the screen is off for a period of time and the device is unplugged,
+Doze applies a subset of the familiar CPU and network restrictions to apps.
+This means users can save battery even when carrying their devices in their
+pockets.</p>
 
 
-<div style="float:right;max-width:320px">
-<img src="{@docRoot}preview/images/quicksettings.png" style="padding-left:1.5em;">
-
-<p class="img-caption" style="padding-left:2em;">
-  <strong>Figure 3.</strong> Quick Settings tiles in the notification shade.
+<img src="/preview/images/doze-diagram-1.png"
+  alt="" id="figure1" />
+<p class="img-caption">
+  <strong>Figure 3.</strong> Doze now applies
+  restrictions to improve battery life even when the device is not stationary.
 </p>
 
 
-  </div><p>Quick Settings is a popular and simple way to expose key settings and actions,
-directly from the notification shade. In Android N, we've expanded the scope of
-Quick Settings to make it even more useful and convenient. </p>
+<p>A short time after the screen turns off while the device is on battery, Doze
+restricts network access and defers jobs and syncs. During brief maintenance
+windows, applications are allowed network access and any of their deferred
+jobs/syncs are executed. Turning the screen on or plugging in the device brings
+the device out of Doze.</p>
 
-<p>We've added more room for additional Quick Settings tiles, which users can
-access across a paginated display area by swiping left or right. We've also
-given users control over what Quick Settings tiles appear and where they are
-displayed &mdash; users can add or move tiles just by dragging and dropping them. </p>
+<p>When the device is stationary again, with screen off and on battery for a
+period of time, Doze applies the full CPU and network restrictions on {@link
+android.os.PowerManager.WakeLock}, {@link android.app.AlarmManager} alarms, and
+GPS/Wi-Fi scans.</p>
 
-<p>For developers, Android N also adds a new API that lets you define your own
-  Quick Settings tiles to give users easy access to key controls and actions in your app.</p>
+<p>The best practices for adapting your app to Doze are the same whether the
+device is moving or not, so if you already updated your app to gracefully
+handle Doze, you're all set. If not, start <a
+href="{@docRoot}training/monitoring-device-state/doze-standby.html#assessing_your_app">adapting
+your app to Doze</a> now.</p>
+
+<h2 id="background_optimizations">Project Svelte: Background optimizations</h2>
+
+<p>Project Svelte is an ongoing effort to minimize RAM use by system and apps
+across the range of Android devices in the ecosystem. In Android N, Project
+Svelte is focused on optimizing the way apps run in the background. </p>
+
+<p>Background processing is an essential part of most apps. When handled right, it
+can make your user experience amazing &mdash; immediate, fast, and context-aware.
+When not handled right, background processing can needlessly consume RAM (and
+battery) and affect system performance for other apps. </p>
+
+<p>Since Android 5.0, {@link android.app.job.JobScheduler} has been the
+preferred way of performing background work in a way that's good
+for users. Apps can schedule jobs while letting the system optimize based on
+memory, power, and connectivity conditions. JobScheduler offers control and
+simplicity, and we want all apps to use it. </p>
 
 <p>
-  Quick Settings tiles are reserved for controls or actions that are either
-  urgently required or frequently used, and should not be used as shortcuts to
-  launching an app.
+  Another good option is <a href=
+  "https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmNetworkManager">
+  <code>GCMNetworkManager</code></a>, part of Google Play Services, which
+  offers similar job scheduling with compatibility across legacy versions of
+  Android.
 </p>
 
-<p>
-  Once you’ve defined your tiles, you can surface them to users, who can add
-  them to Quick Settings just by drag and drop.
-</p>
+<p>We're continuing to extend <code>JobScheduler</code> and
+<code>GCMNetworkManager</code> to meet more of
+your use cases &mdash; for example, in Android N you can now schedule background
+work based on changes in Content Providers. At the same time we're starting to
+deprecate some of the older patterns that can reduce system performance,
+especially on low-memory devices.</p>
+
+<p>In Android N we're removing three commonly-used implicit broadcasts &mdash;
+ {@link android.net.ConnectivityManager#CONNECTIVITY_ACTION}, {@link
+  android.hardware.Camera#ACTION_NEW_PICTURE}, and {@link
+  android.hardware.Camera#ACTION_NEW_VIDEO} &mdash; since those can wake the
+background processes of multiple apps at once and strain memory and battery. If
+your app is receiving these, take advantage of the N Developer Preview to
+  migrate to <code>JobScheduler</code> and related APIs instead. </p>
 
 <p>
-  For information about creating an app tile, see the
-  <code>android.service.quicksettings.Tile</code> in the downloadable <a href=
-  "{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
+  Take a look at the <a href=
+  "{@docRoot}preview/features/background-optimization.html">Background
+  Optimizations</a> documentation for details.
 </p>
 
+
 <h2 id="data_saver">Data Saver</h2>
 
 <div class="col-5of12" style="margin-right:1.5em;">
@@ -230,75 +304,48 @@
 preference changes</a>. All apps should check whether the user has enabled Data
 Saver and make an effort to limit foreground and background data usage.</p>
 
-<h2 id="multi-locale_languages">Multi-locale support, more languages</h2>
+
+<h2 id="tile_api">Quick Settings Tile API</h2>
 
 
-<p>Android N now lets users select <strong>multiple locales</strong> in Settings,
-to better support bilingual use-cases. Apps can use
-a new API to get the user's selected locales and then offer more sophisticated
-user experiences for multi-locale users &mdash; such as showing search results in
-multiple languages and not offering to translate webpages in a language the
-user already knows.</p>
+<div style="float:right;max-width:320px">
+<img src="{@docRoot}preview/images/quicksettings.png" style="padding-left:1.5em;">
 
-<p>Along with multi-locale support, Android N also expands the range of languages
-available to users. It offers more than 25 variants each for commonly used
-languages such as English, Spanish, French, and Arabic. It also adds partial
-support for more than 100 new languages.</p>
+<p class="img-caption" style="padding-left:2em;">
+  <strong>Figure 5.</strong> Quick Settings tiles in the notification shade.
+</p>
 
-<p>Apps can get the list of locales set by the user by calling <code>LocaleList.GetDefault()</code>.  To support the expanded number of locales, Android N is changing the way
-that it resolves resources. Make sure that you test and verify that your apps
-working as expected with the new resource resolution logic.</p>
 
-<p>To learn about the new resource-resolution behavior and the best practices you
-should follow, see <a href="{@docRoot}preview/features/multilingual-support.html">Multilingual Support</a>.</p>
+  </div><p>Quick Settings is a popular and simple way to expose key settings and actions,
+directly from the notification shade. In Android N, we've expanded the scope of
+Quick Settings to make it even more useful and convenient. </p>
 
-<h2 id="icu4">ICU4J APIs in Android</h2>
+<p>We've added more room for additional Quick Settings tiles, which users can
+access across a paginated display area by swiping left or right. We've also
+given users control over what Quick Settings tiles appear and where they are
+displayed &mdash; users can add or move tiles just by dragging and dropping them. </p>
+
+<p>For developers, Android N also adds a new API that lets you define your own
+  Quick Settings tiles to give users easy access to key controls and actions in your app.</p>
 
 <p>
-  Android N now offers a subset of <a href=
-  "http://site.icu-project.org/">ICU4J</a> APIs in the Android framework under
-  the <code>android.icu</code> package. Migration is easy, and mostly entails
-  simply changing from the <code>com.java.icu</code> namespace to
-  <code>android.icu</code>. If you are already using an ICU4J bundle in your
-  apps, switching to the <code>android.icu</code> APIs provided in the Android
-  framework can produce substantial savings in APK size.
+  Quick Settings tiles are reserved for controls or actions that are either
+  urgently required or frequently used, and should not be used as shortcuts to
+  launching an app.
 </p>
 
 <p>
-  To learn more about the Android ICU4J APIs, see <a href=
-  "{@docRoot}preview/features/icu4j-framework.html">ICU4J Support</a>.
+  Once you’ve defined your tiles, you can surface them to users, who can add
+  them to Quick Settings just by drag and drop.
 </p>
 
-<h2 id="android_tv_recording">Android TV recording</h2>
-
-<p>Android N adds the ability to record and playback content from Android TV input
-services via new recording APIs.  Building on top of existing time-shifting
-APIs, TV input services can control what channel data can be recorded, how
-recorded sessions are saved, and manage user interaction with recorded content. </p>
-
-<p>For more information, see <a
-href="{@docRoot}preview/features/tv-recording-api.html">Android TV Recording APIs</a>.</p>
-
-<h2 id="accessibility_enhancements">Accessibility enhancements</h2>
+<p>
+  For information about creating an app tile, see the
+  <code>android.service.quicksettings.Tile</code> in the downloadable <a href=
+  "{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
+</p>
 
 
-<p>Android N now offers Vision Settings directly on the Welcome screen for new
-device setup. This makes it much easier for users to discover and configure
-accessibility features on their devices, including magnification gesture, font
-size, display size, and TalkBack. </p>
-
-<p>With these accessibility features getting more prominent placement, your users
-are more likely to try your app with them enabled. Make sure you test your apps
-early with these settings enabled. You can enable them from Settings >
-Accessibility.</p>
-
-<p>Also in Android N, accessibility services can now help users with motor
-impairments to touch the screen. The new API allows building services with
-features such as face-tracking, eye-tracking, point scanning, and so on, to
-meet the needs of those users.</p>
-
-<p>For more information, see <code>android.accessibilityservice.GestureDescription</code>
-	in the downloadable <a href="{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.</p>
 
 <h2 id="number-blocking">Number-blocking</h2>
 
@@ -351,144 +398,80 @@
 </p>
 
 
-<h2 id="direct_boot">Direct boot</h2>
+<h2 id="multi-locale_languages">Multi-locale support, more languages</h2>
 
-<p>Direct boot improves device startup times and lets registered
-apps have limited functionality even after an unexpected reboot.
-For example, if an encrypted device reboots while the user is sleeping,
-registered alarms, messages and incoming calls can now continue notify
-the user as normal. This also means accessibility services can also be
-  available immediately after a restart.</p>
 
-<p>Direct boot takes advantage of file based encryption in Android N
-to enable fine grained encryption policies for both system and app data.
-The system uses a device-encrypted store for select system data and explicitly
-registered app data. By default a credential-encrypted store is used for all
-  other system data, user data, apps, and app data. </p>
+<p>Android N now lets users select <strong>multiple locales</strong> in Settings,
+to better support bilingual use-cases. Apps can use
+a new API to get the user's selected locales and then offer more sophisticated
+user experiences for multi-locale users &mdash; such as showing search results in
+multiple languages and not offering to translate webpages in a language the
+user already knows.</p>
 
-<p>At boot, the system starts in a restricted mode with access to
-device-encrypted data only, and without general access to apps or data.
-If you have components that you want to run in this mode, you can register
-them by setting a flag in the manifest. After restart, the system activates
-registered components by broadcasting the <code>LOCKED_BOOT_COMPLETED</code>
-intent. The system ensures registered device-encrypted app data is available
-before unlock. All other data is unavailable until the User confirms their lock
-  screen credentials to decrypt it. </p>
+<p>Along with multi-locale support, Android N also expands the range of languages
+available to users. It offers more than 25 variants each for commonly used
+languages such as English, Spanish, French, and Arabic. It also adds partial
+support for more than 100 new languages.</p>
 
-For more information, see <a href="{@docRoot}preview/features/direct-boot.html">Direct Boot</a>.</p>
+<p>Apps can get the list of locales set by the user by calling <code>LocaleList.GetDefault()</code>.  To support the expanded number of locales, Android N is changing the way
+that it resolves resources. Make sure that you test and verify that your apps
+working as expected with the new resource resolution logic.</p>
+
+<p>To learn about the new resource-resolution behavior and the best practices you
+should follow, see <a href="{@docRoot}preview/features/multilingual-support.html"
+>Multilingual Support</a>.</p>
+
+<h2 id="icu4">ICU4J APIs in Android</h2>
+
+<p>
+  Android N now offers a subset of <a href=
+  "http://site.icu-project.org/">ICU4J</a> APIs in the Android framework under
+  the <code>android.icu</code> package. Migration is easy, and mostly entails
+  simply changing from the <code>com.java.icu</code> namespace to
+  <code>android.icu</code>. If you are already using an ICU4J bundle in your
+  apps, switching to the <code>android.icu</code> APIs provided in the Android
+  framework can produce substantial savings in APK size.
+</p>
+
+<p>
+  To learn more about the Android ICU4J APIs, see <a href=
+  "{@docRoot}preview/features/icu4j-framework.html">ICU4J Support</a>.
 </p>
 
 
-  <h3 id="key_attestation">Key Attestation</h3>
 
-<p>Hardware-backed keystores provide a much safer method to create, store,
-and use cryptographic keys on Android devices. They protect keys from the
-Linux kernel, potential Android vulnerabilities, and extraction
-from rooted devices.</p>
+<h2 id="gles_32">OpenGL&trade; ES 3.2 API</h2>
 
-<p>To make it easier and more secure to use hardware-backed keystores,
-Android N introduces Key Attestation. Apps and off-devices can use Key
-Attestation to strongly determine whether an RSA or EC key pair is
-hardware-backed, what the properties of the key pair are, and what
-  constraints are applied to its usage and validity. </p>
-
-<p>Apps and off-device services can request information about a key pair
-through an X.509 attestation certificate which must be signed by a valid
-attestation key. The attestation key is an ECDSA signing key which is
-injected into the device’s hardware-backed keystore at the factory.
-Therefore, an attestation certificate signed by a valid attestation
-key confirms the existence of a hardware-backed keystore, along with
-  details of key pairs in that keystore.</p>
-
-<p>To ensure that the device is using a secure, official Android factory
-image, Key Attestation requires that the device <a
-class="external-link"
-href="https://source.android.com/security/verifiedboot/verified-boot.html#bootloader_requirements">bootloader</a>
-provide the following information to the <a class="external-link"
-href="https://source.android.com/security/trusty/index.html">Trusted
-Execution Environment (TEE)</a>:</p>
+<p>Android N adds framework interfaces and platform support for OpenGL ES 3.2, including:</p>
 
 <ul>
-<li>The OS version and patch level installed on the device</li>
-<li>The <a class="external-link" href="https://source.android.com/security/verifiedboot/index.html">Verified
-Boot</a> public key and lock status</li>
-  </ul>
-
-<p>For more information about the hardware-backed keystore feature,
-see the guide for <a href="">Hardware-backed Keystore</a>.
-
-  <p>In addition to Key Attestation, Android N also introduces
-  fingerprint-bound keys that are not revoked on fingerprint enrollment.</p>
-
-  <h3 id="network_security_config">Network Security Config</h3>
-
-<p>In Android N, apps can customize the behavior of their secure (HTTPS, TLS)
-connections safely, without any code modification, by using the declarative
-<em>Network Security Config</em> instead of using the conventional
-error-prone programmatic APIs (e.g. X509TrustManager).</p>
-
-  <p>Supported features:</p>
-<ul>
-<li><b>Custom trust anchors.</b> Lets an application customize which
-Certificate Authorities (CA) are trusted for its secure connections. For
-example, trusting particular self-signed certificates or a restricted set of public CAs.
-</li>
-<li><b>Debug-only overrides.</b> Lets an application developer safely debug
-secure connections of their application without added risk to the installed
-base.
-</li>
-<li><b>Cleartext traffic opt-out.</b> Lets an application protect itself from
-accidental usage of cleartext traffic.</li>
-<li><b>Certificate pinning.</b> An advanced feature that lets an application
-  limit which server keys are trusted for secure connections.</li>
+  <li> All extensions from the <a class="external-link"
+href="https://www.khronos.org/registry/gles/extensions/ANDROID/ANDROID_extension_pack_es31a.txt">Android Extension Pack</a></a> (AEP) except for <code>EXT_texture_sRGB_decode</code>.
+  <li> Floating-point framebuffers for HDR and deferred shading.
+  <li> BaseVertex draw calls to enable better batching and streaming.
+  <li> Robust buffer access control to reduce WebGL overhead.
 </ul>
 
+<p>The framework API for OpenGL ES 3.2 on Android N is provided with the
+<code>GLES32</code> class. When using OpenGL ES 3.2, be sure to declare the
+requirement in your manifest file, using the <code>&lt;uses-feature&gt;</code> tag and
+the <code>android:glEsVersion</code> attribute. </p>
+
+<p>For information about using OpenGL ES, including how to check a device's
+supported OpenGL ES version at runtime, see the <a
+href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL ES API guide</a>.</p>
+
+
+<h2 id="android_tv_recording">Android TV recording</h2>
+
+<p>Android N adds the ability to record and playback content from Android TV input
+services via new recording APIs.  Building on top of existing time-shifting
+APIs, TV input services can control what channel data can be recorded, how
+recorded sessions are saved, and manage user interaction with recorded content. </p>
+
 <p>For more information, see <a
-href="{@docRoot}preview/features/security-config.html">Network Security
-Config</a>.</p>
+href="{@docRoot}preview/features/tv-recording-api.html">Android TV Recording APIs</a>.</p>
 
-  <h3 id="default_trusted_ca">Default Trusted Certificate Authority</h3>
-
-<p>By default, apps that target Android N only trust system-provided certificates
-and no longer trust user-added Certificate Authorities (CA). Apps targeting Android
-N that wish to trust user-added CAs should use the
-<a href="{@docRoot}preview/features/security-config.html">Network Security Config</a> to
-specify how user CAs should be trusted.</p>
-
-  <h3 id="apk_signature_v2">APK signature scheme v2</h3>
-<p>The PackageManager class now supports verifying apps using the APK
-signature scheme v2. The APK signature scheme v2 is a whole-file signature scheme
-that significantly improves verification speed and strengthens integrity
-  guarantees by detecting any unauthorized changes to APK files.</p>
-
-<p>To maintain backward-compatibility, an APK must be signed with the v1 signature
-scheme (JAR signature scheme) before being signed with the v2 signature scheme.
-With the v2 signature scheme, verification fails if you sign the APK with an
-  additional certificate after signing with the v2 scheme. </p>
-
-<p>APK signature scheme v2 support will be available later in the N Developer
-Preview.</p>
-
-<h2 id="scoped_directory_access">Scoped directory access</h2>
-
-<p>In Android N, apps can use new APIs to request access to specific <a
-href="{@docRoot}guide/topics/data/data-storage.html#filesExternal">external
-storage</a> directories, including directories on removable media such as SD
-cards. The new APIs greatly simplify how your application accesses standard
-external storage directories, such as the <code>Pictures</code> directory. Apps
-like photo apps can use these APIs instead of using
-<code>READ_EXTERNAL_STORAGE</code>, which grants access to all storage
-directories, or the Storage Access Framework, which makes the user navigate to
-the directory.</p>
-
-<p>Additionally, the new APIs simplify the steps a user takes to grant external
-storage access to your app. When you use the new APIs, the system uses a simple
-permissions UI that clearly details what directory the application is
-requesting access to.</p>
-
-<p>For more information, see the
-<a href="{@docRoot}preview/features/scoped-folder-access.html">Scoped
-Directory Access</a> developer documentation.</p>
 
 <h2 id="android_for_work">Android for Work</h2>
 
@@ -551,132 +534,170 @@
   <strong>Settings&gt;More&gt;Vpn</strong>.
 </p>
 
+<h2 id="accessibility_enhancements">Accessibility enhancements</h2>
 
-<h2 id="jit_aot">Profile-guided JIT/AOT compilation</h2>
+<p>Android N now offers Vision Settings directly on the Welcome screen for new
+device setup. This makes it much easier for users to discover and configure
+accessibility features on their devices, including magnification gesture, font
+size, display size, and TalkBack. </p>
 
-<p>In Android N, we've added a Just in Time (JIT) compiler with code profiling to
-ART, which lets it constantly improve the performance of Android apps as they
-run. The JIT compiler complements ART's current Ahead of Time (AOT) compiler
-and helps improve runtime performance, save storage space, and speed up app
-updates and system updates.</p>
+<p>With these accessibility features getting more prominent placement, your users
+are more likely to try your app with them enabled. Make sure you test your apps
+early with these settings enabled. You can enable them from Settings >
+Accessibility.</p>
 
-<p>Profile-guided compilation lets ART manage the AOT/JIT compilation for each app
-according to its actual usage, as well as conditions on the device. For
-example, ART maintains a profile of each app's hot methods and can precompile
-and cache those methods for best performance. It leaves other parts of the app
-uncompiled until they are actually used.</p>
+<p>Also in Android N, accessibility services can now help users with motor
+impairments to touch the screen. The new API allows building services with
+features such as face-tracking, eye-tracking, point scanning, and so on, to
+meet the needs of those users.</p>
 
-<p>Besides improving performance for key parts of the app, profile-guided
-compilation helps reduce an app's overall RAM footprint, including associated
-binaries. This feature is especially important on low-memory devices.</p>
-
-<p>ART manages profile-guided compilation in a way that minimizes impact on the
-device battery. It does precompilation only when then the device is idle and
-charging, saving time and battery by doing that work in advance.</p>
-
-<h2 id="quick_path_to_app_install">Quick path to app install</h2>
-
-<p>One of the most tangible benefits of ART's JIT compiler is the speed of app
-installs and system updates. Even large apps that required several minutes to
-optimize and install in Android 6.0 can now install in just a matter of
-seconds. System updates are also faster, since there's no more optimizing step. </p>
-
-<h2 id="doze_on_the_go">Doze on the go...</h2>
-
-<p>Android 6.0 introduced Doze, a system mode that saves battery by deferring
-apps' CPU and network activities when the device is idle, such as when it's
-sitting on a table or in a drawer. </p>
-
-<p>Now in Android N, Doze takes a step further and saves battery while on the go.
-Any time the screen is off for a period of time and the device is unplugged,
-Doze applies a subset of the familiar CPU and network restrictions to apps.
-This means users can save battery even when carrying their devices in their
-pockets.</p>
+<p>For more information, see <code>android.accessibilityservice.GestureDescription</code>
+	in the downloadable <a href="{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.</p>
 
 
+<h2 id="direct_boot">Direct boot</h2>
 
+<p>Direct boot improves device startup times and lets registered
+apps have limited functionality even after an unexpected reboot.
+For example, if an encrypted device reboots while the user is sleeping,
+registered alarms, messages and incoming calls can now continue notify
+the user as normal. This also means accessibility services can also be
+  available immediately after a restart.</p>
 
+<p>Direct boot takes advantage of file based encryption in Android N
+to enable fine grained encryption policies for both system and app data.
+The system uses a device-encrypted store for select system data and explicitly
+registered app data. By default a credential-encrypted store is used for all
+  other system data, user data, apps, and app data. </p>
 
-<p>A short time after the screen turns off while the device is on battery, Doze
-restricts network access and defers jobs and syncs. During brief maintenance
-windows, applications are allowed network access and any of their deferred
-jobs/syncs are executed. Turning the screen on or plugging in the device brings
-the device out of Doze.</p>
+<p>At boot, the system starts in a restricted mode with access to
+device-encrypted data only, and without general access to apps or data.
+If you have components that you want to run in this mode, you can register
+them by setting a flag in the manifest. After restart, the system activates
+registered components by broadcasting the <code>LOCKED_BOOT_COMPLETED</code>
+intent. The system ensures registered device-encrypted app data is available
+before unlock. All other data is unavailable until the User confirms their lock
+  screen credentials to decrypt it. </p>
 
-<p>When the device is stationary again, with screen off and on battery for a
-period of time, Doze applies the full CPU and network restrictions on {@link
-android.os.PowerManager.WakeLock}, {@link android.app.AlarmManager} alarms, and
-GPS/Wi-Fi scans.</p>
-
-<p>The best practices for adapting your app to Doze are the same whether the
-device is moving or not, so if you already updated your app to gracefully
-handle Doze, you're all set. If not, start <a
-href="{@docRoot}training/monitoring-device-state/doze-standby.html#assessing_your_app">adapting
-your app to Doze</a> now.</p>
-
-<h2 id="background_optimizations">Project Svelte: Background optimizations</h2>
-
-<p>Project Svelte is an ongoing effort to minimize RAM use by system and apps
-across the range of Android devices in the ecosystem. In Android N, Project
-Svelte is focused on optimizing the way apps run in the background. </p>
-
-<p>Background processing is an essential part of most apps. When handled right, it
-can make your user experience amazing &mdash; immediate, fast, and context-aware.
-When not handled right, background processing can needlessly consume RAM (and
-battery) and affect system performance for other apps. </p>
-
-<p>Since Android 5.0, {@link android.app.job.JobScheduler} has been the preferred way of performing background work in a way that's good
-for users. Apps can schedule jobs while letting the system optimize based on
-memory, power, and connectivity conditions. JobScheduler offers control and
-simplicity, and we want all apps to use it. </p>
-
-<p>
-  Another good option is <a href=
-  "https://developers.google.com/android/reference/com/google/android/gms/gcm/GcmNetworkManager">
-  <code>GCMNetworkManager</code></a>, part of Google Play Services, which
-  offers similar job scheduling with compatibility across legacy versions of
-  Android.
+For more information, see <a href="{@docRoot}preview/features/direct-boot.html">Direct Boot</a>.</p>
 </p>
 
-<p>We're continuing to extend <code>JobScheduler</code> and <code>GCMNetworkManager</code> to meet more of
-your use cases &mdash; for example, in Android N you can now schedule background
-work based on changes in Content Providers. At the same time we're starting to
-deprecate some of the older patterns that can reduce system performance,
-especially on low-memory devices.</p>
 
-<p>In Android N we're removing three commonly-used implicit broadcasts &mdash;
- {@link android.net.ConnectivityManager#CONNECTIVITY_ACTION}, {@link
-  android.hardware.Camera#ACTION_NEW_PICTURE}, and {@link
-  android.hardware.Camera#ACTION_NEW_VIDEO} &mdash; since those can wake the
-background processes of multiple apps at once and strain memory and battery. If
-your app is receiving these, take advantage of the N Developer Preview to
-  migrate to <code>JobScheduler</code> and related APIs instead. </p>
+<h2 id="key_attestation">Key Attestation</h2>
 
-<p>
-  Take a look at the <a href=
-  "{@docRoot}preview/features/background-optimization.html">Background
-  Optimizations</a> documentation for details.
-</p>
+<p>Hardware-backed keystores provide a much safer method to create, store,
+and use cryptographic keys on Android devices. They protect keys from the
+Linux kernel, potential Android vulnerabilities, and extraction
+from rooted devices.</p>
 
-<h2 id="gles_32">OpenGL&trade; ES 3.2 API</h2>
+<p>To make it easier and more secure to use hardware-backed keystores,
+Android N introduces Key Attestation. Apps and off-devices can use Key
+Attestation to strongly determine whether an RSA or EC key pair is
+hardware-backed, what the properties of the key pair are, and what
+  constraints are applied to its usage and validity. </p>
 
-<p>Android N adds framework interfaces and platform support for OpenGL ES 3.2, including:</p>
+<p>Apps and off-device services can request information about a key pair
+through an X.509 attestation certificate which must be signed by a valid
+attestation key. The attestation key is an ECDSA signing key which is
+injected into the device’s hardware-backed keystore at the factory.
+Therefore, an attestation certificate signed by a valid attestation
+key confirms the existence of a hardware-backed keystore, along with
+  details of key pairs in that keystore.</p>
+
+<p>To ensure that the device is using a secure, official Android factory
+image, Key Attestation requires that the device <a
+class="external-link"
+href="https://source.android.com/security/verifiedboot/verified-boot.html#bootloader_requirements">bootloader</a>
+provide the following information to the <a class="external-link"
+href="https://source.android.com/security/trusty/index.html">Trusted
+Execution Environment (TEE)</a>:</p>
 
 <ul>
-  <li> All extensions from the <a class="external-link"
-href="https://www.khronos.org/registry/gles/extensions/ANDROID/ANDROID_extension_pack_es31a.txt">Android Extension Pack</a></a> (AEP) except for <code>EXT_texture_sRGB_decode</code>.
-  <li> Floating-point framebuffers for HDR and deferred shading.
-  <li> BaseVertex draw calls to enable better batching and streaming.
-  <li> Robust buffer access control to reduce WebGL overhead.
+<li>The OS version and patch level installed on the device</li>
+<li>The <a href="https://source.android.com/security/verifiedboot/index.html"
+class="external-link" >Verified Boot</a> public key and lock status</li>
+  </ul>
+
+<p>For more information about the hardware-backed keystore feature,
+see the guide for <a href="https://source.android.com/security/keystore/"
+class="external-link">Hardware-backed Keystore</a>.</p>
+
+<p>In addition to Key Attestation, Android N also introduces
+  fingerprint-bound keys that are not revoked on fingerprint enrollment.</p>
+
+<h2 id="network_security_config">Network Security Config</h2>
+
+<p>In Android N, apps can customize the behavior of their secure (HTTPS, TLS)
+connections safely, without any code modification, by using the declarative
+<em>Network Security Config</em> instead of using the conventional
+error-prone programmatic APIs (e.g. X509TrustManager).</p>
+
+  <p>Supported features:</p>
+<ul>
+<li><b>Custom trust anchors.</b> Lets an application customize which
+Certificate Authorities (CA) are trusted for its secure connections. For
+example, trusting particular self-signed certificates or a restricted set of public CAs.
+</li>
+<li><b>Debug-only overrides.</b> Lets an application developer safely debug
+secure connections of their application without added risk to the installed
+base.
+</li>
+<li><b>Cleartext traffic opt-out.</b> Lets an application protect itself from
+accidental usage of cleartext traffic.</li>
+<li><b>Certificate pinning.</b> An advanced feature that lets an application
+  limit which server keys are trusted for secure connections.</li>
 </ul>
 
-<p>The framework API for OpenGL ES 3.2 on Android N is provided with the
-<code>GLES32</code> class. When using OpenGL ES 3.2, be sure to declare the
-requirement in your manifest file, using the <code>&lt;uses-feature&gt;</code> tag and
-the <code>android:glEsVersion</code> attribute. </p>
+<p>For more information, see <a
+href="{@docRoot}preview/features/security-config.html">Network Security
+Config</a>.</p>
 
-<p>For information about using OpenGL ES, including how to check a device's
-supported OpenGL ES version at runtime, see the <a
-href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL ES API guide</a>.</p>
+<h2 id="default_trusted_ca">Default Trusted Certificate Authority</h2>
+
+<p>By default, apps that target Android N only trust system-provided certificates
+and no longer trust user-added Certificate Authorities (CA). Apps targeting Android
+N that wish to trust user-added CAs should use the
+<a href="{@docRoot}preview/features/security-config.html">Network Security Config</a> to
+specify how user CAs should be trusted.</p>
+
+<h2 id="apk_signature_v2">APK signature scheme v2</h2>
+
+<p>The PackageManager class now supports verifying apps using the APK
+signature scheme v2. The APK signature scheme v2 is a whole-file signature scheme
+that significantly improves verification speed and strengthens integrity
+  guarantees by detecting any unauthorized changes to APK files.</p>
+
+<p>To maintain backward-compatibility, an APK must be signed with the v1 signature
+scheme (JAR signature scheme) before being signed with the v2 signature scheme.
+With the v2 signature scheme, verification fails if you sign the APK with an
+  additional certificate after signing with the v2 scheme. </p>
+
+<p>APK signature scheme v2 support will be available later in the N Developer
+Preview.</p>
+
+<h2 id="scoped_directory_access">Scoped directory access</h2>
+
+<p>In Android N, apps can use new APIs to request access to specific <a
+href="{@docRoot}guide/topics/data/data-storage.html#filesExternal">external
+storage</a> directories, including directories on removable media such as SD
+cards. The new APIs greatly simplify how your application accesses standard
+external storage directories, such as the <code>Pictures</code> directory. Apps
+like photo apps can use these APIs instead of using
+<code>READ_EXTERNAL_STORAGE</code>, which grants access to all storage
+directories, or the Storage Access Framework, which makes the user navigate to
+the directory.</p>
+
+<p>Additionally, the new APIs simplify the steps a user takes to grant external
+storage access to your app. When you use the new APIs, the system uses a simple
+permissions UI that clearly details what directory the application is
+requesting access to.</p>
+
+<p>For more information, see the
+<a href="{@docRoot}preview/features/scoped-folder-access.html">Scoped
+Directory Access</a> developer documentation.</p>
+
+
+
+
 
 
diff --git a/docs/html/preview/behavior-changes.jd b/docs/html/preview/behavior-changes.jd
index 804480b..0d93b53 100644
--- a/docs/html/preview/behavior-changes.jd
+++ b/docs/html/preview/behavior-changes.jd
@@ -25,7 +25,6 @@
       <li><a href="#vision-settings">Vision Settings in Setup Wizard</a></li>
     </ol>
   </li>
-  <li><a href="#open-jdk">Platform Migration toward OpenJDK 8</a></li>
   <li><a href="#ndk">NDK Apps Linking to Platform Libraries</a></li>
   <li><a href="#afw">Android for Work</a></li>
 </ol>
@@ -165,10 +164,8 @@
 </ul>
 
 <p>
-  Future releases of Android may deprecate additional implicit broadcasts, as
-  well as unbound background services. For this reason, you should avoid or
-  remove dependencies on manifest-declared receivers for implicit broadcasts,
-  as well as on background services.
+  In general, apps should remove dependence on manifest-declared receivers
+  for implicit broadcasts as well as on background services.
 </p>
 
 <p>
@@ -205,24 +202,6 @@
     </p>
   </li>
 
-  <li>{@code ACTION_OPEN_EXTERNAL_DIRECTORY} (New)
-    <p>
-      This permission is for a new storage option. Apps can now use the intent
-      {@code ACTION_OPEN_EXTERNAL_DIRECTORY} to request that the system create a
-      directory for the app's use. The system prompts the user to grant
-      approval. If the user approves, the app can read and write files and
-      directories in that one directory (and its descendants). The app does not
-      need {@link android.Manifest.permission_group#STORAGE STORAGE}
-      permissions to access this external directory
-    </p>
-
-    <p>
-      For more information about this intent, see the updated
-      {@code Intent} reference documentation in the
-      <a href="{@docRoot}preview/setup-sdk.html#docs-dl">N Preview SDK
-      Reference</a>.
-    </p>
-  </li>
 </ul>
 
 
@@ -333,55 +312,6 @@
   Accessibility</strong>.
 </p>
 
-
-<h2 id="open-jdk">Platform Migration toward OpenJDK 8</h2>
-
-<p>
-  Android N moves Android’s Java language libraries to an OpenJDK-based
-  approach, creating a common code base for developers to build apps and
-  services. If your app depends on a private implementation of Java or
-  unspecified behavior, you should be aware of these known issues:
-</p>
-
-<ul>
-  <li>The {@code ArrayList} private field array is removed.
-    <p>
-      If your app, or a library it used, was dependent on a private field of
-      the <code>ArrayList</code> class, you may encounter an exception such as:
-    </p>
-
-<pre class="no-pretty-print">
-java.lang.NoSuchFieldException: No field array in class Ljava/util/ArrayList;
-</pre>
-  </li>
-
-  <li>Calling a {@code Comparator} implementation with equal elements is
-  possible.
-    <p>
-      You can now call implementations of Comparator to compare an element to
-      itself. However, doing so may cause problems if the Comparator expects to
-      be called only with unique arguments.
-    </p>
-  </li>
-
-  <li>Crypto security provider has been removed.
-    <p>
-      You should only call to the Java Cryptography Extension (JCE) APIs with a
-      provider listed if the provider is included in the code of the APK.
-      Otherwise, your app needs to be able to handle the provider’s absence.
-    </p>
-
-    <p>
-      The reason apps use this provider is to take advantage of its
-      <code>SecureRandom</code> implementation. If your app was relying on <code>setSeed()</code> to
-      derive keys from strings, you must either switch to using <code>SecretKeySpec</code>
-      to load raw key bytes directly, or use a real key derivation function
-      (KDF).
-    </p>
-  </li>
-</ul>
-
-
 <h2 id="ndk">NDK Apps Linking to Platform Libraries</h2>
 
 <p>
diff --git a/docs/html/preview/download-ota.jd b/docs/html/preview/download-ota.jd
new file mode 100644
index 0000000..9c20420
--- /dev/null
+++ b/docs/html/preview/download-ota.jd
@@ -0,0 +1,323 @@
+page.title=Applying a Device OTA Image
+
+@jd:body
+
+<div style="position:relative; min-height:600px">
+
+  <div class="wrap" id="tos" style="position:absolute;display:none;width:inherit;">
+
+    <p class="sdk-terms-intro">Before downloading and installing components of
+      the Android Preview SDK, you must agree to the following terms and
+      conditions.</p>
+
+    <h2 class="norule">Terms and Conditions</h2>
+
+    <div class="sdk-terms" onfocus="this.blur()" style="width:678px">
+This is the Android SDK Preview License Agreement (the “License Agreement”).
+
+1. Introduction
+
+1.1 The Android SDK Preview (referred to in the License Agreement as the “Preview” and specifically including the Android system files, packaged APIs, and Preview library files, if and when they are made available) is licensed to you subject to the terms of the License Agreement. The License Agreement forms a legally binding contract between you and Google in relation to your use of the Preview.
+
+1.2 "Android" means the Android software stack for devices, as made available under the Android Open Source Project, which is located at the following URL: http://source.android.com/, as updated from time to time.
+
+1.3 “Android-compatible” means any Android implemation that (i) complies with the Android Compatibility Definition document, which can be found at the Android compatibility website (http://source.android.com/compatibility) and which may be updated from time to time; and (ii) successfully passes the Android Compatibility Test Suite (CTS).
+
+1.4 "Google" means Google Inc., a Delaware corporation with principal place of business at 1600 Amphitheatre Parkway, Mountain View, CA 94043, United States.
+
+2. Accepting the License Agreement
+
+2.1 In order to use the Preview, you must first agree to the License Agreement. You may not use the Preview if you do not accept the License Agreement.
+
+2.2 By clicking to accept and/or using the Preview, you hereby agree to the terms of the License Agreement.
+
+2.3 You may not use the Preview and may not accept the License Agreement if you are a person barred from receiving the Preview under the laws of the United States or other countries including the country in which you are resident or from which you use the Preview.
+
+2.4 If you will use the Preview internally within your company or organization you agree to be bound by the License Agreement on behalf of your employer or other entity, and you represent and warrant that you have full legal authority to bind your employer or such entity to the License Agreement. If you do not have the requisite authority, you may not accept the License Agreement or use the Preview on behalf of your employer or other entity.
+
+3. Preview License from Google
+
+3.1 Subject to the terms of this License Agreement, Google grants you a limited, worldwide, royalty-free, non-assignable, non-exclusive, and non-sublicensable license to use the Preview solely to develop applications for compatible implementations of Android.
+
+3.2 You may not use this Preview to develop applications for other platforms (including non-compatible implementations of Android) or to develop another SDK. You are of course free to develop applications for other platforms, including non-compatible implementations of Android, provided that this Preview is not used for that purpose.
+
+3.3 You agree that Google or third parties owns all legal right, title and interest in and to the Preview, including any Intellectual Property Rights that subsist in the Preview. "Intellectual Property Rights" means any and all rights under patent law, copyright law, trade secret law, trademark law, and any and all other proprietary rights. Google reserves all rights not expressly granted to you.
+
+3.4 You may not use the Preview for any purpose not expressly permitted by the License Agreement. Except to the extent required by applicable third party licenses, you may not: (a) copy (except for backup purposes), modify, adapt, redistribute, decompile, reverse engineer, disassemble, or create derivative works of the Preview or any part of the Preview; or (b) load any part of the Preview onto a mobile handset or any other hardware device except a personal computer, combine any part of the Preview with other software, or distribute any software or device incorporating a part of the Preview.
+
+3.5 Use, reproduction and distribution of components of the Preview licensed under an open source software license are governed solely by the terms of that open source software license and not the License Agreement. You agree to remain a licensee in good standing in regard to such open source software licenses under all the rights granted and to refrain from any actions that may terminate, suspend, or breach such rights.
+
+3.6 You agree that the form and nature of the Preview that Google provides may change without prior notice to you and that future versions of the Preview may be incompatible with applications developed on previous versions of the Preview. You agree that Google may stop (permanently or temporarily) providing the Preview (or any features within the Preview) to you or to users generally at Google's sole discretion, without prior notice to you.
+
+3.7 Nothing in the License Agreement gives you a right to use any of Google's trade names, trademarks, service marks, logos, domain names, or other distinctive brand features.
+
+3.8 You agree that you will not remove, obscure, or alter any proprietary rights notices (including copyright and trademark notices) that may be affixed to or contained within the Preview.
+
+4. Use of the Preview by You
+
+4.1 Google agrees that nothing in the License Agreement gives Google any right, title or interest from you (or your licensors) under the License Agreement in or to any software applications that you develop using the Preview, including any intellectual property rights that subsist in those applications.
+
+4.2 You agree to use the Preview and write applications only for purposes that are permitted by (a) the License Agreement, and (b) any applicable law, regulation or generally accepted practices or guidelines in the relevant jurisdictions (including any laws regarding the export of data or software to and from the United States or other relevant countries).
+
+4.3 You agree that if you use the Preview to develop applications, you will protect the privacy and legal rights of users. If users provide you with user names, passwords, or other login information or personal information, you must make the users aware that the information will be available to your application, and you must provide legally adequate privacy notice and protection for those users. If your application stores personal or sensitive information provided by users, it must do so securely. If users provide you with Google Account information, your application may only use that information to access the user's Google Account when, and for the limited purposes for which, each user has given you permission to do so.
+
+4.4 You agree that you will not engage in any activity with the Preview, including the development or distribution of an application, that interferes with, disrupts, damages, or accesses in an unauthorized manner the servers, networks, or other properties or services of Google or any third party.
+
+4.5 You agree that you are solely responsible for (and that Google has no responsibility to you or to any third party for) any data, content, or resources that you create, transmit or display through Android and/or applications for Android, and for the consequences of your actions (including any loss or damage which Google may suffer) by doing so.
+
+4.6 You agree that you are solely responsible for (and that Google has no responsibility to you or to any third party for) any breach of your obligations under the License Agreement, any applicable third party contract or Terms of Service, or any applicable law or regulation, and for the consequences (including any loss or damage which Google or any third party may suffer) of any such breach.
+
+4.7 The Preview is in development, and your testing and feedback are an important part of the development process. By using the Preview, you acknowledge that implementation of some features are still under development and that you should not rely on the Preview having the full functionality of a stable release. You agree not to publicly distribute or ship any application using this Preview as this Preview will no longer be supported after the official Android SDK is released.
+
+5. Your Developer Credentials
+
+5.1 You agree that you are responsible for maintaining the confidentiality of any developer credentials that may be issued to you by Google or which you may choose yourself and that you will be solely responsible for all applications that are developed under your developer credentials.
+
+6. Privacy and Information
+
+6.1 In order to continually innovate and improve the Preview, Google may collect certain usage statistics from the software including but not limited to a unique identifier, associated IP address, version number of the software, and information on which tools and/or services in the Preview are being used and how they are being used. Before any of this information is collected, the Preview will notify you and seek your consent. If you withhold consent, the information will not be collected.
+
+6.2 The data collected is examined in the aggregate to improve the Preview and is maintained in accordance with Google's Privacy Policy located at http://www.google.com/policies/privacy/.
+
+7. Third Party Applications
+
+7.1 If you use the Preview to run applications developed by a third party or that access data, content or resources provided by a third party, you agree that Google is not responsible for those applications, data, content, or resources. You understand that all data, content or resources which you may access through such third party applications are the sole responsibility of the person from which they originated and that Google is not liable for any loss or damage that you may experience as a result of the use or access of any of those third party applications, data, content, or resources.
+
+7.2 You should be aware the data, content, and resources presented to you through such a third party application may be protected by intellectual property rights which are owned by the providers (or by other persons or companies on their behalf). You may not modify, rent, lease, loan, sell, distribute or create derivative works based on these data, content, or resources (either in whole or in part) unless you have been specifically given permission to do so by the relevant owners.
+
+7.3 You acknowledge that your use of such third party applications, data, content, or resources may be subject to separate terms between you and the relevant third party.
+
+8. Using Google APIs
+
+8.1 Google APIs
+
+8.1.1 If you use any API to retrieve data from Google, you acknowledge that the data may be protected by intellectual property rights which are owned by Google or those parties that provide the data (or by other persons or companies on their behalf). Your use of any such API may be subject to additional Terms of Service. You may not modify, rent, lease, loan, sell, distribute or create derivative works based on this data (either in whole or in part) unless allowed by the relevant Terms of Service.
+
+8.1.2 If you use any API to retrieve a user's data from Google, you acknowledge and agree that you shall retrieve data only with the user's explicit consent and only when, and for the limited purposes for which, the user has given you permission to do so.
+
+9. Terminating the License Agreement
+
+9.1 the License Agreement will continue to apply until terminated by either you or Google as set out below.
+
+9.2 If you want to terminate the License Agreement, you may do so by ceasing your use of the Preview and any relevant developer credentials.
+
+9.3 Google may at any time, terminate the License Agreement, with or without cause, upon notice to you.
+
+9.4 The License Agreement will automatically terminate without notice or other action upon the earlier of:
+(A) when Google ceases to provide the Preview or certain parts of the Preview to users in the country in which you are resident or from which you use the service; and
+(B) Google issues a final release version of the Android SDK.
+
+9.5 When the License Agreement is terminated, the license granted to you in the License Agreement will terminate, you will immediately cease all use of the Preview, and the provisions of paragraphs 10, 11, 12 and 14 shall survive indefinitely.
+
+10. DISCLAIMERS
+
+10.1 YOU EXPRESSLY UNDERSTAND AND AGREE THAT YOUR USE OF THE PREVIEW IS AT YOUR SOLE RISK AND THAT THE PREVIEW IS PROVIDED "AS IS" AND "AS AVAILABLE" WITHOUT WARRANTY OF ANY KIND FROM GOOGLE.
+
+10.2 YOUR USE OF THE PREVIEW AND ANY MATERIAL DOWNLOADED OR OTHERWISE OBTAINED THROUGH THE USE OF THE PREVIEW IS AT YOUR OWN DISCRETION AND RISK AND YOU ARE SOLELY RESPONSIBLE FOR ANY DAMAGE TO YOUR COMPUTER SYSTEM OR OTHER DEVICE OR LOSS OF DATA THAT RESULTS FROM SUCH USE. WITHOUT LIMITING THE FOREGOING, YOU UNDERSTAND THAT THE PREVIEW IS NOT A STABLE RELEASE AND MAY CONTAIN ERRORS, DEFECTS AND SECURITY VULNERABILITIES THAT CAN RESULT IN SIGNIFICANT DAMAGE, INCLUDING THE COMPLETE, IRRECOVERABLE LOSS OF USE OF YOUR COMPUTER SYSTEM OR OTHER DEVICE.
+
+10.3 GOOGLE FURTHER EXPRESSLY DISCLAIMS ALL WARRANTIES AND CONDITIONS OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+
+11. LIMITATION OF LIABILITY
+
+11.1 YOU EXPRESSLY UNDERSTAND AND AGREE THAT GOOGLE, ITS SUBSIDIARIES AND AFFILIATES, AND ITS LICENSORS SHALL NOT BE LIABLE TO YOU UNDER ANY THEORY OF LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL OR EXEMPLARY DAMAGES THAT MAY BE INCURRED BY YOU, INCLUDING ANY LOSS OF DATA, WHETHER OR NOT GOOGLE OR ITS REPRESENTATIVES HAVE BEEN ADVISED OF OR SHOULD HAVE BEEN AWARE OF THE POSSIBILITY OF ANY SUCH LOSSES ARISING.
+
+12. Indemnification
+
+12.1 To the maximum extent permitted by law, you agree to defend, indemnify and hold harmless Google, its affiliates and their respective directors, officers, employees and agents from and against any and all claims, actions, suits or proceedings, as well as any and all losses, liabilities, damages, costs and expenses (including reasonable attorneys’ fees) arising out of or accruing from (a) your use of the Preview, (b) any application you develop on the Preview that infringes any Intellectual Property Rights of any person or defames any person or violates their rights of publicity or privacy, and (c) any non-compliance by you of the License Agreement.
+
+13. Changes to the License Agreement
+
+13.1 Google may make changes to the License Agreement as it distributes new versions of the Preview. When these changes are made, Google will make a new version of the License Agreement available on the website where the Preview is made available.
+
+14. General Legal Terms
+
+14.1 the License Agreement constitutes the whole legal agreement between you and Google and governs your use of the Preview (excluding any services which Google may provide to you under a separate written agreement), and completely replaces any prior agreements between you and Google in relation to the Preview.
+
+14.2 You agree that if Google does not exercise or enforce any legal right or remedy which is contained in the License Agreement (or which Google has the benefit of under any applicable law), this will not be taken to be a formal waiver of Google's rights and that those rights or remedies will still be available to Google.
+
+14.3 If any court of law, having the jurisdiction to decide on this matter, rules that any provision of the License Agreement is invalid, then that provision will be removed from the License Agreement without affecting the rest of the License Agreement. The remaining provisions of the License Agreement will continue to be valid and enforceable.
+
+14.4 You acknowledge and agree that each member of the group of companies of which Google is the parent shall be third party beneficiaries to the License Agreement and that such other companies shall be entitled to directly enforce, and rely upon, any provision of the License Agreement that confers a benefit on (or rights in favor of) them. Other than this, no other person or company shall be third party beneficiaries to the License Agreement.
+
+14.5 EXPORT RESTRICTIONS. THE PREVIEW IS SUBJECT TO UNITED STATES EXPORT LAWS AND REGULATIONS. YOU MUST COMPLY WITH ALL DOMESTIC AND INTERNATIONAL EXPORT LAWS AND REGULATIONS THAT APPLY TO THE PREVIEW. THESE LAWS INCLUDE RESTRICTIONS ON DESTINATIONS, END USERS AND END USE.
+
+14.6 The License Agreement may not be assigned or transferred by you without the prior written approval of Google, and any attempted assignment without such approval will be void. You shall not delegate your responsibilities or obligations under the License Agreement without the prior written approval of Google.
+
+14.7 The License Agreement, and your relationship with Google under the License Agreement, shall be governed by the laws of the State of California without regard to its conflict of laws provisions. You and Google agree to submit to the exclusive jurisdiction of the courts located within the county of Santa Clara, California to resolve any legal matter arising from the License Agreement. Notwithstanding this, you agree that Google shall still be allowed to apply for injunctive remedies (or an equivalent type of urgent legal relief) in any jurisdiction.
+  </div><!-- sdk terms -->
+
+
+
+    <div id="sdk-terms-form">
+      <p>
+        <input id="agree" type="checkbox" name="agree" value="1" onclick="onAgreeChecked()" />
+        <label id="agreeLabel" for="agree">I have read and agree with the above terms and conditions</label>
+      </p>
+      <p><a href="" class="button disabled" id="downloadForRealz" onclick="return onDownloadForRealz(this);"></a></p>
+    </div>
+
+
+  </div><!-- end TOS -->
+
+
+  <div id="landing">
+
+<p>
+  This page provides links to over-the-air (OTA) device images and describes
+  how to manually apply an OTA update to a device. This procedure may be useful
+  in recovering devices that received OTA updates through the Android Beta
+  Program and do not start up after the update is installed.
+</p>
+
+<h2 id="install-ota">Installing OTA Images</h2>
+
+<p></p>
+
+<p>To install an OTA package to a device:</p>
+
+<ol>
+  <li>Download an OTA device image from the table below.</li>
+  <li>Reboot the device into Recovery mode. For more information on putting
+    Nexus devices in this mode, see
+    <a href="https://support.google.com/nexus/answer/4596836">Reset your Nexus
+      device to factory settings</a>.
+  </li>
+  <li>On the device, select <strong>ADB sideload</strong>.</li>
+  <li>Connect the device to a computer with the Android development environment
+    loaded and the Android Debug Bridge (adb) tool installed.</li>
+  <li>Run the following command:
+    <pre>adb sideload <em>&lt;ota-package&gt;</em></pre>
+  </li>
+</ol>
+
+
+
+<h2 id="ota-images">Device OTA Images</h2>
+
+<table>
+  <tr>
+    <th scope="col">Device</th>
+    <th scope="col">Download / Checksums</th>
+  </tr>
+
+  <tr id="bullhead">
+    <td>Nexus 5X <br>"bullhead"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >bullhead-ota-2659757-4fab1a6f.zip</a><br>
+      MD5: 2a3263bb4935cdc7a326298f2cf13535<br>
+      SHA-1: 4fab1a6f1a68d94c02500d7acb15503192455f20
+    </td>
+  </tr>
+
+  <tr id="shamu">
+    <td>Nexus 6 <br>"shamu"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >shamu-ota-2659757-073c33ae.zip</a><br>
+      MD5: c201a9ccdfa5afdd2f1a9967e462098f<br>
+      SHA-1: 073c33aef3ecc5961e0ba92c5611b98f7750fa94
+    </td>
+  </tr>
+
+  <tr id="angler">
+    <td>Nexus 6P <br>"angler"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >angler-ota-2659757-938ecff3.zip</a><br>
+      MD5: 3363c343fafe03b118776738a37623a8<br>
+      SHA-1: 938ecff398f896c21c03615942727493aeae3556
+    </td>
+  </tr>
+
+  <tr id="volantis">
+    <td>Nexus 9 <br>"volantis"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >volantis-ota-2659757-257cba86.zip</a><br>
+      MD5: d90a271b6c6edc49702df292abc66fed<br>
+      SHA-1: 257cba864cec7f486e0deba9e23e00b840f9a821
+    </td>
+  </tr>
+
+  <tr id="volantisg">
+    <td>Nexus 9G <br>"volantisg"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >volantisg-ota-2659757-edd866f6.zip</a><br>
+      MD5: d2bc6f760a1725a36366bb8c3230dfc7<br>
+      SHA-1: edd866f643d87d56654326ba5dc4d802e0d5c2e6
+    </td>
+  </tr>
+
+  <tr id="fugu">
+    <td>Nexus Player <br>"fugu"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >fugu-ota-2665432-f0f8fea4.zip</a><br>
+      MD5: 4403af764b57502d89111fd68ecb7da5<br>
+      SHA-1: f0f8fea49ea3874b751cf67462ecc5d8e039875e
+    </td>
+  </tr>
+
+  <tr id="ryu">
+    <td>Pixel C <br>"ryu"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >ryu-ota-2659757-1e496acd.zip</a><br>
+      MD5: 1ebd7fddb52cba59b7f686a972e023db<br>
+      SHA-1: 1e496acd67b8fdbee7b5c6ef721746f8e98e704f
+    </td>
+  </tr>
+
+</table>
+
+
+  </div><!-- landing -->
+
+</div><!-- relative wrapper -->
+
+
+
+<script>
+  var urlRoot = "http://storage.googleapis.com/androiddevelopers/shareables/preview/ota/";
+  function onDownload(link) {
+
+    $("#downloadForRealz").html("Download " + $(link).text());
+    $("#downloadForRealz").attr('href', urlRoot + $(link).text());
+
+    $("#tos").fadeIn('fast');
+    $("#landing").fadeOut('fast');
+
+    return true;
+  }
+
+
+  function onAgreeChecked() {
+    /* verify that the TOS is agreed */
+    if ($("input#agree").is(":checked")) {
+      /* reveal the download button */
+      $("a#downloadForRealz").removeClass('disabled');
+    } else {
+      $("a#downloadForRealz").addClass('disabled');
+    }
+  }
+
+  function onDownloadForRealz(link) {
+    if ($("input#agree").is(':checked')) {
+    /*
+      $("#tos").fadeOut('fast');
+      $("#landing").fadeIn('fast');
+    */
+
+      ga('send', 'event', 'M Preview', 'System Image', $("#downloadForRealz").html());
+
+    /*
+      location.hash = "";
+    */
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  $(window).hashchange( function(){
+    if (location.hash == "") {
+      location.reload();
+    }
+  });
+
+</script>
diff --git a/docs/html/preview/download.jd b/docs/html/preview/download.jd
index 72228a2..ac37704 100644
--- a/docs/html/preview/download.jd
+++ b/docs/html/preview/download.jd
@@ -1,7 +1,6 @@
-page.title=Test on an Android N Device
-page.image=images/cards/card-download_16-9_2x.png
-meta.tags="preview", "system image"
-page.tags="preview", "developer preview"
+page.title=Test on a Device
+meta.tags="preview", "nexus","system image"
+page.tags="preview", "androidn"
 page.image=images/cards/card-n-downloads_2x.png
 
 @jd:body
@@ -170,94 +169,128 @@
   <div id="qv">
     <h2>In this document</h2>
       <ol>
-        <li><a href="#device-preview">Install on a Device</a>
+        <li><a href="#device-preview">Set up a hardware device</a>
           <ol>
             <li><a href="#ota">Get over-the-air updates</a></li>
-            <li><a href="#flash">Download the system image</a></li>
-            <li><a href="#revertDevice">Revert to factory specifications</a></li>
+            <li><a href="#flash">Manually flash a device</a></li>
+            <li><a href="#revertDevice">Uninstalling</a></li>
           </ol>
         </li>
-        <li><a href="#setupAVD">Use the Emulator</a></li>
+        <li><a href="#setupAVD">Set up an emulator</a></li>
       </ol>
   </div>
 </div>
 
-
-
-
-
-
-
-<p>To run the Android N Preview and test your apps, you can either
-install the Android N Preview on one of several supported devices or run it on
-the Android Emulator.</p>
-
-<p>Simply installing your app onto Android N this way does not require
-any changes to your app source code. If, however, you want to update your
-app to use new Android N APIs, see
-<a href="{@docRoot}preview/setup-sdk.html">Set Up to Develop for Android N</a>.
-
-
-
-<h2 id="device-preview">Install on a Device</h2>
-
-<p>You can get the Android N Preview on a device by opting into
-  the Android Beta Program to receive over-the-air updates to your device
-  or by downloading an Android N Preview system
-  image and installing it on a device.
+<p>
+  To run and test your app on the new platform you need to set up an Android N
+  runtime environment. You can do that in either of these ways:
 </p>
 
-<p class="warning">
-  <strong>Warning:</strong> The Android system images are previews
-  and are subject to change. Your use of the system images is governed by the
-  Android SDK Preview License Agreement. The Android preview system images are
-  not stable releases, and may contain errors and defects that can result in
-  damage to your computer systems, devices, and data. The preview Android
-  system images are not subject to the same testing as the factory OS and can
-  cause your phone and installed services and applications to stop working.
+<ul>
+  <li>Install Android N on a supported hardware device, or</li>
+  <li>Set up an Android emulator running Android N</li>
+</ul>
+
+<p>
+  If you want an environment for basic compatibility testing of your app on the
+  new platform, all you need is your current APK and a hardware device or
+  emulator. You don't necessarily need to update your full development
+  environment to do basic testing.
+</p>
+
+<p>
+  If you want to modify your app to target Android N or use new Android N APIs,
+  you need to set up a development environment that's updated to support
+  Android N. <a href="{@docRoot}preview/setup-sdk.html">Set Up to Develop for
+  Android N</a> has details.
 </p>
 
 
-<h3 id="ota">Get over-the-air updates</h3>
+<h2 id="device-preview">Set up a hardware device</h2>
 
-<p>You can receive over-the-air updates to preview versions of Android by
-enrolling your compatible device in the Android Beta Program.
-These updates are automatically downloaded and will update your device just like
-official system updates.</p>
+<p>
+  The N Developer Preview offers system updates for a range of hardware devices
+  that you can use for testing your app, from phones to tablets and TV.
+</p>
+
+<p>
+  If you have access to a supported device, you can update it to a Developer
+  Preview milestone build in one of these ways:
+</p>
+
+<ul>
+  <li><strong>Enroll the device in automatic OTA system updates</strong> through the
+  <a href="https://g.co/androidbeta">Android Beta Program</a>. Once enrolled, your device will receive regular
+  over-the-air (OTA) updates of all milestone builds in the N Developer Preview. This
+  approach is recommended because it lets you seamlessly transition from your current
+  environment through the various releases of the N Developer Preview.</li>
+  <li><strong>Download a Developer Preview system image and flash the device</strong>.
+  OTA updates are not provided automatically for devices that you flash manually, but
+  you can enroll those devices in Android Beta Program to get OTA updates. </li>
+</ul>
+
+<h3 id="ota">Enroll the device in automatic OTA updates</h3>
+
+<p>
+  If you have access to a supported device (see the list in the Downloads
+  table), you can receive over-the-air updates to preview versions of Android
+  by enrolling that device in the <a href="https://g.co/androidbeta">Android Beta Program</a>. These updates are
+  automatically downloaded and will update your device just like official
+  system updates.
+</p>
+
+<p>
+  You can un-enroll a device at any time. The device will receive an OTA update
+  to the most recent production version of Android available for that device
+  (for example, Android 6.0 Marshmallow). The update requires a full device
+  reset, so user data on the device will be removed. Make sure to <strong>back
+  up important data</strong> before un-enrolling a device.
+</p>
 
 <p>
   For more information and to enroll your device, see
   the <a href="https://g.co/androidbeta">Android Beta Program</a> web site.
 </p>
 
-<p class="warning">
-  <strong>Warning:</strong> If you enroll a device in the Android Beta Program,
-  then later opt-out of receiving updates on
-  the device, all user data on that device will be removed.
+<p class="note"><strong>Note:</strong>
+  Un-enrolling requires a full device reset. Back up
+  important data first.
 </p>
 
+<h3 id="flash">Flashing a device manually</h3>
 
-<h3 id="flash">Download the system image</h3>
+<p>
+  At any time you can download the latest Developer Preview system image and
+  manually flash it to your device. See the table below to download the system
+  image for your test device. Manually flashing a device is useful if you need
+  precise control over the test environment or need to reinstall frequently,
+  such as for automated testing. 
+</p>
 
-<p>To instead manually flash the system image to your device and control
-the updates yourself, you can download the appropriate system image for your
-device from the table below.</p>
+<!-- You can flash by ota or system image --><p>
+  Installing a system image on a device <strong>removes all data from the
+  device</strong>, so you should back up your data first.
+</p>
 
-<p>Installing a system image on a device <em>removes all data
-from the device</em>, so you should back up your data before installing a
-system image.</p>
+<p>
+  After you back up your device data and download the system image below that
+  matches your device, follow the instructions at <a href=
+  "https://developers.google.com/android/nexus/images#instructions">developers.google.com/android</a>
+  to flash the image onto your device.
+</p>
 
-<p>After you back up your device data and download the system image below that
-matches your device, follow the instructions at <a href=
-"https://developers.google.com/android/nexus/images#instructions"
->developers.google.com/android/nexus</a>
-to flash the image onto your device.</p>
+<p>
+  Manually flashed system images <strong>do not
+  automatically receive OTA updates</strong> to later Developer Preview
+  milestone builds. Make sure to keep your environment up-to-date and flash a
+  new system image at each Developer Preview milestone.
+</p>
 
-<p class="note">
-<strong>Note:</strong> If you manually install a preview system image on a
-device, that device <em>will not</em> receive additional over-the-air updates
-(either production or preview). If you want to update a device with a new
-preview system image, you must perform another manual installation.
+<p>
+  If you decide you want to get OTA updates after manually flashing a device, 
+  all you need to do is enroll the device in the <a href="https://g.co/androidbeta">Android
+  Beta Program</a>. You can enroll the device at any time to receive the next Preview
+  update over the air. 
 </p>
 
 <table>
@@ -328,30 +361,56 @@
       SHA-1: 335a86a435ee51f18464de343ad2e071c38f0e92
     </td>
   </tr>
+  <tr id="seed">
+    <td>General Mobile 4G (Android One) <br>"seed"</td>
+    <td><a href="#top" onclick="onDownload(this)"
+      >seed_l8150-npc56p-preview-82472ebc.tgz</a><br>
+      MD5: 983e083bc7cd0c4a2d39d6ebaa20202a<br>
+      SHA-1: 82472ebc9a6054a103f53cb400a1351913c95127
+    </td>
+  </tr>
 
 </table>
 
-
-<h3 id="revertDevice">Revert to factory specifications</h3>
+<h3 id="revertDevice">Uninstalling the Preview from a device</h3>
 
 <p>
-  If you want to uninstall the preview and revert the device to factory
-  specifications, go to
-  <a href="http://developers.google.com/android/nexus/images"
-  >developers.google.com/android/nexus</a>
-  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.
-</p>
+  If you want to uninstall the preview from a device, you can do so in one of
+  these ways: </p>
+  <ul>
+    <li><strong>Obtain a factory spec system image</strong> and then manually
+    flash it to the device.
+      <ul>
+          <li>For <strong>Nexus devices and Pixel C devices</strong>, see
+        the <a href="http://developers.google.com/android/nexus/images">Factory Images
+        for Nexus Devices</a> page for downloads. </li>
+        <li>For <strong>other devices</strong>, please contact the device manufacturer
+        directly. Alternatively, if the device is supported
+        in the Android Beta Program, you can enroll the device in the
+        program and then un-enroll it (see below).</li>
+      </ul>
+    </li>
+    <li><strong>Un-enroll the device from Android Beta Program</strong>. If the
+    device is enrolled in the <a href="https://g.co/androidbeta">Android Beta
+    Program</a>, regardless of device, you can simply un-enroll it from the program.
+  <p>
+    The device will receive an OTA update to the most recent production version
+    of Android available for that device (for example, Android 6.0 Marshmallow).
+    The update requires a full device reset, so user data on the device will be
+    removed. Make sure to <strong>back up important data</strong> before
+    un-enrolling a device.
+  </p>
+  </li>
+</ul>
 
-<p class="warning">
-  <strong>Warning:</strong> Just like when flashing a preview image,
-  installing a factory image removes all user data on the device.
+<p class="note"><strong>Note:</strong>
+  Uninstalling a Developer Preview system image prior to
+  the end of the program requires a full device reset and removes all user data
+  on the device.
 </p>
 
 
-
-
-<h2 id="setupAVD">Use the Emulator</h2>
+<h2 id="setupAVD">Set up an emulator</h2>
 
 <p>To use the Android Emulator to run the Android N Preview, you need to
 download the Android N Preview SDK and create a virtual device for the
@@ -414,9 +473,10 @@
 Android Studio 1.5.</p>
 
 <p class="note"><strong>Note:</strong>
-If you're currently using Android Studio 2.0 Beta, there's a known issue
-that prevents you from creating AVDs with the N Preview system images, so
-you currently need to use the Android Studio 2.1 preview to create AVDs.</p>
+  If you're currently using Android Studio 2.0 Beta, there's a known issue
+  that prevents you from creating AVDs with the N Preview system images, so
+  you currently need to use the Android Studio 2.1 preview to create AVDs.
+</p>
 
 <p>For more information about creating virtual devices, see <a href=
   "{@docRoot}tools/devices/index.html">Managing Virtual Devices</a>.
diff --git a/docs/html/preview/features/multi-window.jd b/docs/html/preview/features/multi-window.jd
index 8122bbf..a12ab94 100644
--- a/docs/html/preview/features/multi-window.jd
+++ b/docs/html/preview/features/multi-window.jd
@@ -146,15 +146,13 @@
 </p>
 
 <p>
-  If the user is resizes a window and makes it larger in either dimension,
-  the system fills in the expanded
-  area with the color specified by the {@link android.R.attr#windowBackground
-  windowBackground} attribute, or by the default
-  <code>windowBackgroundFallback</code> style attribute. When the user finishes
-  resizing the window, the activity is redrawn with its new dimensions, as
-  described in <a href=
-  "{@docRoot}guide/topics/resources/runtime-changes.html">Handling Runtime
-  Changes</a>.
+  If the user is resizing a window and makes it larger in either dimension, the
+  system resizes the activity to match the user action and issues <a href=
+  "{@docRoot}guide/topics/resources/runtime-changes.html">runtime changes</a>
+  as needed. If the app lags behind in drawing in newly-exposed areas, the
+  system temporarily fills those areas with the color specified by the {@link
+  android.R.attr#windowBackground windowBackground} attribute or by the default
+  <code>windowBackgroundFallback</code> style attribute.
 </p>
 
 <h2 id="configuring">Configuring Your App for Multi-Window Mode</h2>
diff --git a/docs/html/preview/features/notification-updates.jd b/docs/html/preview/features/notification-updates.jd
index f234831..d3042ad 100644
--- a/docs/html/preview/features/notification-updates.jd
+++ b/docs/html/preview/features/notification-updates.jd
@@ -183,7 +183,7 @@
 
 <p>Android N provides developers with a new way to represent
  a queue of notifications: <i>bundled notifications</i>. This is similar to the
-  <a href="{@docRoot}/training/wearables/notifications/stacks.html">Notification
+  <a href="{@docRoot}training/wearables/notifications/stacks.html">Notification
   Stacks</a> feature in Android Wear. For example, if your app creates notifications
   for received messages, when more than one message is received, bundle the
  notifications together as a single group. You can
diff --git a/docs/html/preview/images/pip-active.png b/docs/html/preview/images/pip-active.png
index dead766..a24cb03 100644
--- a/docs/html/preview/images/pip-active.png
+++ b/docs/html/preview/images/pip-active.png
Binary files differ
diff --git a/docs/html/preview/index.jd b/docs/html/preview/index.jd
index 5ad72da..bce5dec 100644
--- a/docs/html/preview/index.jd
+++ b/docs/html/preview/index.jd
@@ -25,7 +25,7 @@
         <h1 class="dac-hero-title">Android N Developer Preview</h1>
         <p class="dac-hero-description">
           Get ready for Android N!
-          <strong>Test your apps</strong> on Nexus devices. Support new system
+          <strong>Test your apps</strong> on Nexus and other devices. Support new system
           behaviors to <strong>save power and memory</strong>.
           Extend your apps with <strong>multi-window UI</strong>,
           <strong>direct reply notifications</strong> and more.
@@ -62,7 +62,7 @@
     </a>
     <ul class="dac-actions">
       <li class="dac-action">
-        <a class="dac-action-link" href="{@docRoot}preview/bug">
+        <a class="dac-action-link" href="https://developer.android.com/preview/bug">
           <i class="dac-action-sprite dac-sprite dac-auto-chevron-large"></i>
           Report an issue
         </a>
@@ -87,7 +87,7 @@
   <div class="wrap dac-offset-parent">
 
     <div class="actions">
-      <div><a href="{@docRoot}preview/bug">
+      <div><a href="https://developer.android.com/preview/bug">
         <span class="dac-sprite dac-auto-chevron-large"></span>
         Report an issue
       </a></div>
diff --git a/docs/html/preview/overview.jd b/docs/html/preview/overview.jd
index 0bc5595..c542e18 100644
--- a/docs/html/preview/overview.jd
+++ b/docs/html/preview/overview.jd
@@ -234,7 +234,7 @@
 <h3 id="hardware_system_images">Hardware system images</h3>
 
 <p>
-  The N Developer Preview includes Nexus hardware system images that you can use when
+  The N Developer Preview includes Nexus and other hardware system images that you can use when
   testing and developing on physical devices. See the <a href=
   "{@docRoot}preview/download.html">Device Images</a> page for the full list
   of hardware images.
diff --git a/docs/html/preview/setup-sdk.jd b/docs/html/preview/setup-sdk.jd
index c8688c6..bc40ebd 100644
--- a/docs/html/preview/setup-sdk.jd
+++ b/docs/html/preview/setup-sdk.jd
@@ -191,7 +191,7 @@
 <pre>
 android {
   compileSdkVersion <strong>'android-N'</strong>
-  buildToolsVersion <strong>24.0.0 rc1</strong>
+  buildToolsVersion <strong>'24.0.0-rc1'</strong>
   ...
 
   defaultConfig {
diff --git a/docs/html/preview/support.jd b/docs/html/preview/support.jd
index 35d07e7..e859c11 100644
--- a/docs/html/preview/support.jd
+++ b/docs/html/preview/support.jd
@@ -5,10 +5,13 @@
 
 @jd:body
 
-<p>Two primary support channels are available to you when developing and testing
-with the Android N Developer Preview: Please file bugs at
-<a href="{@docRoot}preview/bug">https://developer.android.com/preview/bug</a> for device-specific, system, and Google App bugs.
-For issues in other apps, please contact the developer directly.</p>
+<p>
+  Two primary support channels are available to you when developing and testing
+  with the Android N Developer Preview: Please file bugs at <a href=
+  "https://developer.android.com/preview/bug">https://developer.android.com/preview/bug</a> for
+  device-specific, system, and Google App bugs. For issues in other apps,
+  please contact the developer directly.
+</p>
 
 <p>To discuss issues or ideas with other developers working with Android N, join the
 <a href="{@docRoot}preview/dev-community">Developer Preview Google+ community</a>.</p>
@@ -29,18 +32,40 @@
   </div>
 </div>
 
-
 <h3 id="general">General advisories</h3>
 
-<p>This Developer Preview release is for app developers only and is designed for use in compatibility testing and early development only. Please be aware of these general notes about the release:</p>
-
+<p>
+  This Developer Preview release is for app developers only and is designed for
+  use in compatibility testing and early development only. Please be aware of
+  these general notes about the release:
+</p>
 <ul>
-   <li>This release has various stability and performance issues on all devices that make it <em>not suitable for daily use on phone or tablet</em>, especially for non-developers.</li>
-   <li>System and app performance is known to be <strong>periodically slow / janky</strong>, and device may become occasionally unresponsive. These problems may become more acute with prolonged use.</li>
-  <li>Battery life may be regressed in this release for screen-on and screen-off use cases.</li>
-  <li>Some apps may not function normally on Developer Preview 1. This includes Google’s apps as well as other apps.</li>
-  <li>This early build is not Compatibility Test Suite (CTS) approved. Apps that depend on CTS approved builds (Android Pay for example) won’t work. </li>
-  <li>This preview release supports the following devices: Nexus 5X, Nexus 6, Nexus 6P, Nexus 9, Nexus Player, and Pixel C.</li>
+  <li>This release has various stability and performance issues on all devices
+  that make it <em>not suitable for daily use on phone or tablet</em>,
+  especially for non-developers.
+  </li>
+
+  <li>System and app performance is known to be <strong>periodically slow /
+  janky</strong>, and device may become occasionally unresponsive. These
+  problems may become more acute with prolonged use.
+  </li>
+
+  <li>Battery life may be regressed in this release for screen-on and
+  screen-off use cases.
+  </li>
+
+  <li>Some apps may not function normally on Developer Preview 1. This includes
+  Google’s apps as well as other apps.
+  </li>
+
+  <li>This early build is not Compatibility Test Suite (CTS) approved. Apps
+  that depend on CTS approved builds (Android Pay for example) won’t work.
+  </li>
+
+  <li>This preview release supports the following devices: Nexus 5X, Nexus 6,
+  Nexus 6P, Nexus 9, Nexus Player, and Pixel C, as well as General Mobile 4G
+  (Android One).
+  </li>
 </ul>
 
 <h3 id="platform">Platform Issues</h3>
@@ -48,85 +73,165 @@
 <h4 id="performance">Performance and battery</h4>
 
 <ul>
-  <li>System and app performance is known to be <strong>periodically slow / janky</strong>, and device may become occasionally unresponsive. These problems may become more acute with prolonged use.</li>
-  <li>Battery life may be regressed in this release for screen-on and screen-off use cases.</li>
+  <li>System and app performance is known to be <strong>periodically slow /
+  janky</strong>, and device may become occasionally unresponsive. These
+  problems may become more acute with prolonged use.
+  </li>
+
+  <li>Battery life may be regressed in this release for screen-on and
+  screen-off use cases.
+  </li>
+</ul>
+<h4 id="dialer">Dialer</h4>
+
+<ul>
+  <li>Dialer app does not support Direct boot. This will be addressed later in
+  N Developer Preview.
+  </li>
+
+  <li>Voicemail playback does not work.
+  </li>
 </ul>
 
-<h4 id="dialer">Dialer</h4>
+<h4 id="microphone">Microphone</h4>
+
 <ul>
-   <li>Dialer app does not support Direct boot. This will be addressed later in N Developer Preview.</li>
-   <li>Voicemail playback does not work.</li>
+   <li>The system may incorrect persists the microphone mute state across apps and reboots. If you mute the microphone in an app and the state is persisted, open any app that has microphone mute controls and unmute the microphone.</li>
 </ul>
 
 <h4 id="ui">System UI</h4>
 
 <ul>
-   <li>Some new or modified strings in the system UI are not translated to all languages.</li>
-   <li>Overview UI is still in development, and subject to change. For example, we intend to
-   remove the timer that appears when the user switches between apps.</li>
-   <li>Settings controls and toggles may be slow or appear to be unresponsive.</li>
-   <li>Visual design of notifications is subject to change.</li>
-   <li>In the Gmail app, direct archiving of emails included in a notification bundle does not work properly.</li>
+  <li>Some new or modified strings in the system UI are not translated to all
+  languages.
+  </li>
+
+  <li>Overview UI is still in development, and subject to change. For example,
+  we intend to remove the timer that appears when the user switches between
+  apps.
+  </li>
+
+  <li>Settings controls and toggles may be slow or appear to be unresponsive.
+  </li>
+
+  <li>Visual design of notifications is subject to change.
+  </li>
+
+  <li>In the Gmail app, direct archiving of emails included in a notification
+  bundle does not work properly.
+  </li>
 </ul>
 
 <h4 id="afw">Android for Work</h4>
 
 <ul>
-   <li>Work Security Challenge
-   <ul>
-     <li>After migration to N, or after the user creates work profiles, work profiles can't create keys in the keystore until the user changes their pattern, PIN, or password, or sets up a Work Challenge.</li>
-     <li>In Direct boot mode, applying the passcode restrictions to the device causes the work profile to be unlocked, even though the device is locked. This makes the work profile accessible even though it should be protected by the device lock screen.</li>
-     <li>When the user enters a wrong password and pin, the system does not display any informational message; instead, it only clears the input field. This issue does not affect pattern or fingerprint input.</li>
-     <li>On a tablet, the background displayed with the work challenge is disproportionately small.</li>
-     <li>The version of
-     <a href="https://play.google.com/store/apps/details?id=com.google.android.apps.enterprise.dmagent">
-     Google Apps Device Policy</a> that is bundled with N Developer Preview does not yet support the Work Profile Security Challenge feature. Developers should instead use
-     <a href="https://play.google.com/store/apps/details?id=com.afwsamples.testdpc">TestDPC</a>
-     to test this feature.</li>
-   </ul>
-   </li>
-
-   <li>Always On VPN
-   <ul>
-     <li>If Always On VPN mode is turned on, but VPN is not available, apps not specified as exceptions to the Always On policy connect over the ordinary network. Unless specified as exceptions to Always On VPN policy, apps should be offline if they have no VPN connection available.
+  <li>Work Security Challenge
     <ul>
-     <li>When Always On mode is on, a VPN connection is not established after a device reboots into Direct boot mode, even after the user unlocks the secure lock screen.</li>
-    </ul>
+      <li>After migration to N, or after the user creates work profiles, work
+      profiles can't create keys in the keystore until the user changes their
+      pattern, PIN, or password, or sets up a Work Challenge.
       </li>
-  </ul>
+
+      <li>In Direct boot mode, applying the passcode restrictions to the device
+      causes the work profile to be unlocked, even though the device is locked.
+      This makes the work profile accessible even though it should be protected
+      by the device lock screen.
+      </li>
+
+      <li>When the user enters a wrong password and pin, the system does not
+      display any informational message; instead, it only clears the input
+      field. This issue does not affect pattern or fingerprint input.
+      </li>
+
+      <li>On a tablet, the background displayed with the work challenge is
+      disproportionately small.
+      </li>
+
+      <li>The version of <a href=
+      "https://play.google.com/store/apps/details?id=com.google.android.apps.enterprise.dmagent">
+        Google Apps Device Policy</a> that is bundled with N Developer Preview
+        does not yet support the Work Profile Security Challenge feature.
+        Developers should instead use <a href=
+        "https://play.google.com/store/apps/details?id=com.afwsamples.testdpc">TestDPC</a>
+        to test this feature.
+      </li>
+    </ul>
   </li>
 
-   <li>Improved Contacts
-   <ul>
-     <li>Bluetooth PBAP/MAP devices do not display Caller ID for work contacts. The next release of Preview resolves this issue.</li>
-   </ul>
-   </li>
+  <li>Always On VPN
+    <ul>
+      <li>If Always On VPN mode is turned on, but VPN is not available, apps
+      not specified as exceptions to the Always On policy connect over the
+      ordinary network. Unless specified as exceptions to Always On VPN policy,
+      apps should be offline if they have no VPN connection available.
+        <ul>
+          <li>When Always On mode is on, a VPN connection is not established
+          after a device reboots into Direct boot mode, even after the user
+          unlocks the secure lock screen.
+          </li>
+        </ul>
+      </li>
+    </ul>
+  </li>
 
+  <li>Improved Contacts
+    <ul>
+      <li>Bluetooth PBAP/MAP devices do not display Caller ID for work
+      contacts. The next release of Preview resolves this issue.
+      </li>
+    </ul>
+  </li>
 
-   <li>Work Mode
-   <ui>
-     <li>The Google Now Launcher does not display whether Work Mode is on or off. The Launcher also does not show app suspension state.</li>
-     <li>After the user turns Work Mode off and on, the system no longer shows Work profile app widgets, such as Calendar.</li>
-   </ui>
-   </li>
+  <li>Work Mode
+    <ul>
+      <li>The Google Now Launcher does not display whether Work Mode is on or
+      off. The Launcher also does not show app suspension state.
+      </li>
 
-   <li>Suspend Packages
-   <ui>
-     <li>Device admins can suspend critical system packages, which may lead to unexpected behavior, such as placing calls despite the Telephone disabled dialog’s being displayed.</li>
-   </ui>
-   </li>
+      <li>After the user turns Work Mode off and on, the system no longer shows
+      Work profile app widgets, such as Calendar.
+      </li>
+    </ul>
+  </li>
 
-   <li>Other
-   <ul>
-      <li>The Settings app crashes on launch if
-      {@link android.os.UserManager#DISALLOW_MOUNT_PHYSICAL_MEDIA} is set to true when the
-      user inserts physical media such as an SD card.</li>
-      <li>The {@code DPM.setPackagesSuspended} state does not persist when the user uninstalls and then reinstalls an app. Either the app should remain suspended after uninstall/reinstall, or suspended apps should not be uninstallable</li>
-      <li>The first check-in in a Work Profile takes several minutes to complete. This may cause the device to take longer than normal to be visible in the Play EMM API.</li>
-      <li>Notifications from Work Profile apps are not visible to notification listeners installed in the personal profile. As a result, the system does not display Notifications as expected.</li>
-      <li>The version of Google Apps Device Policy that is bundled with N Developer Preview does not yet support the Work Profile Security Challenge feature. Developers should instead use TestDPC to test this feature.</li>
-   </ul>
-   </li>
+  <li>Suspend Packages
+  </li>
+
+  <li>Device admins can suspend critical system packages, which may lead to
+  unexpected behavior, such as placing calls despite the Telephone disabled
+  dialog’s being displayed.
+  </li>
+
+  <li>Other
+    <ul>
+      <li>The Settings app crashes on launch if {@link
+      android.os.UserManager#DISALLOW_MOUNT_PHYSICAL_MEDIA} is set to true when
+      the user inserts physical media such as an SD card.
+      </li>
+
+      <li>The {@code DPM.setPackagesSuspended} state does not persist when the
+      user uninstalls and then reinstalls an app. Either the app should remain
+      suspended after uninstall/reinstall, or suspended apps should not be
+      uninstallable
+      </li>
+
+      <li>The first check-in in a Work Profile takes several minutes to
+      complete. This may cause the device to take longer than normal to be
+      visible in the Play EMM API.
+      </li>
+
+      <li>Notifications from Work Profile apps are not visible to notification
+      listeners installed in the personal profile. As a result, the system does
+      not display Notifications as expected.
+      </li>
+
+      <li>The version of Google Apps Device Policy that is bundled with N
+      Developer Preview does not yet support the Work Profile Security
+      Challenge feature. Developers should instead use TestDPC to test this
+      feature.
+      </li>
+    </ul>
+  </li>
 </ul>
 
 <h4 id="keyboard">Keyboard</h4>
@@ -143,60 +248,108 @@
 
 <h4 id="wifi">Wi-Fi</h4>
 
-   <ul>
-   <li>Wi-Fi has undergone some refactoring which may change API corner case behavior. Specifically, applications which attempt to connect to specific networks, or attempt to reconnect to networks should retest.</li>
-   <li>The legacy DHCP client has been removed from the platform. The only DHCP client that the platform
-   supports is the DHCP client introduced in M.</li>
-   </ul>
+<ul>
+  <li>Wi-Fi has undergone some refactoring which may change API corner case
+  behavior. Specifically, applications which attempt to connect to specific
+  networks, or attempt to reconnect to networks should retest.
+  </li>
+
+  <li>The legacy DHCP client has been removed from the platform. The only DHCP
+  client that the platform supports is the DHCP client introduced in M.
+  </li>
+</ul>
 
 <h4 id="direct">Direct boot</h4>
 
 <ul>
-   <li>NFC doesn't function until first unlock.
-   <ul>
-      <li>When a phone with Bluetooth enabled is restarted, Bluetooth does not turn on automatically. You must manually re-enable Bluetooth.</li>
-      <li>Under some circumstances, the default ringtone may not sound for phone calls and messages. This behavior is fixed in the next N Preview release, with one exception (and workaround):</li>
-      <li>On a device that is not freshly wiped--one that has been booted at least once since being set to direct boot mode--the default notification ringtone does not sound. The user can work around this issue by manually selecting a ringtone from Settings.</li>
-      <li>Direct boot is not enabled by default on devices running an N Developer Preview build. To enable direct boot for testing and development, go to Developer Options and tap Convert to File Encryption. In this dev preview, this requires a factory reset to repartition and reformat your device for File-based Encryption.</li>
-   </ul>
-   </li>
+  <li>NFC doesn't function until first unlock.
+    <ul>
+      <li>When a phone with Bluetooth enabled is restarted, Bluetooth does not
+      turn on automatically. You must manually re-enable Bluetooth.
+      </li>
+
+      <li>Under some circumstances, the default ringtone may not sound for
+      phone calls and messages. This behavior is fixed in the next N Preview
+      release, with one exception (and workaround):
+      </li>
+
+      <li>On a device that is not freshly wiped--one that has been booted at
+      least once since being set to direct boot mode--the default notification
+      ringtone does not sound. The user can work around this issue by manually
+      selecting a ringtone from Settings.
+      </li>
+
+      <li>Direct boot is not enabled by default on devices running an N
+      Developer Preview build. To enable direct boot for testing and
+      development, go to Developer Options and tap Convert to File Encryption.
+      In this dev preview, this requires a factory reset to repartition and
+      reformat your device for File-based Encryption.
+      </li>
+    </ul>
+  </li>
 </ul>
 
 <h4 id="pip">Picture-in-picture for Android TV</h4>
 
 <ul>
-<li>The PIP integration in the Recents UI is not finalized, and is subject to change.
-   <ul>
-      <li>The animation of the PIP window is not smooth. Future releases of the Preview will improve this.</li>
-      </li>Future releases of the Preview will improve upon the visual design and layout alignment of PIP. </li>
-   </ul>
-</li>
+  <li>The PIP integration in the Recents UI is not finalized, and is subject to
+  change.
+    <ul>
+      <li>The animation of the PIP window is not smooth. Future releases of the
+      Preview will improve this.
+      </li>
+    </ul>
+  </li>
+
+  <li style="list-style: none">Future releases of the Preview will improve upon
+  the visual design and layout alignment of PIP.
+  </li>
 </ul>
 
 <h4 id="bugs">Bug reports</h4>
 
 <ul>
-   <li>Bug reports do not always complete successfully (as a workaround, sometimes they can still be accessed through the bug report document provider in internal storage).</li>
+  <li>Bug reports do not always complete successfully (as a workaround,
+  sometimes they can still be accessed through the bug report document provider
+  in internal storage).
+  </li>
 </ul>
 
 <h4 id="split">Split-screen Multi-window</h4>
 
 <ul>
-   <li>Apps may experience crashes and unexpected UI behavior when put into split-screen mode. These are app issues that must be fixed by the app developer.</li>
-   <li>When an app targets a version of the Android platform earlier than N, the App may not work with split-screen toast may appear multiple times.</li>
-   <li>Long-pressing the Overview button while using an app with a fixed orientation may produce unexpected app behavior.</li>
-   <li>Apps may flicker while resizing.</li>
-   <li>Animations are not yet final.</li>
+  <li>Apps may experience crashes and unexpected UI behavior when put into
+  split-screen mode. These are app issues that must be fixed by the app
+  developer.
+  </li>
+
+  <li>When an app targets a version of the Android platform earlier than N, the
+  App may not work with split-screen toast may appear multiple times.
+  </li>
+
+  <li>Long-pressing the Overview button while using an app with a fixed
+  orientation may produce unexpected app behavior.
+  </li>
+
+  <li>Apps may flicker while resizing.
+  </li>
+
+  <li>Animations are not yet final.
+  </li>
 </ul>
 
 <h4 id="ime">Input method</h4>
 
 <ul>
-   <li>
-   Google Keyboard unexpectedly falls back to the generic Google keyboard when <b>Use system language</b>, but Google Keyboard doesn’t support any of the languages selected in the system-language preferences. It should fall back to American English.
-
-   <p>You can work around this problem by adding at least one language that Google Keyboard supports.</p>
-   </li>
+  <li>Google Keyboard unexpectedly falls back to the generic Google keyboard
+  when <b>Use system language</b>, but Google Keyboard doesn’t support any of
+  the languages selected in the system-language preferences. It should fall
+  back to American English.
+    <p>
+      You can work around this problem by adding at least one language that
+      Google Keyboard supports.
+    </p>
+  </li>
 </ul>
 
 
@@ -217,3 +370,13 @@
 <ul>
 <li>Multi-window resizing may cause crashing.</li>
 </ul>
+
+<h4 id="n9">Nexus 9</h4>
+<ul>
+<li>Nexus 9 devices may not start after receiving an over-the-air (OTA) update
+  via the Android Beta Program. To recover from this issue, you can try
+  to manually install the OTA image. For more information, see
+  <a href="{@docRoot}preview/download-ota.html">Applying a Device OTA Image</a>.
+</li>
+</ul>
+
diff --git a/docs/html/sdk/installing/adding-packages.jd b/docs/html/sdk/installing/adding-packages.jd
index 2911c38..70bb9fa 100644
--- a/docs/html/sdk/installing/adding-packages.jd
+++ b/docs/html/sdk/installing/adding-packages.jd
@@ -86,8 +86,6 @@
 <li>
   <h2 id="GetTools" class="norule">Get the latest SDK tools</h2>
 
-<img src="/images/sdk_manager_packages.png" alt="" width="350" style="float:right;margin-left:20px" />
-
   <p>As a minimum when setting up the Android SDK,
   you should download the latest tools and Android platform:</p>
   <ol>
diff --git a/docs/html/sdk/sdk_vars.cs b/docs/html/sdk/sdk_vars.cs
index cd01a64..7e17801 100644
--- a/docs/html/sdk/sdk_vars.cs
+++ b/docs/html/sdk/sdk_vars.cs
@@ -40,17 +40,17 @@
 
 
 set:ndk.mac64_download='android-ndk-r11-darwin-x86_64.zip' ?><?cs
-set:ndk.mac64_bytes='774830876' ?><?cs
-set:ndk.mac64_checksum='7a6fdc0931ea9fe2713064f04474333369a34d53' ?><?cs
+set:ndk.mac64_bytes='772314112' ?><?cs
+set:ndk.mac64_checksum='a3764714eff7d187c80d989a9bf1ff8ebf5a0dfa' ?><?cs
 
 set:ndk.linux64_download='android-ndk-r11-linux-x86_64.zip' ?><?cs
-set:ndk.linux64_bytes='796414803' ?><?cs
-set:ndk.linux64_checksum='8583ff5c22af1603129a6ec35afd3d51163e3fc1' ?><?cs
+set:ndk.linux64_bytes='794012672' ?><?cs
+set:ndk.linux64_checksum='7b4e0d13f6bbf48dd87475be9d052273dc766fb6' ?><?cs
 
 set:ndk.win64_download='android-ndk-r11-windows-x86_64.zip' ?><?cs
-set:ndk.win64_bytes='771291233' ?><?cs
+set:ndk.win64_bytes='771291648' ?><?cs
 set:ndk.win64_checksum='49fcdae88724c74bb52b332b648edba9700b9529' ?><?cs
 set:ndk.win32_download='android-ndk-r11-windows-x86.zip' ?><?cs
-set:ndk.win32_bytes='728773247' ?><?cs
+set:ndk.win32_bytes='728773632' ?><?cs
 set:ndk.win32_checksum='0c9e895e400ab539c2005759410ef3e33d048291'
 ?>
diff --git a/docs/html/tools/support-library/features.jd b/docs/html/tools/support-library/features.jd
index d0c0965..fa5a8b4 100755
--- a/docs/html/tools/support-library/features.jd
+++ b/docs/html/tools/support-library/features.jd
@@ -153,7 +153,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:support-v4:23.1.0
+com.android.support:support-v4:23.2.1
 </pre>
 
 
@@ -237,7 +237,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:appcompat-v7:23.1.0
+com.android.support:appcompat-v7:23.2.1
 </pre>
 
 
@@ -258,7 +258,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:cardview-v7:23.1.0
+com.android.support:cardview-v7:23.2.1
 </pre>
 
 
@@ -280,7 +280,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:gridlayout-v7:23.1.0
+com.android.support:gridlayout-v7:23.2.1
 </pre>
 
 
@@ -314,7 +314,7 @@
 where "&lt;revision&gt;" is the minimum revision at which the library is available. For example:</p>
 
 <pre>
-com.android.support:mediarouter-v7:23.1.0
+com.android.support:mediarouter-v7:23.2.1
 </pre>
 
 <p class="caution">The v7 mediarouter library APIs introduced in Support Library
@@ -340,7 +340,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:palette-v7:23.1.0
+com.android.support:palette-v7:23.2.1
 </pre>
 
 
@@ -362,7 +362,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:recyclerview-v7:23.1.0
+com.android.support:recyclerview-v7:23.2.1
 </pre>
 
 
@@ -391,7 +391,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:preference-v7:23.1.0
+com.android.support:preference-v7:23.2.1
 </pre>
 
 
@@ -455,7 +455,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:support-v13:23.1.0
+com.android.support:support-v13:23.2.1
 </pre>
 
 
@@ -487,7 +487,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:preference-v14:23.1.0
+com.android.support:preference-v14:23.2.1
 </pre>
 
 
@@ -516,7 +516,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:preference-leanback-v17:23.1.0
+com.android.support:preference-leanback-v17:23.2.1
 </pre>
 
 
@@ -558,7 +558,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:leanback-v17:23.1.0
+com.android.support:leanback-v17:23.2.1
 </pre>
 
 
@@ -579,7 +579,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:support-annotations:23.1.0
+com.android.support:support-annotations:23.2.1
 </pre>
 
 
@@ -604,7 +604,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:design:23.1.0
+com.android.support:design:23.2.1
 </pre>
 
 
@@ -632,7 +632,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:customtabs:23.1.0
+com.android.support:customtabs:23.2.1
 </pre>
 
 
@@ -663,7 +663,7 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:percent:23.1.0
+com.android.support:percent:23.2.1
 </pre>
 
 
@@ -693,5 +693,5 @@
 <p>The Gradle build script dependency identifier for this library is as follows:</p>
 
 <pre>
-com.android.support:recommendation:23.1.0
+com.android.support:recommendation:23.2.1
 </pre>
diff --git a/docs/html/tools/support-library/index.jd b/docs/html/tools/support-library/index.jd
index df9dcf9..2a673f9 100644
--- a/docs/html/tools/support-library/index.jd
+++ b/docs/html/tools/support-library/index.jd
@@ -59,9 +59,314 @@
 <p>This section provides details about the Support Library package releases.</p>
 
 <div class="toggle-content opened">
-  <p id="rev23-2-0">
+  <p id="rev23-2-1">
     <a href="#" onclick="return toggleContent(this)"><img src=
     "{@docRoot}assets/images/triangle-opened.png" class="toggle-content-img"
+    alt="">Android Support Library, revision 23.2.1</a> <em>(March
+    2016)</em>
+  </p>
+
+  <div class="toggle-content-toggleme">
+    <dl>
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#v4">v4 Support
+        Library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Fixed an exception in {@link
+          android.support.v4.graphics.drawable.DrawableCompat#wrap
+          DrawableCompat.wrap()} and {@link android.graphics.drawable.LayerDrawable} on
+          API levels 17 to 19. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201817">Issue 201817</a>)
+          </li>
+
+          <li>Fixed an {@code ArrayIndexOutOfBoundsException} in {@link
+          android.support.v4.widget.ViewDragHelper#shouldInterceptTouchEvent
+          ViewDragHelper.shouldInterceptTouchEvent()}. (<a class="external-link"
+            href="https://code.google.com/p/android/issues/detail?id=182262">Issue
+            182262</a>)
+          </li>
+
+          <li>Fixed a bug in {@link android.support.v4.view.ViewPager} related to
+          scroll calculation for size changes.
+          </li>
+
+          <li>Fixed a {@code NullPointerException} when {@code
+          DrawerLayout.removeDrawerListener()} is called without a set {@link
+          android.support.v4.widget.DrawerLayout.DrawerListener
+          DrawerLayout.DrawerListener}. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202478">Issue 202478</a>)
+          </li>
+
+          <li>Fixed a bug where {@link android.support.v4.view.ViewPager} does not set
+          {@link android.view.accessibility.AccessibilityEvent} parameters properly
+          when scrolling.
+          </li>
+
+          <li>Fixed an issue that caused lag during device rotation when using
+          {@link android.support.v4.graphics.drawable.DrawableCompat#wrap
+          Drawable.wrap()}. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201924">Issue 201924</a>)
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#v7-appcompat">v7
+        appcompat library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Reverted dependency on vector assets so that developers using the
+            <a href="{@docRoot}tools/support-library/features.html#v7-appcompat">appcompat
+            library</a> are not forced to use {@link
+            android.graphics.drawable.VectorDrawable} and its associated build flags.
+          </li>
+
+          <li>Fixed a compatibility issue with Night Mode and API level 23.
+            (<a class="external-link" href=
+            "https://code.google.com/p/android/issues/detail?id=201910">Issue
+            201910</a>)
+          </li>
+
+          <li>Fixed a compatibility issue with {@link
+          android.support.v7.widget.SwitchCompat} and API level 7. (<a class=
+          "external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201942">Issue 201942</a>)
+          </li>
+
+          <li>Fixed an issue with propagating configuration values in Resources objects
+          <a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201928">Issue 201928</a>
+          </li>
+
+          <li>Fixed a compatibility issue where the {@link
+          android.support.v7.app.NotificationCompat.MediaStyle
+          NotificationCompat.MediaStyle} cancel button becomes invisible on API level
+          21 and below. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202156">Issue 202156</a>)
+          </li>
+
+          <li>Fixed a compatibility crash with {@link
+          android.support.v7.widget.AppCompatSpinner} on API level 21 and below.
+          (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202246">Issue 202246</a>)
+          </li>
+
+          <li>Fixed an issue where the {@code app:textAllCaps = "false"} style did not
+          work. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202117">Issue 202117</a>)
+          </li>
+
+          <li>Fixed a crash when restoring {@link android.widget.SearchView}.
+            (<a class="external-link" href=
+            "https://code.google.com/p/android/issues/detail?id=201836">Issue
+            201836</a>)
+          </li>
+
+          <li>Fixed a memory leak that occurs when tinting drawable resources using
+          AppCompat. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202379">Issue 202379</a>)
+          </li>
+
+          <li>Fixed an issue with {@link android.view.KeyEvent} on API level 11 and
+          lower. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202939">Issue 202939</a>)
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#v7-cardview">v7 cardview
+        library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Added Night Mode support for {@link
+          android.support.v7.widget.CardView}. (<a class="external-link"
+            href="https://code.google.com/p/android/issues/detail?id=194497">Issue
+            194497</a>)
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#v7-recyclerview">v7
+        recyclerview library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Fixed bugs related to various measure-spec methods. (<a class=
+          "external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201856">Issue
+          201856</a>)
+          </li>
+
+          <li>Reduced the lockdown period in which {@link
+          android.support.v7.widget.RecyclerView} does not allow adapter
+          changes while calculating a layout or scroll. (<a class=
+          "external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202046">Issue
+          202046</a>)
+          </li>
+
+          <li>Fixed a crash when calling {@link
+          android.support.v7.widget.RecyclerView.Adapter#notifyItemChanged
+          notifyItemChanged()} on an item that is out of view. (<a class=
+          "external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202136">Issue
+          202136</a>)
+          </li>
+
+          <li>Fixed a crash that occurs when {@link
+          android.support.v7.widget.RecyclerView.LayoutManager
+          RecyclerView.LayoutManager} adds and removes a view in the same
+          measurement pass. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=193958">Issue
+          193958</a>)
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#v7-mediarouter">v7
+        mediarouter library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Fixed a crash that occurs when calling {@link
+          android.support.v7.media.MediaRouter#getInstance
+          MediaRouter.getInstance()} on API level 17. (<a class="external-link"
+            href=
+            "https://code.google.com/p/android/issues/detail?id=180654">Issue
+            180654</a>)
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#v17-leanback">v17
+        Leanback Library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Fixed an issue with {@code GridLayout.onAddFocusables()} that
+          caused the wrong item to be selected.
+          </li>
+
+          <li>Fixed issue with {@link
+          android.support.v17.leanback.app.GuidedStepFragment} actions
+          disappearing after an action was collapsed.
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for <a href=
+        "{@docRoot}tools/support-library/features.html#design">Design Support
+        Library</a>:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Fixed a {@link android.support.design.widget.TabLayout} crash
+          caused by tab-pooling. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201827">Issue
+          201827</a>)
+          </li>
+
+          <li>Fixed a bug in {@link
+          android.support.design.widget.NavigationView} that caused the wrong
+          color to be selected. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201951">Issue
+          201951</a>)
+          </li>
+
+          <li>Fixed a bug where {@link
+          android.support.design.widget.FloatingActionButton#setBackgroundTintList
+          setBackgroundTintList()} was no longer able to change the background
+          color. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201873">Issue
+          201873</a>)
+          </li>
+
+          <li>Fixed an issue where {@link
+          android.support.design.widget.AppBarLayout} did not completely scroll
+          out of view when used with {@code android:fitsSystemWindows = “true”}.
+          (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201822">Issue
+          201822</a>)
+          </li>
+
+          <li>Fixed an issue where {@code BottomSheetDialog} did not display
+          short content views correctly. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201793">Issue
+          201793</a>)
+          </li>
+
+          <li>Fixed an issue where {@code BottomSheetDialogFragment} moved
+          sporadically when content inside was changed. (<a class=
+          "external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202125">Issue
+          202125</a>)
+          </li>
+
+          <li>Fixed a crash in TextInputLayout counter <a class="external-link"
+            href=
+            "https://code.google.com/p/android/issues/detail?id=202051">link</a>
+          </li>
+
+          <li>Fixed a crash that occured when {@link
+          android.support.design.widget.TextInputLayout#getCounterMaxLength
+          TextInputLayout.getCounterMaxLength()} restored a saved state.
+          (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=202375">Issue
+          202375</a>)
+          </li>
+
+          <li>Fixed a {@code ClassCastException} that occurred when restoring a
+          {@link android.support.design.widget.CoordinatorLayout} using the
+          saved state of a view that was not a {@link
+          android.support.design.widget.CoordinatorLayout}.
+          </li>
+        </ul>
+      </dd>
+
+      <dt>
+        Changes for VectorDrawableCompat:
+      </dt>
+
+      <dd>
+        <ul>
+          <li>Fixed a bug where the wrong variable was read for {@code
+          android:tintMode}. (<a class="external-link" href=
+          "https://code.google.com/p/android/issues/detail?id=201907">Issue
+          201907</a>)
+          </li>
+        </ul>
+      </dd>
+    </dl>
+  </div>
+</div>
+<!-- end of collapsible section -->
+
+<div class="toggle-content closed">
+  <p id="rev23-2-0">
+    <a href="#" onclick="return toggleContent(this)"><img src=
+    "{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img"
     alt="">Android Support Library, revision 23.2.0</a> <em>(February
     2016)</em>
   </p>
