diff --git a/docs/html/_redirects.yaml b/docs/html/_redirects.yaml
index 30dd6de..4211c6f 100644
--- a/docs/html/_redirects.yaml
+++ b/docs/html/_redirects.yaml
@@ -703,8 +703,18 @@
   to: /training/location/index.html
 - from: /google/gcm/adv.html
   to: /google/gcm/gcm.html
-- from: /work
-  to: /training/enterprise/index.html
+- from: /training/enterprise/index.html
+  to: /work/index.html
+- from: /training/enterprise/app-compatibility.html
+  to: /work/managed-profiles.html
+- from: /training/enterprise/app-restrictions.html
+  to: /work/app-restrictions.html
+- from: /training/enterprise/cosu.html
+  to: /work/cosu.html
+- from: /training/enterprise/device-management-policy.html
+  to: /work/device-management-policy.html
+- from: /training/enterprise/work-policy-ctrl.html
+  to: https://developers.google.com/android/work/build-dpc
 - from: /distribute/tools/promote/badge-files.html
   to: https://play.google.com/intl/en_us/badges/
 - from: /google/gcm/...
@@ -1134,12 +1144,6 @@
 - from: /tools/revisions/index.html
   to: /studio/releases/index.html
 
-# Wear Preview related (remove in mnc-io-docs)
-- from: /wear/preview/start.html
-  to: /training/building-wearables.html
-- from: /wear/preview/index.html
-  to: /patience.html
-
 # Just incase something was missed, go to intro page
 - from: /tools/...
   to: /studio/intro/index.html
diff --git a/docs/html/distribute/googleplay/work/about.jd b/docs/html/distribute/googleplay/work/about.jd
index a31bca2..79e8a89 100644
--- a/docs/html/distribute/googleplay/work/about.jd
+++ b/docs/html/distribute/googleplay/work/about.jd
@@ -52,10 +52,13 @@
 <h3 id="design">Develop a great app for business</h3>
 
 <ul>
-  <li>Follow best practices for security and manage user data properly. Businesses
-  are more conscious of data security and employee productivity, especially when it
-  comes to features that share information with other services.</li>
-  <li>Support the <a href="{@docRoot}training/enterprise/app-restrictions.html">App Configuration framework</a> to let an administrator remotely configure app settings such as:
+  <li>Follow best practices for security and manage user data
+  properly. Businesses are more conscious of data security and
+  employee productivity, especially when it comes to features that
+  share information with other services.</li>
+  <li>Support the <a href="{@docRoot}work/app-restrictions.html"
+    >App Configuration framework</a> to let an administrator remotely
+    configure app settings such as:
     <ul>
       <li>Server address and protocol settings</li>
       <li>The ability to switch features on and off</li>
@@ -65,11 +68,15 @@
   </li>
   <li>Request the minimum permissions that your app needs.</li>
   <li>Make sure communication to your backend and data in your backend is secure.</li>
-  <li>Implement authorization policies that will minimize the number of your employees that can access user data.</li>
-  <li><a href={@docRoot}training/enterprise/app-compatibility.html>Offer compatibility with work
-  profile</a> and test that with the <a href="{@docRoot}samples/BasicManagedProfile/index.html"
-  >BasicManagedProfile sample app</a>.</li>
-  <li>Support <a href="{@docRoot}training/enterprise/app-restrictions.html">app restrictions</a> so that IT admins can remotely configure your app through leading EMM solutions.</li>
+  <li>Implement authorization policies that will minimize the number of your
+    employees that can access user data.</li>
+  <li><a href="{@docRoot}work/managed-profiles.html">Offer compatibility with work
+    profile</a> and test that with the
+    <a href="{@docRoot}samples/BasicManagedProfile/index.html"
+    >BasicManagedProfile sample app</a>.</li>
+  <li>Support <a href="{@docRoot}work/app-restrictions.html">app restrictions</a>
+    so that IT admins can remotely configure your app through leading
+    EMM solutions.</li>
 </ul>
 
 <h3 id="support">Provide support and maintenance</h3>
diff --git a/docs/html/google/play/billing/billing_admin.jd b/docs/html/google/play/billing/billing_admin.jd
index ff7acc9..a1135bf 100644
--- a/docs/html/google/play/billing/billing_admin.jd
+++ b/docs/html/google/play/billing/billing_admin.jd
@@ -8,10 +8,11 @@
   <h2>In this document</h2>
   <ol>
     <li><a href="#billing-list-setup">Creating a Product List</a></li>
+    <li><a href="#pricing-template">Pricing Templates</a></li>
     <li><a href="#billing-purchase-type">Choosing a Product Type</a></li>
-    <li><a href="#billing-testing-setup">Setting up Test Accounts</a></li>
     <li><a href="#billing-refunds">Handling Refunds</a></li>
     <li><a href="#billing-refunds">Working with Order Numbers</a></li>
+    <li><a href="#billing-testing-setup">Setting up Test Accounts</a></li>
     <li><a href="#billing-support">Where to Get Support</a></li>
   </ol>
 
@@ -25,176 +26,164 @@
 </div>
 
 <p>In-app billing frees you from processing financial transactions, but you still need to perform a
-few administrative tasks, including setting up and maintaining your product list on the Google Play
-Developer Console, registering test accounts, and handling refunds when necessary.</p>
+few administrative tasks. These tasks include the following:</p>
+<ul>
+  <li>Setting up and maintaining your product list on the Google Play Developer Console.</li>
+  <li>Registering test accounts.</li>
+  <li>Handling refunds when necessary.</li>
+</ul>
+</p>
 
-<p>You must have a Google Play publisher account to register test accounts. And you must have a
-Google payments merchant account to create a product list and issue refunds to your users. If you
+<p>To register a test account, you must have a Google Play publisher account. If you
 already have a publisher account on Google Play, you can use your existing account. You do not
-need to register for a new account to support in-app billing.</p>
+need to register for a new account to support in-app billing. If you don't have a publisher
+account, you can register as a Google Play developer and set up a publisher account through the <a
+href="http://play.google.com/apps/publish">Google Play Developer Console</a>.</p>
 
-<p>If you do not have a publisher account, you can register as a Google Play
-developer and set up a publisher account at the <a
-href="http://play.google.com/apps/publish">Google Play Developer Console</a>. If you do not
-have a Google payments merchant account, you can register for one through the
-Developer Console.</p>
+<p>If you want to create a product list and issue refunds to your users, you must have a
+Google payments merchant account. If you don't have a merchant account, you can
+register for one through the Developer Console.</p>
 
 <h2 id="billing-list-setup">Creating a Product List</h2>
 
 <p>The Google Play Developer Console provides a product list for each of your published
-applications. You can sell an item using Google Play's in-app billing feature only if the item is
-listed on an application's product list. Each application has its own product list; you cannot sell
-items that are listed in another application's product list.</p>
+apps. You can sell an item using Google Play's in-app billing feature only if the item is
+listed on an app's product list. Each app has its own product list; you cannot sell
+items that appear on another app's product list.</p>
 
-<p>You can access an application's product list by clicking the <strong>In-App Products</strong>
-link in applications listed in your developer account (see
-figure 1). The <strong>In-App Products</strong> link appears only if you have a Google payments
-merchant account and the application's manifest includes the <code>com.android.vending.BILLING</code>
-permission.</p>
+<p>You can access an app's product list by opening the <strong>In-app Products</strong>
+page for an app that is listed in your developer account. The link to the
+<strong>In-app Products</strong> page appears only if you have a Google payments merchant
+account and the app's manifest includes the
+<code>com.android.vending.BILLING</code> permission. For more information about this
+permission, see <a href="{@docRoot}google/play/billing/billing_integrate.html#billing-permission">
+Updating Your App's Manifest</a>.</p>
 
-<p>A product list specifies items you are selling in an application &mdash; in-app products,
-subscriptions, or a combination of both. For each item, the product list contains information such as a product id,
-product description, and price. The product list stores only metadata about the items
-you are selling in your application. It does not store any digital content. You are responsible for
-storing and delivering the digital content that you sell in your applications.</p>
+<p>A product list specifies items you are selling in an app: in-app products,
+subscriptions, or a combination of both. For each item, the product list contains information
+such as product ID, product description, and price. You can create a product list for any
+published app, including apps published to the alpha and beta channels.</p>
 
-<div style="margin:1em;">
-<img style="border:1px solid #ddd;padding-bottom:.5em" src="{@docRoot}images/in-app-billing/billing_product_list.png" xheight="548" id="figure1" />
-<p class="img-caption" style="padding-left:.5em;">
-  <strong>Figure 1.</strong> You can access an application's product list by clicking the
-  <strong>In-App Products</strong> link in the main Apps navigation.
-</p>
-</div>
+<p>The product list stores only metadata about the items you are selling in your app.
+It does not store any digital content. You are responsible for storing and delivering
+the digital content that you sell in your apps.</p>
 
-<p>You can create a product list for any published application, or any
-application in the alpha or beta channels, that's been
-uploaded and saved to the Developer Console. However, you must have a Google payments merchant
-account and the application's manifest must include the <code>com.android.vending.BILLING</code>
-permission. If an application's manifest does not include this permission, you will be able to edit
-existing items in the product list but you will not be able to add new items to the list. For more
-information about this permission, see
-<a href="{@docRoot}google/play/billing/billing_integrate.html#billing-permission">Updating Your
-Application's Manifest</a>.</p>
-
-<p class="note"><strong>Note:</strong> Previously you could test an app by
-uploading an unpublished "draft" version. This functionality is no longer
+<p class="note"><strong>Note:</strong> Previously, you could test an app by
+uploading an unpublished draft version. This functionality is no longer
 supported; instead, you must publish it to the alpha or beta distribution
 channel. For more information, see <a
 href="{@docRoot}google/play/billing/billing_testing.html#draft_apps">Draft Apps
 are No Longer Supported</a>.
 
-<p>In addition, an application package can have only one product list. If you create a product
-list for an application, and you use the <a
+<p>In addition, an app package can have only one product list. If you create a product
+list for an app, and you use the <a
 href="{@docRoot}google/play/publishing/multiple-apks.html">multiple APK feature</a> to distribute
-more than one APK for that application, the product list applies to all APK versions that are
-associated with the application listing. You cannot create individual product lists for each APK if
+more than one APK for that app, the product list applies to all APK versions that are
+associated with the app listing. You cannot create individual product lists for each APK if
 you are using the multiple APK feature.</p>
 
-<p>You can add items to a product list two ways: you can add items one at a time by using the In-app
-Products UI (see figure 2), or you can add a batch of items by importing the items from a
+<p>You can add items to a product list two ways: you can add items one at a time on the <strong>In-app
+Products</strong> page, or you can add a batch of items by importing the items from a
 comma-separated values (CSV) file. Adding items one at a time is useful if your
-application has only a few in-app items or you are adding only a few items to a
-product list for testing purposes. The CSV file method is useful if your application has a large
+app has only a few in-app items or you are adding only a few items to a
+product list for testing purposes. The CSV file method is useful if your app has a large
 number of in-app items.</p>
 
-<p class="note"><strong>Note:</strong> Batch upload of product lists containing subscriptions is not yet supported.</p>
+<p class="note"><strong>Note:</strong> Batch upload of product lists containing
+  subscriptions is not supported. Also, when updating existing items in a batch upload,
+  you cannot include changes to in-app products that are linked to a
+<a href="#pricing-template">pricing template</a>.</p>
 
 <h3 id="billing-form-add">Adding items one at a time to a product list</h3>
 
-<p>To add an item to a product list using the In-app Products UI, follow these steps:</p>
+<p>To add an item to a product list using the Developer Console UI, follow these steps:</p>
 
 <ol>
   <li><a href="http://play.google.com/apps/publish">Log in</a> to your publisher account.</li>
-  <li>In the <strong>All Applications</strong> panel, click on the
-  app name, then select <strong>In-app Products</strong>.</li>
-  <li>Click <strong>Add new product</strong> (see figure 2) and provide details about the item you are
-  selling and then click <strong>Save</strong> or <strong>Publish</strong>.</li>
+  <li>In the <strong>All applications</strong> panel, click on the
+  app name, then open the <strong>In-app Products</strong> page.</li>
+  <li><p>Click <strong>Add new product</strong>. After you provide the product type and ID for the item you are
+  selling, click <strong>Continue</strong>.</p>
+  <dl>
+      <dt>Product Type</dt>
+      <dd>
+        <p>The product type can be <strong>Managed product</strong> or <strong>Subscription</strong>. You cannot
+        change an item's product type after you create the item. For more information, see
+        <a href="#billing-purchase-type">Choosing a Product Type</a>.</p>
+        <p class="note"><strong>Note: </strong>For subscription items, you cannot change the
+        item's price once you have published the item.</p>
+      </dd>
+      <dt>Product ID</dt>
+      <dd>
+        <p>Product IDs are unique across an app's namespace. A product ID must start with a
+        lowercase letter or a number and must be composed of only lowercase letters (a-z), numbers
+        (0-9), underscores (_), and periods (.). The product ID <code>android.test</code> is reserved, as are all
+        product IDs that start with <code>android.test</code>.</p>
+        <p class="note"><strong>Note: </strong>Be sure to plan your product ID namespace carefully. You
+        cannot modify an item's product ID after the item is created, and you cannot reuse
+        a product ID within an app.</p>
+      </dd>
+    </dl>
+  </li>
+  <li><p>Enter additional information about the item, then click <strong>Save</strong>.</p>
+    <dl>
+      <dt>Publishing State</dt>
+      <dd>
+        <p>An item's publishing state can be <strong>Active</strong> or
+        <strong>Inactive</strong>. To be visible to a user during checkout, an item's publishing state must be set to
+        <strong>Active</strong>, and the item's app must be published on Google Play.</p>
+        <p class="note"><strong>Note:</strong> If you're using a test account, users can see active items
+        within unpublished apps, as well. For more information, see <a
+        href="{@docRoot}google/play/billing/billing_testing.html#billing-testing-real">Testing In-app
+        Billing</a>.</p>
+      </dd>
+      <dt>Languages and Translations</dt>
+      <dd>
+        <p>By default, in-app products inherit their default language from the parent app.</p>
+        <p>You can provide localized titles and descriptions for your in-app
+        products by selecting <strong>Add Translations</strong>. If you want Google
+        Play to translate your title and description for you, based on the title and
+        description in the default language, just choose the languages that you
+        want to offer. You can also provide custom translations in specific
+        languages.</p>
+      </dd>
+      <dt>Title</dt>
+      <dd>
+        The title is a short descriptor for the item. An example of a title is: "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.
+      </dd>
+      <dt>Description</dt>
+      <dd>
+        The description is a long descriptor for the item. An example of a description is:
+        "Instantly puts creatures to sleep. Does not work on angry elves." Every item must have a description.
+        Descriptions can be up to 80 characters in length.
+      </dd>
+      <dt>Price</dt>
+      <dd>
+        <p>Provide a price in your home currency, or link the price to an existing
+        pricing template. Based on the price you enter or the prices
+        from the pricing template, the system autofills country-specific prices for
+        different currencies. These generated prices use current exchange rates and
+        locally relevant pricing patterns (see figure 1).</p>
+        <p>You can also change prices for other currencies manually, but you can do
+          this only if a currency is used in one of the target countries for your
+          app. You can specify target countries for your app on the
+          <strong>Pricing &amp; Distribution</strong> page in the Google Play
+          Developer Console.</p>
+      </dd>
+    </dl>
+  </li>
 </ol>
 
-<div style="margin:1em;">
-<img style="border:1px solid #ddd;padding-bottom:.5em;" src="{@docRoot}images/in-app-billing/billing_add.png" height="300" id="figure2" />
-<p class="img-caption" style="padding-left:.5em;">
-  <strong>Figure 2.</strong> The Add New Product page lets you add items to an
-  application's product list.
-</p>
-</div>
-
-<p>You must enter the following information for each item in a product list:</p>
-<ul>
-  <li><strong>In-app Product ID</strong>
-    <p>Product IDs are unique across an application's namespace. A product ID must start with a
-    lowercase letter or a number, and must be composed using only lowercase letters (a-z), numbers
-    (0-9), underlines (_), and dots (.). The product ID "android.test" is reserved, as are all
-    product IDs that start with "android.test."</p>
-    <p>In addition, you cannot modify an item's product ID after it is created, and you cannot reuse
-    a product ID.</p>
-  </li>
-  <li><strong>Product Type</strong>
-    <p>The product type can be <strong>Managed per user account</strong>,
-    <strong>Unmanaged</strong>, or <strong>Subscription</strong>. You can never
-    change an item's product type after you set it. For more information, see
-    <a href="#billing-purchase-type">Choosing a product type</a> later in this
-    document.</p>
-  </li>
-  <li><strong>Publishing State</strong>
-    <p>An item's publishing state can be <strong>Published</strong> or <strong>Unpublished
-    </strong>. To be visible to a user during checkout, an item's publishing state must be set to
-    <strong>Published</strong> and the item's application must be published on Google Play.</p>
-    <p class="note"><strong>Note:</strong> This is not true for test accounts. An item is visible to
-    a test account if the application is not published and the item is published. See <a
-    href="{@docRoot}google/play/billing/billing_testing.html#billing-testing-real">Testing In-app
-    Billing</a> for more information.</p>
-  </li>
-  <li><strong>Languages and Translations</strong>
-    <p>You can provide localized titles and descriptions for your in-app
-    products using the Add Translations button. If you want Google Play to translate
-    your title and description for you, based on the title and description in the
-    default language, just click the languages that you want to offer. If you want
-    to provide custom translations in specific languages, you can also do that. By
-    default, an in-app product inherits its default language from the parent
-    application.</p>
-  </li>
-  <li><strong>Title</strong>
-    <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>
-  <li><strong>Description</strong>
-    <p>The description is a long descriptor for the item. For example, "Instantly puts creatures to
-    sleep. Does not work on angry elves." Every item must have a description. Descriptions can be
-    up to 80 characters in length.</p>
-  </li>
-  <li><strong>Price</strong>
-    <p>You must provide a default price in your home currency. You can also provide prices in other
-    currencies, but you can do this only if a currency's corresponding country is listed as a
-    target country for your application. You can specify target countries on the Edit Application
-    page in the Google Play developer console.</p>
-    <p>To specify prices in other currencies, you can manually enter the price for each
-    currency or you can click <strong>Auto Fill</strong> and let Google Play do a one-time
-    conversion from your home currency to the currencies you are targeting (see figure 3).</p>
-    <p>For subscription items, note that you can not change the item's price once you have published
-    it.</p>
-  </li>
-</ul>
-
-<div style="margin:1em;">
-<img style="border:1px solid #ddd;padding-bottom:.5em"
-    src="{@docRoot}images/in-app-billing/billing_list_form_2.png"
-    xheight="1226" id="figure3" />
-<p class="img-caption" style="padding-left:.5em;">
-  <strong>Figure 3.</strong> Specifying additional currencies for an in-app product.
-</p>
-</div>
-
-<p>For more information about product IDs and product lists, see <a
-href="http://support.google.com/googleplay/android-developer/bin/answer.py?hl=en&answer=1072599">
-Creating In-App Product IDs</a>. For more information about pricing, see <a
-href="http://support.google.com/googleplay/android-developer/bin/answer.py?hl=en&answer=1153485">
-In-App Billing Pricing</a>.</p>
-
-<p class="note"><strong>Note</strong>: Be sure to plan your product ID namespace. You cannot reuse
-or modify product IDs after you save them.</p>
+<figure id="fig-elp">
+  <img class="border-img" src="{@docRoot}images/in-app-billing/edit_local_prices.png"
+  width="700" alt="An item that costs 1.99 in USD usually costs a different
+  amount in AUD, EUR, or BOB. Some countries also add tax to the price.">
+  <figcaption>
+    <b>Figure 1. </b>Specifying additional currencies for an in-app product.
+  </figcaption>
+</figure>
 
 <h3 id="billing-bulk-add">Adding a batch of items to a product list</h3>
 
@@ -203,17 +192,46 @@
 manually through the In-app Products UI (see <a href="#billing-form-add">Adding items one at a time
 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
-tax-exclusive default price and tax-inclusive prices will be auto-filled. If you
+<p>If you are importing and exporting CSV files with in-app products, keep
+country-specific pricing in mind. If you use auto-fill, you can provide a
+tax-exclusive default price, and tax-inclusive prices will be auto-filled. If you
 do not use auto-fill, prices you provide must include tax.</p>
 
 <p class="note"><strong>Note:</strong> Batch upload of product lists containing
-subscriptions is not yet supported.</p>
+subscriptions is not supported. Also, when updating existing items in a batch
+upload, you cannot include changes to in-app products that are linked to a
+<a href="#pricing-template">pricing template</a>.</p>
 
-The CSV file uses commas (,) and semi-colons (;) to separate data values.
-Commas are used to separate primary data values, and semi-colons are used to separate subvalues. For
-example, the syntax for the CSV file is as follows:</p>
+<p>To import the items that are specified in your CSV file, do the following:</p>
+
+<ol>
+  <li><a href="http://play.google.com/apps/publish">Log in</a> to your publisher account.</li>
+  <li>In the <strong>All applications</strong> panel, select the app
+  name, then open the <strong>In-app Products</strong> page.</li>
+  <li>On the In-app Products List page, click <strong>Import/Export</strong>
+  &gt; <strong>Import in-app products from CSV file</strong>, then select your
+  CSV file.
+    <p>The CSV file must be on your local computer or on a local disk that is connected to your
+    computer.</p>
+  </li>
+  <li>Select the <strong>Overwrite</strong> checkbox if you want to overwrite existing items in
+  your product list.
+    <p>This option overwrites values of existing items only if the value of the <em>product_id</em>
+    in the CSV file matches the In-app Product ID for an existing item in the product list.
+    Overwriting doesn't delete items that are on a product list but not present in the CSV
+    file.</p>
+  </li>
+</ol>
+
+<p>You can also export an existing product list to a CSV file by clicking <strong>Export to CSV
+</strong> on the In-app Product List page. This is useful if you have manually added items to
+a product list and you want to start managing the product list through a CSV file.</p>
+
+<h4 id="billing-bulk-format">Formatting batches of items</h4>
+
+<p>The CSV file uses commas (,) and semicolons (;) to separate data values.
+Commas are used to separate primary data values, and semicolons are used to
+separate subvalues. For example, the syntax for the CSV file is as follows:</p>
 
 <p>"<em>product_id</em>","<em>publish_state</em>","<em>purchase_type</em>","<em>autotranslate</em>
 ","<em>locale</em>; <em>title</em>; <em>description</em>","<em>autofill</em>","<em>country</em>;
@@ -222,83 +240,108 @@
 
 <p>Descriptions and usage details are provided below.</p>
 
-<ul>
-  <li><em>product_id</em>
-    <p>This is equivalent to the In-app Product ID setting in the In-app Products UI. If you specify
+<dl>
+  <dt>product_id</dt>
+  <dd>
+    This is equivalent to the In-app Product ID setting in the In-app Products UI. If you specify
     a <em>product_id</em> that already exists in a product list, and you choose to overwrite
     the product list while importing the CSV file, the data for the existing item is overwritten with
     the values specified in the CSV file. The overwrite feature does not delete items that are on a
-    product list but not present in the CSV file.</p>
-  </li>
-  <li><em>publish_state</em>
-    <p>This is equivalent to the Publishing State setting in the In-app Products UI. Can be <code>
-    published</code> or <code>unpublished</code>.</p>
-  </li>
-  <li><em>purchase_type</em>
-    <p>This is equivalent to the Product Type setting in the In-app Products UI. Can be <code>
+    product list but not present in the CSV file.
+  </dd>
+  <dt>publish_state</dt>
+  <dd>
+    This is equivalent to the Publishing State setting in the In-app Products UI. Can be <code>
+    published</code> or <code>unpublished</code>.
+  </dd>
+  <dt>purchase_type</dt>
+  <dd>
+    This is equivalent to the Product Type setting in the In-app Products UI. Can be <code>
     managed_by_android</code>, which is equivalent to <strong>Managed per user account
     </strong> in the In-app Products UI, or <code>managed_by_publisher</code>, which is equivalent
-    to <strong>Unmanaged</strong> in the In-app Products UI.</p>
-  </li>
-  <li><em>autotranslate</em>
-    <p>This is equivalent to selecting the <strong>Fill fields with auto translation</strong>
-    checkbox in the In-app Products UI. Can be <code>true</code> or <code>false</code>.</p>
-  </li>
-  <li><em>locale</em>
+    to <strong>Unmanaged</strong> in the In-app Products UI.
+  </dd>
+  <dt>autotranslate</dt>
+  <dd>
+    This is equivalent to selecting the <strong>Fill fields with auto translation</strong>
+    checkbox in the In-app Products UI. Can be <code>true</code> or <code>false</code>.
+  </dd>
+  <dt>locale</dt>
+  <dd>
     <p>This is equivalent to the Language setting in the In-app Products UI. You must have an entry
     for the default locale. The default locale must be the first entry in the list of
     locales, and it must include a <em>title</em> and <em>description</em>. If you want to provide
     translated versions of the <em>title</em> and <em>description</em> in addition to the default,
     you must use the following syntax rules:</p>
-    <p>If <em>autotranslate</em> is <code>true</code>, you must specify the default locale,
-    default title, default description, and other locales using the following format:</p>
-    <p>"true,"<em>default_locale</em>; <em>default_locale_title</em>;
-    <em>default_locale_description</em>; <em>locale_2</em>;    <em>locale_3</em>, ..."</p>
-    <p>If <em>autotranslate</em> is <code>false</code>, you must specify the default locale,
-    default title, and default description as well as the translated titles and descriptions using
-    the following format:</p>
-    <p>"false,"<em>default_locale</em>; <em>default_locale_title</em>;
-    <em>default_locale_description</em>; <em>locale_2</em>; <em>locale_2_title</em>;
-    <em>local_2_description</em>; <em>locale_3</em>; <em>locale_3_title</em>;
-     <em>locale_3_description</em>; ..."</p>
+    <ul>
+      <li>
+      <p>If <em>autotranslate</em> is <code>true</code>, you must specify the default locale,
+      default title, default description, and other locales using the following format:</p>
+      <p>"true,"<em>default_locale</em>; <em>default_locale_title</em>;
+      <em>default_locale_description</em>; <em>locale_2</em>;    <em>locale_3</em>, ..."</p>
+      </li>
+      <li>
+      <p>If <em>autotranslate</em> is <code>false</code>, you must specify the default locale,
+      default title, and default description as well as the translated titles and descriptions using
+      the following format:</p>
+      <p>"false,"<em>default_locale</em>; <em>default_locale_title</em>;
+      <em>default_locale_description</em>; <em>locale_2</em>; <em>locale_2_title</em>;
+      <em>local_2_description</em>; <em>locale_3</em>; <em>locale_3_title</em>;
+       <em>locale_3_description</em>; ..."</p>
+      </li>
+    </ul>
     <p>See table 1 for a list of the language codes you can use with the <em>locale</em> field.</p>
-  </li>
-  <li><em>title</em>
-    <p>This is equivalent to the Title setting in the In-app Products UI. If the <em>title</em>
-    contains a semicolon, it must be escaped with a backslash (for example, "\;"). A backslash
-    should also be escaped with a backslash (for example, "\\">.</p>
-  </li>
-  <li><em>description</em>
-    <p>This is equivalent to the Description in the In-app Products UI. If the <em>description</em>
-    contains a semicolon, it must be escaped with a backslash (for example, "\;"). A backslash
-    should also be escaped with a backslash (for example, "\\">.</p>
-  </li>
-  <li><em>autofill</em>
+  </dd>
+  <dt>title</dt>
+  <dd>
+    This is equivalent to the Title setting in the In-app Products UI. If the <em>title</em>
+    contains a semicolon, it must be escaped with a backslash (for example, <code>\;</code>). Also, a backslash
+    must be escaped with a backslash (for example, <code>\\</code>).
+  </dd>
+  <dt>description</dt>
+  <dd>
+    This is equivalent to the Description in the In-app Products UI. If the <em>description</em>
+    contains a semicolon, it must be escaped with a backslash (for example, <code>\;</code>). Also, a backslash
+    must be escaped with a backslash (for example, <code>\\</code>).
+  </dd>
+  <dt>autofill</dt>
+  <dd>
     <p>This is equivalent to clicking <strong>Auto Fill</strong> in the In-app Products UI. Can be
     <code>true</code> or <code>false</code>. The syntax for specifying the <em>country</em>
-    and <em>price</em> varies depending on which <em>autofill</em> setting you use.</p>
-    <p>If <em>autofill</em> is set to <code>true</code>, you need to specify only the default
-    price in your home currency and you must use this syntax:</p>
-    <p>"true","<em>default_price_in_home_currency</em>"
-    <p>If <em>autofill</em> is set to <code>false</code>, you need to specify a <em>country</em>
-    and a <em>price</em> for each currency and you must use the following syntax:</p>
-    <p>"false", "<em>home_country</em>; <em>default_price_in_home_currency</em>; <em>country_2</em>;
-    <em>country_2_price</em>; <em>country_3</em>; <em>country_3_price</em>; ..."</p>
-  </li>
-  <li><em>country</em>
-    <p>The country for which you are specifying a price. You can only list countries that your
-    application is targeting. The country codes are two-letter uppercase
-    ISO country codes (such as "US") as defined by
-    <a href="http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2">ISO 3166-2</a>.</p>
-  </li>
-  <li><em>price</em>
-    <p>This is equivalent to the Price in the In-app Products UI. The price must be specified in
+    and <em>price</em> varies depending on which <em>autofill</em> setting you use:</p>
+    <ul>
+      <li>
+        <p>If <em>autofill</em> is set to <code>true</code>, you need to specify only the default
+        price in your home currency, and you must use this syntax:</p>
+        <p>"true","<em>default_price_in_home_currency</em>"
+      </li>
+      <li>
+        <p>If <em>autofill</em> is set to <code>false</code>, you need to specify a <em>country</em>
+        and a <em>price</em> for each currency, and you must use the following syntax:</p>
+        <p>"false", "<em>home_country</em>; <em>default_price_in_home_currency</em>; <em>country_2</em>;
+        <em>country_2_price</em>; <em>country_3</em>; <em>country_3_price</em>; ..."</p>
+      </li>
+    </ul>
+    <p class="note"><strong>Note: </strong>If you use an <em>autofill</em> value of <code>false</code>
+    and set country prices manually, you must incorporate country-specific
+    pricing patterns, including tax rates, into the prices you provide.</p>
+  </dd>
+  <dt>country</dt>
+  <dd>
+    The country for which you are specifying a price. You can only list countries that your
+    app is targeting. The country codes are two-letter uppercase
+    ISO country codes (such as "US"), as defined by
+    <a href="http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2">ISO 3166-2</a>.
+  </dd>
+  <dt>price</dt>
+  <dd>
+    This is equivalent to the Price in the In-app Products UI. The price must be specified in
     micro-units. To convert a currency value to micro-units, you multiply the real value by
     1,000,000.
-    For example, if you want to sell an in-app item for $1.99 you specify 1990000 in the
-    <em>price</em> field.</p>
-  </li>
-</ul>
+    For example, if you want to sell an in-app item for $1.99, you specify <code>1990000</code> in the
+    <em>price</em> field.
+  </dd>
+</dl>
 
 <p class="table-caption" id="language-table"><strong>Table 1.</strong> Language codes you can use
 with the <em>locale</em> field.</p>
@@ -373,51 +416,319 @@
 </tr>
 </table>
 
-<p>To import the items that are specified in your CSV file, do the following:</p>
+<h2 id="pricing-template">
+  Pricing Templates
+</h2>
+
+<p>
+  If you sell multiple apps at the same price, or if you sell multiple in-app
+  products at the same price across one or more apps, you can add <em>pricing
+  templates</em>. These templates make it easier to manage shared prices.
+</p>
+
+<h3 id="add-pricing-template">
+  Adding a pricing template
+</h3>
+
+<p>
+  When creating a pricing template, you provide new pricing information that you
+  can apply to paid apps and in-app products. To add a pricing template, do the
+  following:
+</p>
 
 <ol>
-  <li><a href="http://play.google.com/apps/publish">Log in</a> to your publisher account.</li>
-  <li>In the <strong>All Applications</strong> panel, click on the app
-  name, then select <strong>In-app Products</strong>.</li>
-  <li>On the In-app Products List page, click <strong>Import/Export</strong>
-  &gt; <strong>Import in-app products from CSV file</strong>, then select your
-  CSV file.
-    <p>The CSV file must be on your local computer or on a local disk that is connected to your
-    computer.</p>
+  <li>
+    <a href="http://play.google.com/apps/publish">Log in</a> to your publisher
+    account.
   </li>
-  <li>Select the <strong>Overwrite</strong> checkbox if you want to overwrite existing items in
-  your product list.
-    <p>This option overwrites values of existing items only if the value of the <em>product_id</em>
-    in the CSV file matches the In-app Product ID for an existing item in the product list.
-    Overwriting does not delete items that are on a product list but not present in the CSV
-    file.</p>
+
+  <li>In the <strong>Settings</strong> panel, open the <strong>Pricing
+  template</strong> page.
+  </li>
+
+  <li>
+    <p>
+      If you are adding your first pricing template, the <strong>Add a Pricing
+      Template</strong> banner appears. Select <strong>Add template</strong> to
+      create a new template. The new template's <em>Pricing</em> tab appears.
+    </p>
+
+    <p>
+      Otherwise, you see a list of your pricing templates. Select <strong>New
+      pricing template</strong>. The new template's <em>Pricing</em> tab
+      appears.
+    </p>
+  </li>
+
+  <li>
+    <p>
+      Provide details about the template. These details include the name, the
+      price, and whether to include tax as part of your country-specific
+      prices.
+    </p>
+    <p>
+      Based on the price and tax option you provide, the Developer Console
+      generates prices for international currencies using current exchange
+      rates and country-specific pricing patterns.
+    </p>
+  </li>
+  <li>Select <strong>Create template</strong> to finish adding the template.
   </li>
 </ol>
 
-<p>You can also export an existing product list to a CSV file by clicking <strong>Export to CSV
-</strong> on the In-app Product List page. This is useful if you have manually added items to
-a product list and you want to start managing the product list through a CSV file.</p>
+<h3 id="link-pricing-template">
+  Linking a pricing template
+</h3>
 
-<h3 id="billing-purchase-type">Choosing a Product Type</h3>
+<p>
+  You can create links between pricing templates and sets of paid apps and
+  in-app products that share the same price. After completing this linking
+  process, any changes you make to the pricing template are applied to the
+  prices of items that you've linked to the template. To complete the linking
+  process, use either the pricing template's <em>Linked Items</em> tab or the
+  Price section within a paid app or in-app product's pricing page.
+</p>
 
-<p>An item's product type controls how Google Play manages the purchase of the item. There are
-several product types, including "managed per user account", "unmanaged," and "subscription." However,
-note that the product types supported vary
-across In-app Billing Version, so you should always choose a product type that's valid for the
-version of In-app BIlling that your app uses. </p>
+<p class="note">
+  <strong>Note:</strong> Since a subscription within your app has a constant
+  price, you cannot link a subscription with a pricing template. You can,
+  however, import the prices from a pricing template and apply them to a new
+  subscription.
+</p>
 
-<p>For details, refer to the documentation for <a
-href="{@docRoot}google/play/billing/api.html#producttype">In-app Billing Version
-3</a> or <a href="{@docRoot}google/play/billing/v2/api.html#producttype">In-app
-Billing Version 2</a>.
+<h4>
+  Linking a pricing template to in-app products and paid apps
+</h4>
+
+<p>
+  To link a pricing template to an in-app product, do the following:
+</p>
+
+<ol>
+  <li>
+    <a href="http://play.google.com/apps/publish">Log in</a> to your publisher
+    account.
+  </li>
+
+  <li>In the <strong>Settings</strong> panel, open the <strong>Pricing
+  template</strong> page. This page shows the list of pricing templates you have
+  created for your account.
+  </li>
+
+  <li>Choose an existing pricing template that you want to link to an in-app
+  product, then select the template's <em>Linked Items</em> tab. This tab shows
+  options to link your pricing template to in-app products and paid apps
+  (see figure 2).
+  </li>
+
+  <li>In the Link In-App Products section of the tab, enter or choose the name
+  of an app. This app should contain the in-app product that you want to link
+  to your pricing template.
+  </li>
+
+  <li>Based on the app that you selected, you see a list of in-app products
+  that are active and are not yet linked to a pricing template. Choose the
+  in-app product that you want to link to the pricing template by selecting the
+  <strong>Link</strong> button that appears in the same row as the in-app
+  product.
+  </li>
+
+  <li>The price of the in-app product is now linked to your pricing template.
+  Any changes you make to the prices within your pricing template affect the
+  prices of the linked in-app product.
+  </li>
+</ol>
+
+<p>
+  To link a pricing template to the price of a paid app, you follow a similar
+  process. On the pricing template's <em>Linked Items</em> tab, choose a paid
+  app in the Link Paid Apps section.
+</p>
+
+<figure id="fig-lpt">
+  <img class="border-img"
+  src="{@docRoot}images/in-app-billing/link_pricing_template.png" width="700"
+  alt="The Sleeping Potion in-app product is linked to the Basic Inventory item,
+  but the Invisibility Potion is not.">
+  <figcaption>
+    <b>Figure 2. </b>On a pricing template's <em>Linked Items</em> tab, you can
+    change which in-app products and paid apps are linked to the pricing
+    template.
+  </figcaption>
+</figure>
+
+<h4>
+  Linking an in-app product or paid app to a pricing template
+</h4>
+
+<p>
+  To link an in-app product to a pricing template, do the following:
+</p>
+
+<ol>
+  <li>
+    <a href="http://play.google.com/apps/publish">Log in</a> to your publisher
+    account.
+  </li>
+
+  <li>In the <strong>All applications</strong> panel, select the app name, then
+  open the <strong>In-app Products</strong> page.
+  </li>
+
+  <li>Choose the in-app product that you want to link to a pricing template.
+  The item's details page appears.
+  </li>
+
+  <li>In the Pricing section, choose the pricing template that you want to link
+  to the price of this in-app product.
+  </li>
+
+  <li>The price of the in-app product is now linked to the pricing template you
+  selected. Any changes you make to the prices within your pricing template
+  affect the prices of this in-app product.
+  </li>
+</ol>
+
+<p>
+  To link the price of a paid app to a pricing template, you follow a similar
+  process on the app's <strong>Pricing &amp; Distribution</strong> page.
+</p>
+
+<h3 id="delete-linked-item">
+  Deleting an item that is linked to a pricing template
+</h3>
+
+<p>
+  As your app evolves, you may find it useful to remove older versions of
+  in-app products or unpublish paid apps, some of which may be linked to pricing
+  templates. To delete an in-app product or unpublish a paid app that is linked
+  to a pricing template, complete the following steps. You don't need to unlink
+  the in-app product or paid app from the pricing template beforehand.
+</p>
+
+<h4>
+  Deleting an in-app product that is linked to a template
+</h4>
+
+<p>
+  To delete an in-app product that is linked to a template, do the following:
+</p>
+
+<ol>
+  <li>
+    <a href="http://play.google.com/apps/publish">Log in</a> to your publisher
+    account.
+  </li>
+
+  <li>Select the app that contains the in-app product you want to delete.
+  </li>
+
+  <li>Open the app's <strong>In-app Products</strong> page.
+  </li>
+
+  <li>Choose the in-app product that you want to delete.
+  </li>
+
+  <li>Select the button that indicates whether the in-app product is active or
+  inactive (enclosed in a box within figure 3). The drop-down menu includes a
+  <strong>Delete</strong> option.
+  </li>
+  <li>Select <strong>Delete</strong>, then choose <strong>Yes</strong> in the
+  confirmation dialog that appears.
+  </li>
+</ol>
+
+<figure id="fig-diap">
+  <img class="border-img" src="{@docRoot}images/in-app-billing/delete_iap.png"
+  width="500" alt="">
+  <figcaption>
+    <b>Figure 3. </b>Deleting an in-app product that is linked to a pricing
+    template.
+  </figcaption>
+</figure>
+
+<h4>
+  Unpublishing a paid app that is linked to a template
+</h4>
+
+<div class="figure-right">
+  <figure id="fig-upa">
+    <img src="{@docRoot}images/in-app-billing/unpublish_paid_app.png"
+    width="700" alt="">
+    <figcaption>
+      <b>Figure 4. </b>Unpublishing an app that has already been published and is
+      linked to a pricing template.
+    </figcaption>
+  </figure>
+</div>
+
+<p>
+  To unpublish a paid app that is already published and is linked to a template,
+  do the following:
+</p>
+
+<ol>
+  <li>
+    <a href="http://play.google.com/apps/publish">Log in</a> to your publisher
+    account.
+  </li>
+
+  <li>Select the app that you want to unpublish.
+  </li>
+
+  <li>Select <strong>Unpublish app</strong> (enclosed in a box within figure 4),
+  then choose <strong>Unpublish</strong> in the confirmation dialog that
+  appears.
+  </li>
+</ol>
+
+<h3 id="delete-pricing-template">
+  Deleting a pricing template
+</h3>
+
+<p>
+  If you no longer need a pricing template, you can delete it by completing the
+  following steps:
+</p>
+
+<ol>
+  <li>
+    <a href="http://play.google.com/apps/publish">Log in</a> to your publisher
+    account.
+  </li>
+
+  <li>In the <strong>Settings</strong> panel, open the <strong>Pricing
+  template</strong> page, which shows the list of pricing templates you have
+  created for your account.
+  </li>
+
+  <li>Select the pricing template that you wish to delete.
+  </li>
+
+  <li>On the pricing template's <em>Linked Items</em> tab, unlink all in-app
+  products that are linked to the template.</li>
+
+  <li>Select <strong>Delete template</strong>.
+  </li>
+</ol>
+
+<h2 id="billing-purchase-type">Choosing a Product Type</h3>
+
+<p>An item's product type controls how Google Play manages the purchase of the item. The supported
+product types include "managed product" and "subscription." Since support for different product
+types can vary among versions of the In-app Billing API, make sure that you choose a product
+type that's valid for the version of the In-app Billing API that your app uses. </p>
+
+<p>For details, refer to the documentation for the <a
+href="{@docRoot}google/play/billing/api.html#producttype">In-app Billing API</a>.
 
 <h2 id="billing-refunds">Handling Refunds</h2>
 
 <p>In-app billing does not allow users to send a refund request to Google Play. Refunds for
-in-app purchases must be directed to you (the application developer). You can then process the
+in-app purchases must be directed to you (the app developer). You can then process the
 refund through your Google payments merchant account. When you do this, Google Play receives a
 refund notification from Google payments, and Google Play sends a refund message to your
-application. For more information, see <a
+app. For more information, see <a
 href="{@docRoot}google/play/billing/v2/api.html#billing-action-notify">Handling
 IN_APP_NOTIFY messages</a> and <a
 href="http://support.google.com/googleplay/android-developer/bin/answer.py?hl=en&answer=1153485">
@@ -463,22 +774,22 @@
 <p>The Google Play Developer Console lets you set up one or more test accounts.
 A test account is a regular Google account that you register on the Developer
 Console as a test account. Test accounts are authorized to make in-app purchases
-from applications that you have uploaded to the Google Play Developer Console
+from apps that you have uploaded to the Google Play Developer Console
 but have not yet published.</p>
 
 <p>You can use any Google account as a test account. Test accounts are useful if you want to let
-multiple people test In-app Billing on applications without giving them access to your publisher
+multiple people test In-app Billing on apps without giving them access to your publisher
 account's sign-in credentials. If you want to own and control the test accounts, you can create the
 accounts yourself and distribute the credentials to your developers or testers.</p>
 
 <p>Test accounts have three limitations:</p>
 
 <ul>
-  <li>Test account users can make purchase requests only within applications that are already
-  uploaded to your publisher account (although the application doesn't need to be published).</li>
+  <li>Test account users can make purchase requests only within apps that are already
+  uploaded to your publisher account (although the app doesn't need to be published).</li>
   <li>Test accounts can only be used to purchase items that are listed (and published) in an
-  application's product list.</li>
-  <li>Test account users do not have access to your publisher account and cannot upload applications
+  app's product list.</li>
+  <li>Test account users do not have access to your publisher account and cannot upload apps
   to your publisher account.</li>
 </ul>
 
@@ -496,25 +807,29 @@
 <h3 id="license_key">Getting an app's license key</h3>
 
 <p>The Google Play Developer Console provides a public licensing key for each
-app. To get the key for an app, follow these steps:</p>
+app.</p>
+
+<p>To locate the key for an app, follow these steps:</p>
 <ol>
-  <li>Open the <strong>All Applications</strong> panel.</li>
-  <li>Click on the app name, then select <strong>Services &amp; APIs</strong>.</li>
-  <li>Scroll down to the <strong>Your License Key for this Application</strong>
-field to locate the key for the app, as shown in the figure below.</li>
+  <li>Open the <strong>All applications</strong> panel.</li>
+  <li>Click on the app name, then open the <strong>Services &amp; APIs</strong>
+  page.</li>
+  <li>Scroll down to the section of the page labeled Your License Key for This
+  Application, as shown in figure 5.</li>
 </ol>
 <p>Previously, the Developer Console provided a single public key per developer
 account. To transition apps to the new per-app public key, the Developer Console
-set the app-specific key as the former developer key. This ensures compatibility
+sets the app-specific key as the former developer key. This ensures compatibility
 for apps that depend on the (former) developer key. </p>
 
-<div style="margin:1em;">
-<img style="border:1px solid #ddd;padding-bottom:.5em" src="{@docRoot}images/in-app-billing/billing_app_key.png" xheight="510" id="figure4" />
-<p class="img-caption" style="padding-left:.5em;">
-  <strong>Figure 4.</strong> You can find the license key for each app in the
-  <strong>Services &amp; APIs</strong> panel.
-</p>
-</div>
+<figure id="fig-bak">
+  <img class="border-img" src="{@docRoot}images/in-app-billing/billing_app_key.png"
+  width="700" alt="">
+  <figcaption>
+    <b>Figure 5. </b>You can find the license key for each app on the
+    <strong>Services &amp; APIs</strong> page.
+  </figcaption>
+</figure>
 
 <h2 id="billing-support">Where to Get Support</h2>
 
diff --git a/docs/html/google/play/billing/billing_integrate.jd b/docs/html/google/play/billing/billing_integrate.jd
index c658f70..e666bc6 100755
--- a/docs/html/google/play/billing/billing_integrate.jd
+++ b/docs/html/google/play/billing/billing_integrate.jd
@@ -111,13 +111,13 @@
           <li>Select <strong>File > New > Directory</strong> and enter {@code aidl} in the
           <em>New Directory</em> window, then select <strong>OK</strong>.
 
-          <li>Select <strong>File > New > Package</strong> and enter 
+          <li>Select <strong>File > New > Package</strong> and enter
           {@code com.android.vending.billing} in the <em>New Package</em> window, then select
           <strong>OK</strong>.</li>
 
-          <li>Using your operating system file explorer, navigate to 
-          {@code &lt;sdk&gt;/extras/google/play_billing/}, copy the 
-          {@code IInAppBillingService.aidl} file, and paste it into the 
+          <li>Using your operating system file explorer, navigate to
+          {@code &lt;sdk&gt;/extras/google/play_billing/}, copy the
+          {@code IInAppBillingService.aidl} file, and paste it into the
           {@code com.android.vending.billing} package in your project.
           </li>
         </ol>
@@ -137,7 +137,7 @@
   </li>
 </ol>
 
-<h2 id="billing-permission">Updating Your Application's Manifest</h2>
+<h2 id="billing-permission">Updating Your App's Manifest</h2>
 
 <p>
   In-app billing relies on the Google Play application, which handles all
@@ -150,8 +150,8 @@
 </p>
 
 <p>
-  To give your app the necessary permission, add this line in your {@code
-  Android.xml} manifest file:
+  To give your app the necessary permission, add this line in the {@code
+  AndroidManifest.xml} file:
 </p>
 
 <pre>
diff --git a/docs/html/google/play/billing/billing_overview.jd b/docs/html/google/play/billing/billing_overview.jd
index cc56468..a05cc8d 100644
--- a/docs/html/google/play/billing/billing_overview.jd
+++ b/docs/html/google/play/billing/billing_overview.jd
@@ -122,7 +122,7 @@
 
 <h2 id="console">Google Play Developer Console</h2>
 <p>The Developer Console is where you can publish your
-In-app Billing application, and manage the various in-app products that are
+In-app Billing application and manage the various in-app products that are
 available for purchase from your application.</p>
 <p>You can create a product list of
 digital goods that are associated with your application, including items for
@@ -130,6 +130,14 @@
 information such as the item’s unique product ID (also called its SKU), product
 type, pricing, description, and how Google Play should handle and track
 purchases for that product.</p>
+<p>If you sell several of your apps or in-app products at the same price, you
+can add <em>pricing templates</em> to manage these price points from a
+centralized location. When using pricing templates, you can include local taxes
+within the prices you provide, or you can provide prices and have the system
+add local taxes to these prices. You can make changes to the prices in your
+pricing templates, such as refreshing the exchange rates for certain
+countries, and your changes are applied to the apps and in-app products
+that you link to the template.</p>
 <p>You can also create test accounts to authorize
 access for testing applications that are unpublished.</p>
 <p>To learn how to use the Developer Console to configure your in-app
diff --git a/docs/html/google/play/billing/billing_reference.jd b/docs/html/google/play/billing/billing_reference.jd
index 45ec785..95ab8e5 100644
--- a/docs/html/google/play/billing/billing_reference.jd
+++ b/docs/html/google/play/billing/billing_reference.jd
@@ -139,7 +139,8 @@
     <td>{@code price_amount_micros}</td>
     <td>Price in micro-units, where 1,000,000 micro-units equal one unit of the
     currency. For example, if {@code price} is {@code "€7.99"}, {@code
-    price_amount_micros} is {@code "7990000"}.</td>
+    price_amount_micros} is {@code "7990000"}. This value represents the
+    localized, rounded price for a particular currency.</td>
   </tr>
   <tr>
     <td>{@code price_currency_code}</td>
diff --git a/docs/html/google/play/billing/index.jd b/docs/html/google/play/billing/index.jd
index b2e9fe4..80934ae 100644
--- a/docs/html/google/play/billing/index.jd
+++ b/docs/html/google/play/billing/index.jd
@@ -14,6 +14,17 @@
 <div class="sidebox">
   <h2><strong>New in In-App Billing</strong></h2>
   <ul>
+  <li><strong>Rounded Pricing</strong>&mdash;After developers set prices for the
+    apps and in-app products that they distribute to multiple countries, the
+    system automatically sets local prices for different currencies using
+    today’s exchange rates and country-specific pricing patterns. To satisfy
+    particular pricing needs, developers can also adjust these prices manually.
+  </li>
+  <li><strong>Pricing Templates</strong>&mdash;Developers can add pricing
+    templates and link these templates to app prices or in-app product prices.
+    These templates include local prices across all markets. By using a
+    template, developers can apply price changes in bulk to all items linked to
+    that template.</li>
   <li><strong>In-app Promotions</strong>&mdash;Developers can create promo codes
     which users can redeem for content or features.</li>
   <li><strong>Prorated Subscription Prices</strong>&mdash;Content providers can
@@ -29,33 +40,13 @@
   <li><strong>Subscription Upgrade/Downgrade</strong>&mdash;A user can
     subscribe to a higher or lower tier of subscription while their current
     subscription is active. The old subscription is canceled, and the unused
-    portion is applied on a pro-rated basis to the new subscription.</li>
+    portion is applied on a prorated basis to the new subscription.</li>
   <li><strong>Manual Subscription Renewal</strong>&mdash;A user can purchase
     a subscription at the current rate while their existing subscription is
     still active. The existing subscription is extended by the appropriate
     period.</li>
   <li><strong>IAB Sandbox</strong>&mdash;The In-app Billing Sandbox now supports
     testing subscription purchases.</li>
-  <li><strong>As of January 2015, the In-App Billing v2 API is shut down.
-    If your app is still using In-app Billing
-    v2, please migrate to the v3 API as soon as possible.</strong></li>
-  <li><strong>Seasonal subscriptions</strong>&mdash;You can now set up a
-    recurring <a href="billing_subscriptions.html#user-billing">seasonal
-    subscription</a> that starts and ends on the same date each year (for
-    example, a sports subscription that starts every September 1 and ends every
-    April 10).</li>
-  <li><strong>Deferred subscription billing</strong>&mdash;You can
-    <a href="billing_subscriptions.html#deferred-billing">defer</a> a
-    subscriber's next billing date until the date you choose. The user still has
-    access to the content but is not charged during the deferral period.</li>
-  <li><strong>Weekly subscriptions</strong>&mdash;You can now set up a
-    recurring <a href="billing_subscriptions.html#user-billing">subscription</a>
-    that bills the user every week.</li>
-  <li><strong>Payment grace period</strong>&mdash;If a subscriber misses a
-    subscription payment due to an expired credit card, you can define a
-    <a href="billing_subscriptions.html#grace-period">grace period</a>
-    to the continue the subscription until payment is successful.</li>
-
  </ul>
 </div>
 </div>
@@ -101,5 +92,5 @@
     implementation.</dd>
   <dt><strong><a href="{@docRoot}google/play/billing/billing_admin.html">Administering
   In-app Billing</a></strong></dt>
-    <dd>Learn how to set up your product list, register test accounts, and handle refunds.</dd>
+    <dd>Learn how to set up your product list, add pricing templates, register test accounts, and handle refunds.</dd>
 </dl>
diff --git a/docs/html/guide/topics/admin/device-admin.jd b/docs/html/guide/topics/admin/device-admin.jd
index 45bd76a..e2fef04 100644
--- a/docs/html/guide/topics/admin/device-admin.jd
+++ b/docs/html/guide/topics/admin/device-admin.jd
@@ -48,11 +48,12 @@
 provided by the Device Administration API to provide stronger security for
 employee devices that are powered by Android.</p>
 
-<p class="note"><strong>Note</strong> For information on building a Work Policy
-Controller for Android for Work deployments, see <a
-href="{@docRoot}training/enterprise/work-policy-ctrl.html">Building a Work
-Policy Controller</a>.</p>
-
+<p class="note">
+  <strong>Note</strong> For information on building a Work Policy
+  Controller for Android for Work deployments, see
+  <a href="https://developers.google.com/android/work/build-dpc"
+  >Build a Device Policy Controller</a>.
+</p>
 
 <h2 id="overview">Device Administration API Overview</h2>
 
diff --git a/docs/html/images/in-app-billing/billing_add.png b/docs/html/images/in-app-billing/billing_add.png
deleted file mode 100644
index 1ca448d..0000000
--- a/docs/html/images/in-app-billing/billing_add.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/images/in-app-billing/billing_app_key.png b/docs/html/images/in-app-billing/billing_app_key.png
index bff8500..5adca9c 100644
--- a/docs/html/images/in-app-billing/billing_app_key.png
+++ b/docs/html/images/in-app-billing/billing_app_key.png
Binary files differ
diff --git a/docs/html/images/in-app-billing/billing_list_form_2.png b/docs/html/images/in-app-billing/billing_list_form_2.png
deleted file mode 100644
index 33f17c9..0000000
--- a/docs/html/images/in-app-billing/billing_list_form_2.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/images/in-app-billing/billing_product_list.png b/docs/html/images/in-app-billing/billing_product_list.png
deleted file mode 100644
index dabdcb9..0000000
--- a/docs/html/images/in-app-billing/billing_product_list.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/images/in-app-billing/delete_iap.png b/docs/html/images/in-app-billing/delete_iap.png
new file mode 100644
index 0000000..4603452
--- /dev/null
+++ b/docs/html/images/in-app-billing/delete_iap.png
Binary files differ
diff --git a/docs/html/images/in-app-billing/edit_local_prices.png b/docs/html/images/in-app-billing/edit_local_prices.png
new file mode 100644
index 0000000..2b76548
--- /dev/null
+++ b/docs/html/images/in-app-billing/edit_local_prices.png
Binary files differ
diff --git a/docs/html/images/in-app-billing/link_pricing_template.png b/docs/html/images/in-app-billing/link_pricing_template.png
new file mode 100644
index 0000000..cf762a8
--- /dev/null
+++ b/docs/html/images/in-app-billing/link_pricing_template.png
Binary files differ
diff --git a/docs/html/images/in-app-billing/unpublish_paid_app.png b/docs/html/images/in-app-billing/unpublish_paid_app.png
new file mode 100644
index 0000000..64bbd0d
--- /dev/null
+++ b/docs/html/images/in-app-billing/unpublish_paid_app.png
Binary files differ
diff --git a/docs/html/images/testing/test_framework.png b/docs/html/images/testing/test_framework.png
deleted file mode 100644
index fbc5fc2..0000000
--- a/docs/html/images/testing/test_framework.png
+++ /dev/null
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/3D-Image-viewer.gif b/docs/html/images/topic/instant-apps/3D-Image-viewer.gif
new file mode 100644
index 0000000..b46f2d9
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/3D-Image-viewer.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/BandH-Photo.gif b/docs/html/images/topic/instant-apps/BandH-Photo.gif
new file mode 100644
index 0000000..fa2cdfc
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/BandH-Photo.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/Buzzfeed.gif b/docs/html/images/topic/instant-apps/Buzzfeed.gif
new file mode 100644
index 0000000..af7cc66
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/Buzzfeed.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/Park-and-Pay.gif b/docs/html/images/topic/instant-apps/Park-and-Pay.gif
new file mode 100644
index 0000000..f5cbfb0
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/Park-and-Pay.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/instant-apps-section-2.png b/docs/html/images/topic/instant-apps/instant-apps-section-2.png
new file mode 100644
index 0000000..8060c57
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/instant-apps-section-2.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/instant-apps-section-4.png b/docs/html/images/topic/instant-apps/instant-apps-section-4.png
new file mode 100644
index 0000000..8e0fcf8
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/instant-apps-section-4.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/instant-apps-section-5.png b/docs/html/images/topic/instant-apps/instant-apps-section-5.png
new file mode 100644
index 0000000..e92ec80
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/instant-apps-section-5.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/play-services-features-2x.png b/docs/html/images/topic/instant-apps/play-services-features-2x.png
new file mode 100644
index 0000000..098f91c
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/play-services-features-2x.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/s3-BandH-animated.gif b/docs/html/images/topic/instant-apps/s3-BandH-animated.gif
new file mode 100644
index 0000000..4e44f74
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/s3-BandH-animated.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/s3-BandH-static.png b/docs/html/images/topic/instant-apps/s3-BandH-static.png
new file mode 100644
index 0000000..004afb7
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/s3-BandH-static.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/s3-BuzzFeed-animated.gif b/docs/html/images/topic/instant-apps/s3-BuzzFeed-animated.gif
new file mode 100644
index 0000000..7ed534e
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/s3-BuzzFeed-animated.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/s3-BuzzFeed-static.png b/docs/html/images/topic/instant-apps/s3-BuzzFeed-static.png
new file mode 100644
index 0000000..cdd0dc8
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/s3-BuzzFeed-static.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/s3-ParkandPay-animated.gif b/docs/html/images/topic/instant-apps/s3-ParkandPay-animated.gif
new file mode 100644
index 0000000..4a14dc2
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/s3-ParkandPay-animated.gif
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/s3-ParkandPay-static.png b/docs/html/images/topic/instant-apps/s3-ParkandPay-static.png
new file mode 100644
index 0000000..fa9c2bf
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/s3-ParkandPay-static.png
Binary files differ
diff --git a/docs/html/images/topic/instant-apps/upgrade-your-app-2x.png b/docs/html/images/topic/instant-apps/upgrade-your-app-2x.png
new file mode 100644
index 0000000..60fe373
--- /dev/null
+++ b/docs/html/images/topic/instant-apps/upgrade-your-app-2x.png
Binary files differ
diff --git a/docs/html/images/work/cards/android-studio_600px.png b/docs/html/images/work/cards/android-studio_600px.png
new file mode 100644
index 0000000..d2ce8d7
--- /dev/null
+++ b/docs/html/images/work/cards/android-studio_600px.png
Binary files differ
diff --git a/docs/html/images/work/cards/briefcase_600px.png b/docs/html/images/work/cards/briefcase_600px.png
new file mode 100644
index 0000000..9c30cf0
--- /dev/null
+++ b/docs/html/images/work/cards/briefcase_600px.png
Binary files differ
diff --git a/docs/html/images/work/cards/work-cloud_600px.png b/docs/html/images/work/cards/work-cloud_600px.png
new file mode 100644
index 0000000..9e63a0c
--- /dev/null
+++ b/docs/html/images/work/cards/work-cloud_600px.png
Binary files differ
diff --git a/docs/html/images/work/cards/work-devhub_600px.png b/docs/html/images/work/cards/work-devhub_600px.png
new file mode 100644
index 0000000..b63b917
--- /dev/null
+++ b/docs/html/images/work/cards/work-devhub_600px.png
Binary files differ
diff --git a/docs/html/images/work/cards/work-folder_600px.png b/docs/html/images/work/cards/work-folder_600px.png
new file mode 100644
index 0000000..1804d6f
--- /dev/null
+++ b/docs/html/images/work/cards/work-folder_600px.png
Binary files differ
diff --git a/docs/html/images/work/cards/work-profile_600px.png b/docs/html/images/work/cards/work-profile_600px.png
new file mode 100644
index 0000000..60284ff
--- /dev/null
+++ b/docs/html/images/work/cards/work-profile_600px.png
Binary files differ
diff --git a/docs/html/images/work/cosu-pinning_vs_locktaskmode.png b/docs/html/images/work/cosu-pinning_vs_locktaskmode.png
new file mode 100644
index 0000000..8fa470b
--- /dev/null
+++ b/docs/html/images/work/cosu-pinning_vs_locktaskmode.png
Binary files differ
diff --git a/docs/html/images/work/cosu-pinning_vs_locktaskmode_2x.png b/docs/html/images/work/cosu-pinning_vs_locktaskmode_2x.png
new file mode 100644
index 0000000..d7690f4
--- /dev/null
+++ b/docs/html/images/work/cosu-pinning_vs_locktaskmode_2x.png
Binary files differ
diff --git a/docs/html/images/work/guide-app-restrictions.png b/docs/html/images/work/guide-app-restrictions.png
new file mode 100644
index 0000000..83c2b42
--- /dev/null
+++ b/docs/html/images/work/guide-app-restrictions.png
Binary files differ
diff --git a/docs/html/images/work/guide-app-restrictions_2x.png b/docs/html/images/work/guide-app-restrictions_2x.png
new file mode 100644
index 0000000..4e64a1c
--- /dev/null
+++ b/docs/html/images/work/guide-app-restrictions_2x.png
Binary files differ
diff --git a/docs/html/images/work/guide-managed-overview.png b/docs/html/images/work/guide-managed-overview.png
new file mode 100644
index 0000000..caead68
--- /dev/null
+++ b/docs/html/images/work/guide-managed-overview.png
Binary files differ
diff --git a/docs/html/images/work/guide-managed-overview_2x.png b/docs/html/images/work/guide-managed-overview_2x.png
new file mode 100644
index 0000000..53518ad
--- /dev/null
+++ b/docs/html/images/work/guide-managed-overview_2x.png
Binary files differ
diff --git a/docs/html/images/work/hero_650px.png b/docs/html/images/work/hero_650px.png
new file mode 100644
index 0000000..5c790fa
--- /dev/null
+++ b/docs/html/images/work/hero_650px.png
Binary files differ
diff --git a/docs/html/images/work/hero_650px_2x.png b/docs/html/images/work/hero_650px_2x.png
new file mode 100644
index 0000000..d3e5049
--- /dev/null
+++ b/docs/html/images/work/hero_650px_2x.png
Binary files differ
diff --git a/docs/html/images/enterprise/work-launcher.png b/docs/html/images/work/work-launcher.png
similarity index 100%
rename from docs/html/images/enterprise/work-launcher.png
rename to docs/html/images/work/work-launcher.png
Binary files differ
diff --git a/docs/html/jd_collections.js b/docs/html/jd_collections.js
index 78776aa..4909206d 100644
--- a/docs/html/jd_collections.js
+++ b/docs/html/jd_collections.js
@@ -169,6 +169,22 @@
       "preview/features/tv-recording-api.html"
     ]
   },
+  "wear/preview/landing": {
+    "title": "",
+    "resources": [
+      "wear/preview/api-overview.html",
+      "wear/preview/downloads.html",
+      "wear/preview/start.html"
+    ]
+  },
+  "wear/preview/landing/resources": {
+    "title": "",
+    "resources": [
+      "wear/preview/features/complications.html",
+      "wear/preview/features/notifications.html",
+      "wear/preview/features/ui-nav-actions.html"
+    ]
+  },
   "google/landing/services": {
     "title": "",
     "resources": [
@@ -349,7 +365,7 @@
     "resources": [
       "https://www.android.com/work/",
       "https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
-      "training/enterprise/index.html"
+      "work/index.html"
     ]
   },
   "distribute/essentials": {
@@ -1741,26 +1757,6 @@
       "training/monitoring-device-state/index.html"
     ]
   },
-  "training/work/apps": {
-    "title": "",
-    "resources": [
-      "training/enterprise/app-compatibility.html",
-      "training/enterprise/app-restrictions.html",
-      "training/enterprise/cosu.html",
-      "https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
-      "samples/AppRestrictionSchema/index.html",
-      "https://www.youtube.com/watch?v=dH41OutAMNM",
-      "samples/AppRestrictionEnforcer/index.html"
-    ]
-  },
-  "training/work/admin": {
-    "title": "",
-    "resources": [
-      "training/enterprise/work-policy-ctrl.html",
-      "samples/BasicManagedProfile/index.html",
-      "https://www.youtube.com/watch?v=j3QC6hcpy90"
-    ]
-  },
 "tools/help/log": {
     "title": "",
     "resources": [
@@ -1879,4 +1875,45 @@
     "https://medium.com/google-developers/writing-more-code-by-writing-less-code-with-android-studio-live-templates-244f648d17c7#.hczcm02du",
     ]
   },
-}
+  "work/landing/primary": {
+    "title": "",
+    "resources": [
+      "work/overview.html",
+      "work/guide.html",
+      "https://www.google.com/work/android/developers/applyDevHub/",
+      "work/app-restrictions.html",
+      "work/cosu.html",
+      "work/managed-profiles.html"
+    ]
+  },
+  "work/landing/resources": {
+    "title": "",
+    "resources": [
+      "https://developers.google.com/android/work/",
+      "https://www.google.com/work/android/",
+      "https://developers.google.com/android/work/build-dpc",
+      "https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "https://www.youtube.com/watch?v=dH41OutAMNM&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX"
+    ]
+  },
+  "work/apps": {
+    "title": "",
+    "resources": [
+      "work/managed-profiles.html",
+      "work/app-restrictions.html",
+      "work/cosu.html",
+      "https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "samples/AppRestrictionSchema/index.html",
+      "samples/AppRestrictionEnforcer/index.html"
+    ]
+  },
+  "work/admin": {
+    "title": "",
+    "resources": [
+      "https://developers.google.com/android/work/build-dpc",
+      "samples/BasicManagedProfile/index.html",
+      "https://www.youtube.com/watch?v=j3QC6hcpy90"
+    ]
+  }
+};
diff --git a/docs/html/jd_extras.js b/docs/html/jd_extras.js
index e96fe7e..546fcfe 100644
--- a/docs/html/jd_extras.js
+++ b/docs/html/jd_extras.js
@@ -3283,19 +3283,55 @@
     "type":"distribute"
   },
   {
-    "title":"Android for Work",
+    "title":"Join the Android for Work DevHub",
     "titleFriendly":"",
-    "summary":"Learn more about how Android for Work makes your favorite phones and tablets the perfect business tools.",
-    "url":"https://www.android.com/work/",
+    "summary":"The Android for Work DevHub is a place to help developers keep up with Android in the workplace.",
+    "url":"https://www.google.com/work/android/developers/applyDevHub/",
+    "group":"",
+    "keywords": ["work", "enterprise", "isv", "devhub"],
+    "tags": [],
+    "image":"images/work/cards/work-devhub_600px.png",
+    "lang":"en",
+    "type":"Community"
+  },
+  {
+    "title":"Enterprise Mobility Managers",
+    "titleFriendly":"",
+    "summary":"Integrate Android for Work into your enterprise mobility management (EMM) solution.",
+    "url":"https://developers.google.com/android/work/",
     "group":"",
     "keywords": ["work", "enterprise", "emm"],
     "tags": [],
-    "image":"images/cards/card-android-work_2x.png",
+    "image":"images/work/cards/work-cloud_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Learn More About Android for Work",
+    "titleFriendly":"",
+    "summary":"Android for Work makes your favorite phones and tablets the perfect business tools.",
+    "url":"https://www.google.com/work/android/",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/work-profile_600px.png",
     "lang":"en",
     "type":"about"
   },
   {
-    "title":"Android for Work DevBytes",
+    "title":"Build a Device Policy Controller",
+    "titleFriendly":"",
+    "summary":"Create and administer a managed profile on an employee's device.",
+    "url":"https://developers.google.com/android/work/build-dpc",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/work-folder_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Android for Work for Developers",
     "titleFriendly":"",
     "summary":"Watch the videos in this playlist to understand more about Android for Work and get tips on developing enterprise apps.",
     "url":"https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
@@ -3319,10 +3355,10 @@
     "type":"youtube"
   },
   {
-    "title":"Building an enterprise ready app",
+    "title":"Building an Enterprise Ready App",
     "titleFriendly":"",
     "summary":"A holistic view of Android for Work for developers.",
-    "url":"https://www.youtube.com/watch?v=dH41OutAMNM",
+    "url":"https://www.youtube.com/watch?v=dH41OutAMNM&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
     "group":"",
     "keywords": ["work", "enterprise", "emm"],
     "tags": [],
@@ -3451,18 +3487,6 @@
     "type":"Video"
   },
   {
-    "title":"Android for Work: Single Use Devices",
-    "titleFriendly":"",
-    "summary":"Android M is bringing the power of Android to all kinds of workplaces.",
-    "url":"https://www.youtube.com/watch?v=j3QC6hcpy90",
-    "group":"",
-    "keywords": ["Marshmallow"],
-    "tags": [],
-    "image":"https://i1.ytimg.com/vi/j3QC6hcpy90/maxresdefault.jpg",
-    "lang":"en",
-    "type":"Video"
-  },
-  {
     "title":"Runtime Permissions in Android 6.0 Marshmallow",
     "titleFriendly":"",
     "summary":"Learn how to integrate runtime permissions into your Android app.",
diff --git a/docs/html/jd_extras_en.js b/docs/html/jd_extras_en.js
index 2aaaf2c..3aab5bd 100644
--- a/docs/html/jd_extras_en.js
+++ b/docs/html/jd_extras_en.js
@@ -237,7 +237,7 @@
     "title":"Test Your App",
     "summary":"This document describes key concepts related to Android app testing. It assumes you have a basic knowledge of the JUnit testing framework. Android testing is based on JUnit. In general, a JUnit test is a method whose statements test a part of the application\u2026",
     "url":"studio/test/index.html",
-    "image":"images/testing/test_framework.png",
+    "image":"studio/images/test/test-framework.png",
     "type":"studio",
     "keywords": [],
     "tags": [],
@@ -3231,19 +3231,127 @@
   },
   {
     "title":"Android for Work",
-    "category":"Enterprise",
-    "summary":"Learn more about how Android for Work makes your favorite phones and tablets the perfect business tools.",
-    "url":"https://www.android.com/work/",
+    "titleFriendly":"",
+    "summary": "Develop apps for Android for Work to take advantage of security and management features built into Android.",
+    "url":"https://developer.android.com/work",
     "group":"",
     "keywords": ["work", "enterprise", "emm"],
     "tags": [],
-    "image":"images/cards/card-android-work_2x.png",
+    "image":"images/work/cards/briefcase_600px.png",
+    "lang":"en",
+    "type":"work"
+  },
+  {
+    "title":"Android for Work Developer Overview",
+    "titleFriendly":"",
+    "summary": "Learn how to build Android apps for the enterprise and take advantage of Google's Android for Work program.",
+    "url":"https://developer.android.com/work/overview.html",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/briefcase_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Android for Work Developer Guide",
+    "titleFriendly":"",
+    "summary": "Android for Work provides organizations with a secure, flexible, and unified Android mobility platform combining devices, applications, and management.",
+    "url":"https://developer.android.com/work/guide.html",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/android-studio_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Set up App Restrictions",
+    "titleFriendly":"",
+    "summary": "Learn how to implement app restrictions and configuration settings that can be changed by other apps on the same device.",
+    "url":"https://developer.android.com/work/app-restrictions.html",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/briefcase_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Set up Managed Profiles",
+    "titleFriendly":"",
+    "summary": "Learn how to make sure your apps operate smoothly in a corporate environment by following some best practices.",
+    "url":"https://developer.android.com/work/managed-profiles.html",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/briefcase_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Set up Single-Purpose Devices",
+    "titleFriendly":"",
+    "summary": "Learn how to develop single-use solutions for Android devices.",
+    "url":"https://developer.android.com/work/cosu.html",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/briefcase_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Join the Android for Work DevHub",
+    "titleFriendly":"",
+    "summary":"The Android for Work DevHub is a place to help developers keep up with Android in the workplace.",
+    "url":"https://www.google.com/work/android/developers/applyDevHub/",
+    "group":"",
+    "keywords": ["work", "enterprise", "isv", "devhub"],
+    "tags": [],
+    "image":"images/work/cards/work-devhub_600px.png",
+    "lang":"en",
+    "type":"Community"
+  },
+  {
+    "title":"Enterprise Mobility Managers",
+    "titleFriendly":"",
+    "summary":"Integrate Android for Work into your enterprise mobility management (EMM) solution.",
+    "url":"https://developers.google.com/android/work/",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/work-cloud_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Learn More About Android for Work",
+    "titleFriendly":"",
+    "summary":"Learn more about how Android for Work makes your favorite phones and tablets the perfect business tools.",
+    "url":"https://www.google.com/work/android/",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/work-profile_600px.png",
     "lang":"en",
     "type":"about"
   },
   {
-    "title":"Android for Work DevBytes",
-    "category":"Enterprise",
+    "title":"Build a Device Policy Controller",
+    "titleFriendly":"",
+    "summary":"Learn how to develop a Device Policy Controller to create and administer a managed profile on an employee's device.",
+    "url":"https://developers.google.com/android/work/build-dpc",
+    "group":"",
+    "keywords": ["work", "enterprise", "emm"],
+    "tags": [],
+    "image":"images/work/cards/work-folder_600px.png",
+    "lang":"en",
+    "type":"guide"
+  },
+  {
+    "title":"Android for Work for Developers",
+    "titleFriendly":"",
     "summary":"Watch the videos in this playlist to understand more about Android for Work and get tips on developing enterprise apps.",
     "url":"https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
     "group":"",
@@ -3251,11 +3359,11 @@
     "tags": [],
     "image":"https://i1.ytimg.com/vi/jQWB_-o1kz4/maxresdefault.jpg",
     "lang":"en",
-    "type":"video"
+    "type":"youtube"
   },
   {
     "title":"App Configurations, Testing and Launchers",
-    "category":"Enterprise",
+    "titleFriendly":"",
     "summary":"With Android for Work you can make your apps remotely configurable. We also cover how to test your app in a managed environment.",
     "url":"https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
     "group":"",
@@ -3263,23 +3371,23 @@
     "tags": [],
     "image":"https://i1.ytimg.com/vi/39NkpWkaH8M/maxresdefault.jpg",
     "lang":"en",
-    "type":"video"
+    "type":"youtube"
   },
   {
-    "title":"Building an enterprise ready app",
-    "category":"Enterprise",
+    "title":"Building an Enterprise Ready App",
+    "titleFriendly":"",
     "summary":"A holistic view of Android for Work for developers.",
-    "url":"https://www.youtube.com/watch?v=dH41OutAMNM",
+    "url":"https://www.youtube.com/watch?v=dH41OutAMNM&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
     "group":"",
     "keywords": ["work", "enterprise", "emm"],
     "tags": [],
     "image":"https://i1.ytimg.com/vi/dH41OutAMNM/maxresdefault.jpg",
     "lang":"en",
-    "type":"video"
+    "type":"youtube"
   },
   {
     "title":"Android for Work: Single Use Devices",
-    "category":"Enterprise",
+    "titleFriendly":"",
     "summary":"Single-purpose computers are everywhere, and Android can meet that need.",
     "url":"https://www.youtube.com/watch?v=j3QC6hcpy90",
     "group":"",
@@ -3287,7 +3395,7 @@
     "tags": [],
     "image":"https://i1.ytimg.com/vi/j3QC6hcpy90/maxresdefault.jpg",
     "lang":"en",
-    "type":"video"
+    "type":"youtube"
   },
   {
     "title":"Discover YouTube cards",
@@ -3943,7 +4051,7 @@
     "resources": [
       "https://www.android.com/work/",
       "https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
-      "training/enterprise/index.html"
+      "work/index.html"
     ]
   },
   "distribute/essentials": {
@@ -4976,6 +5084,22 @@
       "training/wearables/ui/index.html"
     ]
   },
+  "wear/preview/landing": {
+    "title": "",
+    "resources": [
+      "wear/preview/api-overview.html",
+      "wear/preview/downloads.html",
+      "wear/preview/start.html"
+    ]
+  },
+  "wear/preview/landing/resources": {
+    "title": "",
+    "resources": [
+      "wear/preview/features/complications.html",
+      "wear/preview/features/notifications.html",
+      "wear/preview/features/ui-nav-actions.html"
+    ]
+  },
   "design/auto/auto_ui_guidelines": {
     "title": "",
     "resources": [
@@ -5105,26 +5229,6 @@
       "training/monitoring-device-state/index.html"
     ]
   },
-  "training/work/apps": {
-    "title": "",
-    "resources": [
-      "training/enterprise/app-compatibility.html",
-      "training/enterprise/app-restrictions.html",
-      "training/enterprise/cosu.html",
-      "https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
-      "samples/AppRestrictionSchema/index.html",
-      "https://www.youtube.com/watch?v=dH41OutAMNM",
-      "samples/AppRestrictionEnforcer/index.html"
-    ]
-  },
-  "training/work/admin": {
-    "title": "",
-    "resources": [
-      "training/enterprise/work-policy-ctrl.html",
-      "samples/BasicManagedProfile/index.html",
-      "https://www.youtube.com/watch?v=j3QC6hcpy90"
-    ]
-  },
 "tools/help/log": {
     "title": "",
     "resources": [
@@ -5279,6 +5383,47 @@
       "preview/features/picture-in-picture.html",
       "preview/features/tv-recording-api.html"
     ]
+  },
+  "work/landing/primary": {
+    "title": "",
+    "resources": [
+      "work/overview.html",
+      "work/guide.html",
+      "https://www.google.com/work/android/developers/applyDevHub/",
+      "work/app-restrictions.html",
+      "work/cosu.html",
+      "work/managed-profiles.html"
+    ]
+  },
+  "work/landing/resources": {
+    "title": "",
+    "resources": [
+      "https://developers.google.com/android/work/",
+      "https://www.google.com/work/android/",
+      "https://developers.google.com/android/work/build-dpc",
+      "https://www.youtube.com/watch?v=jQWB_-o1kz4&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "https://www.youtube.com/watch?v=dH41OutAMNM&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX"
+    ]
+  },
+  "work/apps": {
+    "title": "",
+    "resources": [
+      "work/managed-profiles.html",
+      "work/app-restrictions.html",
+      "work/cosu.html",
+      "https://www.youtube.com/watch?v=39NkpWkaH8M&index=2&list=PLOU2XLYxmsIKAK2Bhv19H2THwF-22O5WX",
+      "samples/AppRestrictionSchema/index.html",
+      "samples/AppRestrictionEnforcer/index.html"
+    ]
+  },
+  "work/admin": {
+    "title": "",
+    "resources": [
+      "https://developers.google.com/android/work/build-dpc",
+      "samples/BasicManagedProfile/index.html",
+      "https://www.youtube.com/watch?v=j3QC6hcpy90"
+    ]
   }
 };
 
diff --git a/docs/html/jd_tag_helpers.js b/docs/html/jd_tag_helpers.js
index 3ad3633..0ec0d67 100644
--- a/docs/html/jd_tag_helpers.js
+++ b/docs/html/jd_tag_helpers.js
@@ -15,6 +15,7 @@
   SAMPLES_RESOURCES,
   TOOLS_RESOURCES,
   TRAINING_RESOURCES,
+  WORK_RESOURCES,
   YOUTUBE_RESOURCES,
   BLOGGER_RESOURCES,
   PREVIEW_RESOURCES
@@ -74,6 +75,7 @@
   'tools': TOOLS_RESOURCES,
   'training': TRAINING_RESOURCES,
   'preview': PREVIEW_RESOURCES,
+  'work': WORK_RESOURCES,
   'youtube': YOUTUBE_RESOURCES,
   'blog': BLOGGER_RESOURCES
 };
@@ -112,4 +114,4 @@
     ALL_RESOURCES_BY_URL[url] = res;
   }
 }
-var IS_RESOURCE_IN_LANG = buildResourceLookupMap(ALL_RESOURCES_BY_LANG);
\ No newline at end of file
+var IS_RESOURCE_IN_LANG = buildResourceLookupMap(ALL_RESOURCES_BY_LANG);
diff --git a/docs/html/patience.jd b/docs/html/patience.jd
deleted file mode 100644
index e6ead5a..0000000
--- a/docs/html/patience.jd
+++ /dev/null
@@ -1,26 +0,0 @@
-page.title=Patience
-fullpage=true
-page.type=about
-nonavpage=true
-@jd:body
-
-
-<div class="landing-body-content">
-
-    <div class="landing-rest-of-page">
-      <div class="landing-section landing-white-background">
-        <div class="wrap">
-
-          <div class="landing-section-header">
-            <div class="landing-h1">Patience...</div>
-            <div class="landing-subhead">
-              This information is not yet available. Please check back later.
-            </div>
-          </div>
-
-        </div>  <!-- end .wrap -->
-      </div>  <!-- end .landing-section -->
-    </div>  <!-- end .landing-rest-of-page -->
-
-</div> <!-- end landing-body-content -->
-
diff --git a/docs/html/preview/api-overview.jd b/docs/html/preview/api-overview.jd
index 4a7b879..ab2b5ba2 100644
--- a/docs/html/preview/api-overview.jd
+++ b/docs/html/preview/api-overview.jd
@@ -9,35 +9,39 @@
 
 <div id="qv-wrapper">
 <div id="qv">
-  <h2>Key developer features</h2>
+  <h2>Key Developer Features</h2>
   <ol>
       <ul style="list-style-type:none;">
-        <li><a href="#multi-window_support">Multi-window support</a></li>
+        <li><a href="#multi-window_support">Multi-window Support</a></li>
         <li><a href="#notification_enhancements">Notifications</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="#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="#data_saver">Data Saver</a></li>
         <li><a href="#vulkan">Vulkan API</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="#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="#emoji">New Emojis</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_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>
-        <li><a href="#launcher_shortcuts">Launcher shortcuts</a></li>
-        <li><a href="#print_svc">Print service enhancements</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>
+        <li><a href="#keyboard_shortcuts_helper">Keyboard Shortcuts Helper</a></li>
+        <li><a href="#sustained_performance_api">Sustained Performance API</a></li>
+        <li><a href="#vr">VR Support</a></li>
+        <li><a href="#print_svc">Print Service Enhancements</a></li>
         <li><a href="#virtual_files">Virtual Files</a></li>
+        <li><a href="#framemetrics_api">FrameMetricsListener API</a></li>
       </ol>
 </div>
 </div>
@@ -57,7 +61,7 @@
   new APIs.
 </p>
 
-<h2 id="multi-window_support">Multi-window support</h2>
+<h2 id="multi-window_support">Multi-window Support</h2>
 
 
 <p>In Android N, we're introducing a new and much-requested multitasking feature
@@ -82,6 +86,7 @@
 <p class="img-caption">
   <strong>Figure 1.</strong> Apps running in split-screen mode.
 </p>
+
   </div>
 
 <p>Especially on tablets and other larger-screen devices, multi-window support
@@ -101,7 +106,7 @@
   developer documentation.
 </p>
 
-<h2 id="notification_enhancements">Notification enhancements</h2>
+<h2 id="notification_enhancements">Notification Enhancements</h2>
 
 <p>In Android N we've redesigned notifications to make them easier and faster to
 use. Some of the changes include:</p>
@@ -114,6 +119,13 @@
   </li>
 
   <li>
+    <strong>Message style customization</strong>: You can customize more of the
+    user interface labels associated with your notifications using the
+    <code>MessageStyle</code> class. You can configure the message, conversation
+    title, and content view.
+  </li>
+
+  <li>
     <strong>Bundled notifications</strong>: The system can group messages
     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
@@ -160,7 +172,7 @@
 
 
 
-<h2 id="jit_aot">Profile-guided JIT/AOT compilation</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
@@ -182,14 +194,14 @@
 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>
+<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>
+<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
@@ -227,7 +239,7 @@
 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>
+<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
@@ -347,7 +359,7 @@
 
 <p>
   Vulkan is only available to apps on devices with Vulkan-capable hardware,
-  such as Nexus 5X and Nexus 6P. We're working closely with our
+  such as Nexus 5X, Nexus 6P, and Nexus Player. We're working closely with our
   partners to bring Vulkan to more devices as soon as possible.
 </p>
 
@@ -391,22 +403,22 @@
 </p>
 
 <p>
-  For information about creating an app tile, see the
+  For information about creating an app tile, see the documentation for
   <code>android.service.quicksettings.Tile</code> in the downloadable <a href=
   "{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
 </p>
 
 
 
-<h2 id="number-blocking">Number-blocking</h2>
+<h2 id="number-blocking">Number Blocking</h2>
 
-<p>Android N now supports number-blocking in the platform and provides a
+<p>Android N now supports number blocking in the platform and provides a
 framework API to let service providers maintain a blocked-number list. The
 default SMS app, the default phone app, and carrier apps can read from and
 write to the blocked-number list. The list is not accessible to other apps.</p>
 
-<p>By making number-blocking a standard feature of the platform, Android provides
-a consistent way for apps to support number-blocking across a wide range of
+<p>By making number blocking a standard feature of the platform, Android provides
+a consistent way for apps to support number blocking across a wide range of
 devices. Among the other benefits that apps can take advantage of are:</p>
 
 <ul>
@@ -427,7 +439,7 @@
   Reference</a>.
 </p>
 
-<h2 id="call_screening">Call screening</h2>
+<h2 id="call_screening">Call Screening</h2>
 
 <p>
   Android N allows the default phone app to screen incoming calls. The phone
@@ -449,7 +461,7 @@
 </p>
 
 
-<h2 id="multi-locale_languages">Multi-locale support, more languages</h2>
+<h2 id="multi-locale_languages">Multi-locale Support, More Languages</h2>
 
 
 <p>Android N now lets users select <strong>multiple locales</strong> in Settings,
@@ -464,14 +476,58 @@
 languages such as English, Spanish, French, and Arabic. It also adds partial
 support for more than 100 new languages.</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
+<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="emoji">New Emojis</h2>
+
+<p>
+  Android N introduces additional emojis and emoji-related features including
+  skin tone emojis and support for variation
+  selectors. If your app supports emojis,
+  follow the guidelines below to take advantage of these emoji-related features.
+</p>
+
+<ul>
+  <li>
+    <strong>Check that a device contains an emoji before inserting it.</strong>
+    To check which emojis are present in the
+    system font, use the {@link android.graphics.Paint#hasGlyph(String)} method.
+  </li>
+  <li>
+    <strong>Check that an emoji supports variation selectors.</strong>
+    Variation selectors allow you to
+    present certain emojis in color or in black-and-white.
+    On mobile devices, apps should represent emojis in color rather than black-and-white. However,
+    if your app displays emojis inline with text, then it should use the black-and-white variation.
+    To determine whether an emoji has a variation, use the variation selector.
+    For a complete list of characters with variations, review the
+    <em>emoji variation sequences</em> section of the
+    <a class="external-link"
+    href="http://www.unicode.org/Public/9.0.0/ucd/StandardizedVariants-9.0.0d1.txt">
+      Unicode documentation on variations</a>.
+  </li>
+  <li>
+    <strong>Check that an emoji supports skin tone.</strong> Android N allows users to modify the
+    rendered skin tone of emojis to their preference. Keyboard apps should provide visual
+    indications for emojis that have multiple skin tones and should allow users to
+    select the skin tone that they prefer. To determine which system emojis have
+    skin tone modifiers, use the {@link android.graphics.Paint#hasGlyph(String)}
+    method. You can determine which emojis use skin tones by reading the
+    <a class="external-link"
+    href="http://unicode.org/emoji/charts/full-emoji-list.html">
+     Unicode documentation</a>.
+  </li>
+</ul>
+
+
 <h2 id="icu4">ICU4J APIs in Android</h2>
 
 <p>
@@ -497,7 +553,8 @@
 
 <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>.
+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.
@@ -513,7 +570,7 @@
 href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL ES API guide</a>.</p>
 
 
-<h2 id="android_tv_recording">Android TV recording</h2>
+<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
@@ -596,7 +653,7 @@
   customizes the flow with a corporate logo.
 </p>
 
-<h2 id="accessibility_enhancements">Accessibility enhancements</h2>
+<h2 id="accessibility_enhancements">Accessibility Enhancements</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
@@ -614,15 +671,15 @@
 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>
+  in the downloadable <a href="{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.</p>
 
 
-<h2 id="direct_boot">Direct boot</h2>
+<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
+registered alarms, messages and incoming calls can now continue to notify
 the user as normal. This also means accessibility services can also be
   available immediately after a restart.</p>
 
@@ -722,22 +779,58 @@
 <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>
+<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>
+  Android N introduces APK Signature Scheme v2, a new app-signing scheme that
+  offers faster app install times and more protection against unauthorized
+  alterations to APK files. By default, Android Studio 2.2 and the Android
+  Plugin for Gradle 2.2 sign your app using both APK Signature Scheme v2 and
+  the traditional signing scheme, which uses JAR signing.
+</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>
+  Although we recommend applying APK Signature Scheme v2 to your app, this new
+  scheme is not mandatory. If your app doesn't build properly when using APK
+  Signature Scheme v2, you can disable the new scheme. The disabling process
+  causes Android Studio 2.2 and the Android Plugin for Gradle 2.2 to sign your
+  app using only the traditional signing scheme. To sign with only the
+  traditional scheme, open the module-level <code>build.gradle</code> file, then
+  add the line <code>v2SigningEnabled false</code> to your release signing
+  configuration:
+</p>
 
-<p>APK signature scheme v2 support will be available later in the N Developer
-Preview.</p>
+<pre>
+  android {
+    ...
+    defaultConfig { ... }
+    signingConfigs {
+      release {
+        storeFile file("myreleasekey.keystore")
+        storePassword "password"
+        keyAlias "MyReleaseKey"
+        keyPassword "password"
+        <strong>v2SigningEnabled false</strong>
+      }
+    }
+  }
+</pre>
 
-<h2 id="scoped_directory_access">Scoped directory access</h2>
+<p class="caution"><strong>Caution: </strong> If you sign your app using APK
+  Signature Scheme v2 and make further changes to the app, the app's signature
+  is invalidated. For this reason, use tools such as <code>zipalign</code>
+  before signing your app using APK Signature Scheme v2, not after.
+</p>
+
+<p>
+  For more information, read the Android Studio documents that describe how to
+  <a href="{@docRoot}studio/publish/app-signing.html#release-mode">
+  sign an app</a> in Android Studio and how to <a href=
+  "{@docRoot}studio/build/build-variants.html#signing"> configure
+  the build file for signing apps</a> using the Android Plugin for Gradle.
+</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
@@ -758,62 +851,62 @@
 <a href="{@docRoot}preview/features/scoped-folder-access.html">Scoped
 Directory Access</a> developer documentation.</p>
 
-<h2 id="launcher_shortcuts">
-  Launcher shortcuts
-</h2>
+<h2 id="keyboard_shortcuts_helper">Keyboard Shortcuts Helper</h2>
 
 <p>
-  Android N allows apps to define action-specific shortcuts which can be
-  displayed in the launcher. These <em>launcher shortcuts</em> let your users
-  quickly start common or recommended tasks within your app. Each shortcut
-  contains an <a href=
-  "{@docRoot}guide/components/intents-filters.html">intent</a>, which links the
-  shortcut to a specific action in your app. Examples of these actions include:
-</p>
-
-<ul>
-  <li>Navigating users to a particular location in a mapping app.
-  </li>
-
-  <li>Sending messages to a friend in a communication app.
-  </li>
-
-  <li>Playing the next episode of a TV show in a media app.
-  </li>
-
-  <li>Loading the last save point in a gaming app.
-  </li>
-</ul>
-
-<p>
-  Your app can create up to five <em>dynamic shortcuts</em>. When users perform
-  a gesture over your app's launcher icon, these shortcuts appear. By dragging
-  the shortcuts onto the launcher, users can make persistent copies of the
-  shortcuts, called <em>pinned shortcuts</em>. Users can create an unlimited
-  number of pinned shortcuts for each app.
-</p>
-
-<p class="note">
-  <strong>Note:</strong> Although other apps can't access your shortcut data,
-  the launcher <strong>does</strong> have access to this data. Therefore, the
-  shortcuts you create should conceal sensitive user information.
+In Android N, the user can press "Alt + /" to trigger a <em>Keyboard Shortcuts</em>
+screen that displays all shortcuts available both from the system and from
+the app in focus. These are retrieved automatically from the app’s menu if
+available, but developers can provide their own fine-tuned shortcuts lists
+for the screen. You can do this by overriding the new
+<code>Activity.onProvideKeyboardShortcuts()</code> method, described in the downloadable
+<a href="{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
 </p>
 
 <p>
-  You can use this command to view your app's shortcuts:
+To trigger the Keyboard Shortcuts Helper from anywhere in your app,
+call {@code Activity.requestKeyboardShortcutsHelper()} for the relevant activity.
 </p>
 
-<pre class="no-pretty-print">
-$ adb shell dumpsys shortcut
-</pre>
+<h2 id="sustained_performance_api">Sustained Performance API</h2>
 
 <p>
-  To update all shortcuts and to delete dynamic shortcuts, use the appropriate
-  methods that the Launcher Shortcut API provides. For more details about this
-  API, see <code>android.content.pm.ShortcutManager</code> in the downloadable
-  <a href="{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
+Performance can fluctuate dramatically for long-running apps, because the
+system throttles system-on-chip engines as device components reach their
+temperature limits. This fluctuation presents a moving target for app
+developers creating high-performance, long-running apps.
 </p>
 
+<p>
+To address these limitations, Android N includes support for
+<em>sustained performance mode</em>, enabling OEMs to provide hints about
+device-performance capabilities for long-running apps. App developers
+can use these hints to tune apps for a predictable,
+consistent level of device performance over long periods of time.
+</p>
+
+<p>
+App developers can try out this new API in the N Developer Preview on
+Nexus 6P devices only. To use this feature,
+set the sustained performance window flag for the window
+you want to run in sustained performance mode. Set this flag using the
+{@code Window.setSustainedPerformanceMode()} method. The system automatically
+disables this mode when the window is no longer in focus.
+</p>
+
+<h2 id="vr">VR Support</h2>
+
+<p>
+Android N adds platform support and optimizations for a new VR Mode to let developers
+build high-quality mobile VR experiences for users. There are a number of performance
+enhancements, including access to an exclusive CPU core for VR apps.
+Within your apps, you can take advantage of intelligent head-tracking,
+and stereo notifications that work for VR. Most importantly, Android N provides for
+very low latency graphics. For complete information about building VR apps for Android N,
+see the <a href="https://developers.google.com/vr/android/">Google VR SDK for Android</a>.
+</p>
+
+
 <h2 id="print_svc">Print Service Enhancements</h2>
 
 <p>
@@ -855,6 +948,46 @@
   "{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
 </p>
 
+<h2 id="framemetrics_api">FrameMetricsListener API</h2>
+
+<p>
+The FrameMetricsListener API allows an app to monitor its UI rendering
+performance. The API provides this capability by exposing a streaming Pub/Sub API to transfer frame
+timing info for the app's current window. The data returned is
+equivalent to that which <code><a href="{@docRoot}tools/help/shell.html#shellcommands">adb shell</a>
+dumpsys gfxinfo framestats</code> displays, but is not limited to the past 120 frames.
+</p>
+
+<p>
+You can use FrameMetricsListener to measure interaction-level UI
+performance in production, without a USB connection. This API
+allows collection of data at a much higher granularity than does
+{@code adb shell dumpsys gfxinfo}. This higher granularity is possible because
+the system can collect data for particular interactions in the app; the system
+need not capture a global summary of the entire app’s
+performance, or clear any global state. You can use this
+capability to gather performance data and catch regressions in UI performance
+for real use cases within an app.
+</p>
+
+<p>
+To monitor a window, implement the <code>FrameMetricsListener.onMetricsAvailable()</code>
+callback method and register it on that window. For more information, refer to
+the {@code FrameMetricsListener} class documentation in
+the downloadable <a href="{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
+</p>
+
+<p>
+The API provides a {@code FrameMetrics} object, which contains timing data that
+the rendering subsystem reports for various milestones in a frame lifecycle.
+The supported metrics are: {@code UNKNOWN_DELAY_DURATION},
+{@code INPUT_HANDLING_DURATION}, {@code ANIMATION_DURATION},
+{@code LAYOUT_MEASURE_DURATION}, {@code DRAW_DURATION}, {@code SYNC_DURATION},
+{@code COMMAND_ISSUE_DURATION}, {@code SWAP_BUFFERS_DURATION},
+{@code TOTAL_DURATION}, and {@code FIRST_DRAW_FRAME}.
+</p>
+
+
 <h2 id="virtual_files">Virtual Files</h2>
 
 <p>
@@ -936,4 +1069,4 @@
   For more information about accessing user files, see the
   <a href="{@docRoot}guide/topics/providers/document-provider.html">Storage
   Access Frameworks guide</a>.
-</p>
\ No newline at end of file
+</p>
diff --git a/docs/html/preview/behavior-changes.jd b/docs/html/preview/behavior-changes.jd
index b6b2ee6..66dce7a 100644
--- a/docs/html/preview/behavior-changes.jd
+++ b/docs/html/preview/behavior-changes.jd
@@ -20,6 +20,7 @@
   </li>
   <li><a href="#perm">Permissions Changes</a>
   </li>
+  <li><a href="#sharing-files">Sharing Files Between Apps</a></li>
   <li><a href="#accessibility">Accessibility Improvements</a>
     <ol>
       <li><a href="#screen-zoom">Screen Zoom</a></li>
@@ -55,14 +56,13 @@
 </p>
 
 
-<h2 id="perf">Performance Improvements</h2>
+<h2 id="perf">Battery and Memory</h2>
 
 <p>
-  Android N contains system behavior changes aimed at improving the battery
-  life of devices, RAM usage, and app performance. These changes can impact the
-  availability of system resources and system notifications to your app. You
-  should review these changes and evaluate how your app may need to adjust to
-  them.
+Android N includes system behavior changes aimed at improving the battery life
+of devices and reducing RAM usage. These changes can affect your app’s access to
+system resources, along with the way your app interacts with other apps via
+certain implicit intents.
 </p>
 
 <h3 id="doze">Doze</h3>
@@ -138,7 +138,7 @@
 </p>
 
 <p>
-  Similarly, apps can register to receive implicit {@link
+  Similarly, in previous versions of Android, apps could register to receive implicit {@link
   android.hardware.Camera#ACTION_NEW_PICTURE} and {@link
   android.hardware.Camera#ACTION_NEW_VIDEO} broadcasts from other apps, such as
   Camera. When a user takes a picture with the Camera app, these apps wake up
@@ -244,6 +244,23 @@
   </li>
 </ul>
 
+<h2 id="sharing-files">Sharing Files Between Apps</h2>
+
+<p>
+For apps targeting Android N, the Android framework enforces
+the {@link android.os.StrictMode} API policy that prohibits exposing {@code file://} URIs
+outside your app. If an intent containing a file URI leaves your app, the app fails
+with a {@code FileUriExposedException} exception.
+</p>
+
+<p>
+To share files between applications, you should send a {@code content://} URI
+and grant a temporary access permission on the URI. The easiest way to grant this permission is by
+using the {@link android.support.v4.content.FileProvider} class. For more information
+on permissions and sharing files,
+see <a href="{@docRoot}training/secure-file-sharing/index.html">Sharing Files</a>.
+</p>
+
 <h2 id="accessibility">Accessibility Improvements</h2>
 
 <p>
@@ -474,7 +491,7 @@
   running in device owner mode, the <code>DISALLOW_ADD_USER</code> restriction
   is automatically set. This prevents users from creating unmanaged secondary
   users. In addition, the <code>CreateUser()</code> and
-  <code>createAndInitial()</code> methods are deprecated; the new
+  <code>createAndInitializeUser()</code> methods are deprecated; the new
   <code>DevicePolicyManager.createAndManageUser()</code> method replaces them.
   </li>
 
@@ -483,6 +500,10 @@
   <code>DevicePolicyManagewr.getWifiMacAddress()</code>. If Wi-Fi has never
   been enabled on the device, this method returns a value of {@code null}.
   </li>
+
+  <li>The Work Mode setting controls access to work apps. When work mode is off the
+  system launcher indicates work apps are unavailable by greying them out. Enabling
+  work mode again restores normal behavior.
 </ul>
 
 <p>
@@ -563,5 +584,33 @@
 which causes {@code ActivityThread.StopInfo} to throw a
 {@code RuntimeException} when your app targets Android N.
 </li>
+
+<li>
+If an app posts {@link java.lang.Runnable} tasks to a {@link android.view.View}, and
+the {@link android.view.View}
+is not attached to a window, the system
+queues the {@link java.lang.Runnable} task with the {@link android.view.View};
+the {@link java.lang.Runnable} task does not execute until the
+{@link android.view.View} is attached
+to a window. This behavior fixes the following bugs:
+<ul>
+   <li>If an app posted to a {@link android.view.View} from a thread other than the intended
+   window’s UI thread, the {@link java.lang.Runnable} may run on the wrong thread as a result.
+   </li>
+   <li>If the {@link java.lang.Runnable} task was posted from a thread other than
+   a looper thread, the app could expose the {@link java.lang.Runnable} task.</li>
+</ul>
+</li>
+
+<li>
+If an app on Android N with
+{@link android.Manifest.permission#DELETE_PACKAGES DELETE_PACKAGES}
+permission tries to delete a package, but a different app had installed that package,
+the system requires user confirmation. In this scenario, apps should expect
+{@link android.content.pm.PackageInstaller#STATUS_PENDING_USER_ACTION STATUS_PENDING_USER_ACTION}
+as the return status when they invoke
+{@link android.content.pm.PackageInstaller#uninstall PackageInstaller.uninstall()}.
+</li>
+
 </ul>
 
diff --git a/docs/html/preview/download-ota.jd b/docs/html/preview/download-ota.jd
index 7e70f57..2058501 100644
--- a/docs/html/preview/download-ota.jd
+++ b/docs/html/preview/download-ota.jd
@@ -203,72 +203,72 @@
   <tr id="bullhead">
     <td>Nexus 5X <br>"bullhead"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >bullhead-ota-npc91k-dfcbfda0.zip</a><br>
-      MD5: af537dc0c06e85f32a929c10aaf12e0a<br>
-      SHA-1: 12a32b09223eb8f98bc0f0f05d951789d5fbe12e
+      >bullhead-ota-npd35k-b8cfbd80.zip</a><br>
+      MD5: 15fe2eba9b01737374196bdf0a792fe9<br>
+      SHA-1: 5014b2bba77f9e1a680ac3f90729621c85a14283
     </td>
   </tr>
 
   <tr id="shamu">
     <td>Nexus 6 <br>"shamu"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >shamu-ota-npc91k-201dd8d1.zip</a><br>
-      MD5: 016d60b4734151ca70d977c04d737487<br>
-      SHA-1: 09ca7c0712366c53e61abb7a6142ce703e2ac62c
+      >shamu-ota-npd35k-078e6fa5.zip</a><br>
+      MD5: e8b12f7721c53af9a450f7058928a5fc<br>
+      SHA-1: b7a9b756f84a1d2e482ff9c16749d65f6e51425a
     </td>
   </tr>
 
   <tr id="angler">
     <td>Nexus 6P <br>"angler"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >angler-ota-npc91k-7399f083.zip</a><br>
-      MD5: eacc5307ef4f00ba4b61ac9c1620def9<br>
-      SHA-1: 6a9f36cad4bd8fd63e7719c00e0b75bd991614ff
+      >angler-ota-npd35k-88457699.zip</a><br>
+      MD5: 3fac09fef759dde26e57cb80b20b6477<br>
+      SHA-1: 27d6caa786577d8a38b2da5bf94b33b4524a1a1c
     </td>
   </tr>
 
   <tr id="volantis">
     <td>Nexus 9 <br>"volantis"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >volantis-ota-npc91k-42fc9c84.zip</a><br>
-      MD5: e1f3f5504aa3389ef4fbac7ac42a995f<br>
-      SHA-1: 1e49e2867479ad1a1c58f52584c62575bb9c2c3b
+      >volantis-ota-npd35k-51dbae76.zip</a><br>
+      MD5: 58312c4a5971818ef5c77a3f446003da<br>
+      SHA-1: aad9005be33d3e2bab480509a6ab74c3c3b9d921
     </td>
   </tr>
 
   <tr id="volantisg">
     <td>Nexus 9G <br>"volantisg"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >volantisg-ota-npc91k-4aa98b9f.zip</a><br>
-      MD5: ad2e60aa9b1a063f906eb8904388e5f8<br>
-      SHA-1: 4edfa8ab5d2d02ec46afffce62466aa715420558
+      >volantisg-ota-npd35k-834f047f.zip</a><br>
+      MD5: 92b7d1fa252f7394e70f957c72d4aac8<br>
+      SHA-1: b6c057c84d90893630e303cbb60530e20ddb8361
     </td>
   </tr>
 
   <tr id="fugu">
     <td>Nexus Player <br>"fugu"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >fugu-ota-npc91o-b1d73dd5.zip</a><br>
-      MD5: d7fbccde75e0b6d860102320ea76d58f<br>
-      SHA-1: b1d73dd5a6498fb6c66e022bd0a6c8b6a6a2374b
+      >fugu-ota-npd35k-6ac91298.zip</a><br>
+      MD5: 1461622ad53ea842b2722fa7b49b8172<br>
+      SHA-1: 409c061668ab270774877d7f3eae44fa48d2b931
     </td>
   </tr>
 
   <tr id="ryu">
     <td>Pixel C <br>"ryu"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >ryu-ota-npc91k-80971fa8.zip</a><br>
-      MD5: 9d66ca3c5673586bb5ade9fdda6fb924<br>
-      SHA-1: 329209b6f1ee08a29e4be32139672a30901a19b7
+      >ryu-ota-npd35k-a0b2347f.zip</a><br>
+      MD5: c60117f3640cc6db12386fd632289c7d<br>
+      SHA-1: 87349c767c69efb4172c90ce1d88cf578c3d28b3
     </td>
   </tr>
 
   <tr id="seed">
     <td>General Mobile 4G (Android One) <br>"seed"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >seed_l8150-ota-npc91k-8e8c8777.zip</a><br>
-      MD5: d21d417d7b5525633b5f7bcfa8b23245<br>
-      SHA-1: bfe42c7e291ca667d3f4d7c80825e5cf8830fc9a
+      >seed_l8150-ota-npd35k-09897a1d.zip</a><br>
+      MD5: a55cf94f7cce0393ec6c0b35041766b7<br>
+      SHA-1: 6f33742290eb46f2561891f38ca2e754b4e50c6a
     </td>
   </tr>
 
diff --git a/docs/html/preview/download.jd b/docs/html/preview/download.jd
index 480e32b..b5405c7 100644
--- a/docs/html/preview/download.jd
+++ b/docs/html/preview/download.jd
@@ -302,72 +302,72 @@
   <tr id="bullhead">
     <td>Nexus 5X <br>"bullhead"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >bullhead-npc91k-factory-d09b15b5.tgz</a><br>
-      MD5: f5aa4b0b10213435569ed4833dd973f8<br>
-      SHA-1: d09b15b5f8978e2fee3fbd799554de90b7012d64
+      >bullhead-npd35k-factory-5ba40535.tgz</a><br>
+      MD5: b6c5d79a21815ee21db41822dcf61e9f<br>
+      SHA-1: 5ba4053577007d15c96472206e3a79bc80ab194c
     </td>
   </tr>
 
   <tr id="shamu">
     <td>Nexus 6 <br>"shamu"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >shamu-npc91k-factory-7c9936dc.tgz</a><br>
-      MD5: 271b758d01f61cdef71a3e4c14e90e85<br>
-      SHA-1: 7c9936dca492dd9a5b279612962e3439031fcc06
+      >shamu-npd35k-factory-a33bf20c.tgz</a><br>
+      MD5: e1cf9c57cfb11bebe7f1f5bfbf05d7ab<br>
+      SHA-1: a33bf20c719206bcf08d1edd8da6c0ff9d50f69c
     </td>
   </tr>
 
   <tr id="angler">
     <td>Nexus 6P <br>"angler"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >angler-npc91k-factory-dcd13c44.tgz</a><br>
-      MD5: 3f304dc1d5044768af26c8503d3fbf18<br>
-      SHA-1: dcd13c44e7254916fcf7cb7fa31e0dc03737a3f5
+      >angler-npd35k-factory-81c341d5.tgz</a><br>
+      MD5: e93de7949433339856124c3729c15ebb<br>
+      SHA-1: 81c341d57ef2cd139569b055d5d59e9e592a7abd
     </td>
   </tr>
 
   <tr id="volantis">
     <td>Nexus 9 <br>"volantis"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >volantis-npc91k-factory-ed835af7.tgz</a><br>
-      MD5: 466a9873111a320e5a19891de61e5609<br>
-      SHA-1: ed835af7bebf26d4c12b5c30c8b1a337c06c9623
+      >volantis-npd35k-factory-2b50e19d.tgz</a><br>
+      MD5: 565be87ebb2d5937e2abe1a42645864b<br>
+      SHA-1: 2b50e19dae2667b27f911e3c61ed64860caf43e1
     </td>
   </tr>
 
   <tr id="volantisg">
     <td>Nexus 9G <br>"volantisg"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >volantisg-npc91k-factory-6f20b9f6.tgz</a><br>
-      MD5: 419f76cdf886b18d2e7281915b9c77b0<br>
-      SHA-1: 6f20b9f6b0d77dc17793db32cd2da5a0b0aa63c9
+      >volantisg-npd35k-factory-2e89ebe6.tgz</a><br>
+      MD5: a8464e15c6683fe2afa378a63e205fda<br>
+      SHA-1: 2e89ebe67a46b2f3beb050746c13341cd11fa678
     </td>
   </tr>
 
   <tr id="fugu">
     <td>Nexus Player <br>"fugu"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >fugu-npc91o-factory-3b8e3f56.tgz</a><br>
-      MD5: b88b70ecbfb80c983c90b97cb243628b<br>
-      SHA-1: 3b8e3f56a4c35b559783c2928e740df2aab8b377
+      >fugu-npd35k-factory-1de74874.tgz</a><br>
+      MD5: c0dbb7db671f61b2785da5001cedefcb<br>
+      SHA-1: 1de74874f8d83e14d642f13b5a2130fc2aa55873
     </td>
   </tr>
 
   <tr id="ryu">
     <td>Pixel C <br>"ryu"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >ryu-npc91k-factory-463030f2.tgz</a><br>
-      MD5: 24e8981a3c95637867eb768c0f84c96c<br>
-      SHA-1: 463030f2ecdcfe9e92ddf9f3a224ac7aa5ed5866
+      >ryu-npd35k-factory-b4eed85d.tgz</a><br>
+      MD5: bdcb6f770e753668b5fadff2a6678e0d<br>
+      SHA-1: b4eed85de0d42c200348a8629084f78e24f72ac2
     </td>
   </tr>
 
   <tr id="seed">
     <td>General Mobile 4G (Android One) <br>"seed"</td>
     <td><a href="#top" onclick="onDownload(this)"
-      >seed_l8150-npc91k-factory-7026d89d.tgz</a><br>
-      MD5: a614984799c887d9b5af2d366fefc8e3<br>
-      SHA-1: 7026d89d79decd8421da8df844a1fcd9e27df163
+      >seed_l8150-npd35k-factory-5ab1212b.tgz</a><br>
+      MD5: 7d34a9774fdd6e025d485ce6cfc23c4c<br>
+      SHA-1: 5ab1212bc9417269d391aacf1e672fff24b4ecc5
     </td>
   </tr>
 
diff --git a/docs/html/preview/features/background-optimization.jd b/docs/html/preview/features/background-optimization.jd
index ec02328..3c33b9d 100644
--- a/docs/html/preview/features/background-optimization.jd
+++ b/docs/html/preview/features/background-optimization.jd
@@ -379,7 +379,7 @@
 
   <li style="list-style: none; display: inline">
 <pre class="no-pretty-print">
-{@code $ adb shell cmd appops set RUN_IN_BACKGROUND ignore}
+{@code $ adb shell cmd appops set &lt;package&gt; RUN_IN_BACKGROUND ignore}
 </pre>
   </li>
 
@@ -389,7 +389,7 @@
 
   <li style="list-style: none; display: inline">
 <pre class="no-pretty-print">
-{@code $ adb shell cmd appops set RUN_IN_BACKGROUND allow}
+{@code $ adb shell cmd appops set &lt;package&gt; RUN_IN_BACKGROUND allow}
 </pre>
   </li>
-</ul>
\ No newline at end of file
+</ul>
diff --git a/docs/html/preview/features/data-saver.jd b/docs/html/preview/features/data-saver.jd
index 88035f61..761556e 100644
--- a/docs/html/preview/features/data-saver.jd
+++ b/docs/html/preview/features/data-saver.jd
@@ -13,10 +13,16 @@
     <ol>
       <li>
         <a href="#status">Checking Data Saver Preferences</a>
+        <ol>
+          <li>
+            <a href="#request-whitelist">Requesting whitelist permissions</a>
+          </li>
+        </ol>
       </li>
 
       <li>
-        <a href="#monitor-changes">Monitoring Changes to Data Saver Preferences</a>
+        <a href="#monitor-changes">Monitoring Changes to Data Saver
+        Preferences</a>
       </li>
 
       <li>
@@ -125,6 +131,27 @@
 }
 </pre>
 
+<h3 id="request-whitelist">
+  Requesting whitelist permissions
+</h3>
+
+<p>
+  If your app needs to use data in the background, it can request whitelist
+  permissions by sending a
+  <code>Settings.ACTION_IGNORE_BACKGROUND_DATA_RESTRICTIONS_SETTINGS</code>
+  intent containing a URI of your app's package name: for example,
+  <code>package:MY_APP_ID</code>.
+</p>
+
+<p>
+  Sending the intent and URI launches the <strong>Settings</strong> app and
+  displays data usage settings for your app. The user can then decide whether
+  to enable background data for your app. Before you send this intent, it is
+  good practice to first ask the user if they want to launch the
+  <strong>Settings</strong> app for the purpose of enabling background data
+  usage.
+</p>
+
 <h2 id="monitor-changes">
   Monitoring Changes to Data Saver Preferences
 </h2>
@@ -132,9 +159,8 @@
 <p>
   Apps can monitor changes to Data Saver preferences by creating a {@link
   android.content.BroadcastReceiver} to listen for {@code
-  ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED} ({@code
-  "android.net.conn.RESTRICT_BACKGROUND_CHANGED"}) and dynamically registering
-  the receiver with {@link android.content.Context#registerReceiver
+  ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED} and dynamically
+  registering the receiver with {@link android.content.Context#registerReceiver
   Context.registerReceiver()}. When an app receives this broadcast, it should
   <a href="#status">check if the new Data Saver preferences affect its
   permissions</a> by calling {@code
diff --git a/docs/html/preview/features/notification-updates.jd b/docs/html/preview/features/notification-updates.jd
index 7ee0954..0163337 100644
--- a/docs/html/preview/features/notification-updates.jd
+++ b/docs/html/preview/features/notification-updates.jd
@@ -16,6 +16,7 @@
   <li><a href="#direct">Direct Reply</a></li>
   <li><a href="#bundle">Bundled Notifications</a></li>
   <li><a href="#custom">Custom Views</a></li>
+  <li><a href="#style">Message Style</a></li>
 </ol>
 
 </div>
@@ -203,6 +204,17 @@
   android.support.v4.app.RemoteInput}, you can update the reply history
   using the {@code setRemoteInputHistory()} method.
 </p>
+
+<p>
+  The notification must be either updated or cancelled after the app has
+  received remote input. When the user replies to a remote update
+  using Direct Reply,
+  do not cancel the notification. Instead, update the notification to display the user's reply.
+For notifications using {@code MessagingStyle}, you should add
+the reply as the latest message. When using other templates, you can
+append the user's reply to the remote-input history.
+</p>
+
 <h2 id="bundle">Bundled Notifications</h2>
 
 <p>Android N provides developers with a new way to represent
@@ -233,6 +245,12 @@
   group.
 </p>
 
+<p class="note">
+  <strong>Note:</strong> If the same app sends four or more notifications
+  and does not specify a grouping, the
+  system automatically groups them together.
+</p>
+
 <p>To learn how to add notifications to a group, see
 <a href="{@docRoot}training/wearables/notifications/stacks.html#AddGroup">Add
 Each Notification to a Group</a>.</p>
@@ -348,7 +366,7 @@
 {@code DecoratedCustomViewStyle()} method.</p>
 
 <pre>
-Notification noti = new Notification.Builder()
+Notification notification = new Notification.Builder()
            .setSmallIcon(R.drawable.ic_stat_player)
            .setLargeIcon(albumArtBitmap))
            .setCustomContentView(contentView);
@@ -356,3 +374,26 @@
            .build();
 
 </pre>
+
+<h2 id="style">Messaging Style</h2>
+<p>
+  Android N introduces a new API for customizing the style of a notification.
+  Using the <code>MessageStyle</code> class, you can change several of the
+  labels displayed on the notification, including the conversation title,
+  additional messages, and the content view for the notification.
+</p>
+
+<p>
+  The following code snippet demonstrates how to customize a notification's
+  style using the <code>MessageStyle</code> class.
+</p>
+
+<pre>
+  Notification notification = new Notification.Builder()
+             .setStyle(new Notification.MessagingStyle("Me")
+                 .setConversationTitle("Team lunch")
+                 .addMessage("Hi", timestamp1, null) // Pass in null for user.
+                 .addMessage("What's up?", timestamp2, "Coworker")
+                 .addMessage("Not much", timestamp3, null)
+                 .addMessage("How about lunch?", timestamp4, "Coworker"));
+</pre>
diff --git a/docs/html/preview/features/scoped-folder-access.jd b/docs/html/preview/features/scoped-folder-access.jd
index 814692d..06dd665 100644
--- a/docs/html/preview/features/scoped-folder-access.jd
+++ b/docs/html/preview/features/scoped-folder-access.jd
@@ -44,6 +44,12 @@
 all available volumes, including removable media volumes, use
 <code>StorageManager.getVolumesList()</code>.</p>
 
+<p>If you have information about a specific file, use
+<code>StorageManager.getStorageVolume(File)</code> to get the
+<code>StorageVolume</code> that contains the file. Call
+<code>createAccessIntent()</code> on this <code>StorageVolume</code> to access
+the external storage directory for the file.</p>
+
 <p>
 On secondary volumes, such as external SD cards, pass in null when calling
 <code>StorageVolume.createAccessIntent()</code> to request access to the entire
diff --git a/docs/html/preview/features/tv-recording-api.jd b/docs/html/preview/features/tv-recording-api.jd
index be6d04e..6619821 100644
--- a/docs/html/preview/features/tv-recording-api.jd
+++ b/docs/html/preview/features/tv-recording-api.jd
@@ -38,7 +38,23 @@
 
 <h2 id="supporting">Indicating Support for Recording</h2>
 
-<p>To tell the system that your TV input service supports recording, follow
+<p>To tell the system that your TV input service supports recording, set
+the <code>android:canRecord</code> attribute in your service metadata XML file
+to <code>true</code>:
+</p>
+
+<pre>
+&lt;tv-input xmlns:android="http://schemas.android.com/apk/res/android"
+  <b>android:canRecord="true"</b>
+  android:setupActivity="com.example.sampletvinput.SampleTvInputSetupActivity" /&gt;
+</pre>
+
+<p>For more information on the service metadata file, see
+<a href="{@docRoot}training/tv/tif/tvinput.html#manifest">Declare Your TV Input
+Service in the Manifest</a>.
+</p>
+
+<p>Alternatively, you can indicate recording support in your code using
 these steps:</p>
 
 <ol>
@@ -49,7 +65,7 @@
 <code>setCanRecord(true)</code> before calling <code>build()</code> to
 indicate your service supports recording.</li>
 <li>Register your <code>TvInputInfo</code> object with the system by calling
-<code>TvInputService.updateTvInputInfo()</code>.</li>
+<code>TvInputManager.updateTvInputInfo()</code>.</li>
 </ol>
 
 <h2 id="recording">Recording a Session</h2>
diff --git a/docs/html/preview/overview.jd b/docs/html/preview/overview.jd
index 0369490..1b45c1a 100644
--- a/docs/html/preview/overview.jd
+++ b/docs/html/preview/overview.jd
@@ -153,7 +153,7 @@
 <ul>
   <li><strong><a href="{@docRoot}preview/support.html#dp1">Preview 1</a></strong> (initial release, alpha)</li>
   <li><strong><a href="{@docRoot}preview/support.html#dp2">Preview 2</a></strong> (incremental update, alpha)</li>
-  <li><strong>Preview 3</strong> (incremental update, beta)</li>
+  <li><strong><a href="{@docRoot}preview/support.html#dp3">Preview 3</a></strong> (incremental update, beta)</li>
   <li><strong>Preview 4</strong> (final APIs and official SDK, Play publishing)</li>
   <li><strong>Preview 5</strong> (near-final system images for final testing)</li>
   <li><strong>Final release</strong> to AOSP and ecosystem</li>
diff --git a/docs/html/preview/setup-sdk.jd b/docs/html/preview/setup-sdk.jd
index 9a0a351..ebeae74 100644
--- a/docs/html/preview/setup-sdk.jd
+++ b/docs/html/preview/setup-sdk.jd
@@ -91,11 +91,11 @@
   </tr>
   <tr>
     <td style="white-space: nowrap">
-    <a href="{@docRoot}shareables/preview/n-preview-2-docs.zip"
-      >n-preview-2-docs.zip</a></td>
+    <a href="{@docRoot}shareables/preview/n-preview-3-docs.zip"
+      >n-preview-3-docs.zip</a></td>
     <td width="100%">
-      MD5: c02732760f468bd97cd94c1b76361229<br>
-      SHA-1: 591eabe168c909799f6d8dcbe7b126c25ea8b04d
+      MD5: 19bcfd057a1f9dd01ffbb3d8ff7b8d81<br>
+      SHA-1: 9224bd4445cd7f653c4c294d362ccb195a2101e7 
     </td>
   </tr>
 <table>
diff --git a/docs/html/preview/support.jd b/docs/html/preview/support.jd
index f0da709..7c56f97 100644
--- a/docs/html/preview/support.jd
+++ b/docs/html/preview/support.jd
@@ -5,10 +5,39 @@
 
 @jd:body
 
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>In this document</h2>
+
+<ul>
+  <li><a href="#dp3">Developer Preview 3</a>
+    <ul>
+      <li><a href="#general">General advisories</a></li>
+      <li><a href="#new">New in DP3</a></li>
+      <li><a href="#ki">Known issues</a></li>
+    </ul>
+  </li>
+  <li><a href="#dp2">Developer Preview 2</a></li>
+  <li><a href="#dp1">Developer Preview 1</a></li>
+</ul>
+
+<!--
+<h2>See Also</h2>
+<ol>
+  <li></li>
+</ol>
+-->
+
+</div>
+</div>
+
 <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
+  "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>
@@ -16,6 +45,484 @@
 <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>
 
+<h2 id="dp3">Developer Preview 3</h2>
+
+<div class="wrap">
+  <div class="cols">
+    <div class="col-6of12">
+      <p>
+        <em>Date: May 2016<br>
+        Build: NPD35K<br>
+        Emulator support: x86 &amp; ARM (32/64-bit)<br>
+        Google Play services: 8.4</em>
+      </p>
+    </div>
+  </div>
+</div>
+
+<h3 id="general">General advisories</h3>
+
+<p>
+  This Developer Preview release is for <strong>app developers and other early
+  adopters</strong> and is available for daily use, development, or
+  compatibility testing. Please be aware of these general notes about the
+  release:
+</p>
+
+<ul>
+  <li>This release may have various <strong>stability issues</strong> on
+    supported devices. Users may encounter system instability, such as kernel
+    panics and crashes.
+  </li>
+
+  <li>Some apps <strong>may not function as expected</strong> on the new
+  platform version. This includes Google’s apps as well as other apps.
+  </li>
+
+  <li>Developer Preview 3 is <strong>Compatibility Test Suite (CTS)
+  approved</strong> on these devices: Nexus 5X, Nexus 6, Nexus 6P, and Pixel
+  C. Apps that depend on CTS approved builds should
+  work normally on these devices (Android Pay for example).
+  </li>
+
+  <li>Developer Preview 3 is <strong>available on all supported
+  devices:</strong> Nexus 5X, Nexus 6, Nexus 6P, Nexus 9, Nexus Player, Pixel
+  C, General Mobile 4G (Android One), as well as Sony Xperia Z3 (D6603 and
+  D6653 models).
+
+  </li>
+</ul>
+
+
+<h3 id="new">New in DP3</h3>
+
+<h4 id="">VR Mode for Android</h4>
+
+<p>
+  Android N adds platform support and optimizations for a new VR Mode to let
+  developers build high quality mobile VR experiences for users. There are a
+  number of performance enhancements, including access to an exclusive CPU core
+  for VR apps. Within your apps, you can take advantage of intelligent
+  head-tracking, and stereo notifications that work for VR. Most importantly,
+  Android N provides for very low latency graphics.
+</p>
+
+<p>
+  For more information, see the <a href=
+  "https://developers.google.com/vr/android/">Google VR SDK for Android</a>.
+</p>
+
+<h4 id="">Sustained performance mode</h4>
+
+<p>
+  Android N includes optional support for <a href=
+  "{@docRoot}preview/api-overview.html#sustained_performance_api">sustained
+  performance mode</a>, enabling OEMs to provide hints on device performance
+  capabilities for long running applications. App developers can then use these
+  hints to tune applications for a predictable, consistent level of device
+  performance over long periods of time. App developers can try out this new
+  API in the developer preview on Nexus 6P devices only.
+</p>
+
+<h4>Multiprocess WebView</h4>
+
+<p>
+  Starting with version 51 in Android N, WebView will run web content in a
+  separate sandboxed process when the developer option "Multiprocess WebView"
+  is enabled. The WebView team is looking for feedback on compatibility and
+  runtime performance in N before enabling multiprocess WebView in a future
+  version of Android. In this version, regressions in startup time, total
+  memory usage and software rendering performance are expected.
+</p>
+
+<p>
+  If you find unexpected issues in multiprocess mode we’d like to hear about
+  them. Please get in touch with the WebView team by <a href=
+  "https://bugs.chromium.org/p/chromium/issues/entry?template=Webview%20Bugs">
+  filing a bug</a>.
+</p>
+
+<h4 id="">Keyboard Shortcuts helper</h4>
+
+<p>
+  Android N lets users press <code>Meta+/</code> to trigger a <strong>Keyboard
+  Shortcuts</strong> screen that displays all shortcuts available both from the
+  system and from the app in focus. Developers can add their own shortcuts or
+  trigger the Shortcuts screen from their apps. See <a href=
+  "{@docRoot}preview/api-overview.html#keyboard_shortcuts_helper">Keyboard
+  Shortcuts helper</a> for details.
+</p>
+
+<h4 id="">FrameMetrics API</h4>
+
+<p>
+  DP3 introduces a new <a href=
+  "{@docRoot}preview/api-overview.html#framemetrics_api">FrameMetrics API</a>
+  that allows an app to monitor its UI rendering performance by exposing a
+  streaming pubsub API to transfer frame timing info for the application’s
+  current window. <code>FrameMetricsListener</code> can be used to measure
+  interaction-level UI performance in production with higher granularity and
+  without the need for a USB connection.
+</p>
+
+<h4 id="api-changes">Feature and API changes</h4>
+
+<dl>
+  <dt>
+    Launcher Shortcuts and the Launcher Shortcuts API
+  </dt>
+
+  <dd>
+    We’ve decided to defer this feature to a future release of Android. We plan
+    to remove the Launcher Shortcuts APIs (ShortcutManager and others) from the
+    public Android N API starting in the next developer preview.
+  </dd>
+
+  <dt>
+    WebView Javascript run before page load
+  </dt>
+
+  <dd>
+    Starting with apps targeting Android N, the Javascript context is reset
+    when a new page is loaded. Currently, the context is carried over for the
+    first page loaded in a new {@link android.webkit.WebView} instance.
+    Developers looking to inject Javascript into the {@link
+    android.webkit.WebView} should execute the script after the page has
+    started to load.
+  </dd>
+
+  <dt>
+    WebView Geolocation on insecure origins
+  </dt>
+
+  <dd>
+    Starting with apps targeting Android N, the geolocation API will only be
+    allowed on secure origins (over HTTPS.) This policy is designed to protect
+    users' private information when they're using an insecure connection.
+  </dd>
+
+  <dt>
+    Data Saver
+  </dt>
+
+  <dd>
+    Starting in Developer Preview 3, apps can use use an intent to display a
+    system dialog that lets the user directly add the app to the Data Saver
+    exemption whitelist. See the <a href=
+    "{@docRoot}preview/api-overview.html#data_saver">Data Saver
+    documentation</a> for details.
+  </dd>
+
+  <dt>
+    <a href=
+    "{@docRoot}preview/api-overview.html#number-blocking">Number-blocking</a>
+  </dt>
+
+  <dd>
+    If an unauthorized user attempts to block or unblock a number, the
+    operation now fails with {@link java.lang.SecurityException}. (Previously,
+    the operation threw {@link java.lang.UnsupportedOperationException}.)
+  </dd>
+
+  <dt>
+    <a href="{@docRoot}preview/api-overview.html#tile_api">Quick Settings Tile
+    API</a>
+  </dt>
+
+  <dd>
+    The system now uses the activity's metadata to decide on the tile mode.
+    (Previously, tile mode was determined by the return value of
+    <code>TileService.onTileAdded()</code>.) For more information, see
+    <code>TileService.META_DATA_ACTIVE_TILE</code> in the downloadable <a href=
+    "{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
+  </dd>
+</dl>
+
+<h4 id="dp3-fixes">Fixes for issues reported by developers</h4>
+
+<p>
+  A number of issues reported by developers have been fixed, including:
+</p>
+
+<ul>
+  <li>Bluetooth Audio playback interrupted after 1 song (bug <a href=
+  "https://code.google.com/p/android/issues/detail?id=206889">206889</a>)
+  </li>
+
+  <li>Pixel C Consistently Crashes (bug <a href=
+  "https://code.google.com/p/android/issues/detail?id=206962">206962</a>)
+  </li>
+
+  <li>Clock and Toast notification issues (bug <a href=
+  "https://code.google.com/p/android/issues/detail?id=203094">203094</a>)
+  </li>
+
+  <li>Pixel C reboots when connected to MacBook Pro via USB C Cable (bug
+  <a href=
+  "https://code.google.com/p/android/issues/detail?id=205432">205432</a>)
+  </li>
+
+  <li>Calandar offset by one day (bug <a href=
+  "https://code.google.com/p/android/issues/detail?id=203002">203002</a>)
+  </li>
+
+  <li>TelephonyManager.getAllCellInfo returning invalid data (bug <a href=
+  "https://code.google.com/p/android/issues/detail?id=203022">203022</a>)
+  </li>
+
+  <li>Nexus 6p, Bluetooth keeps disconnecting (bug <a href=
+  "https://code.google.com/p/android/issues/detail?id=208062">208062</a>)
+  </li>
+</ul>
+
+<p>For the full list of fixed issues, see <a href="https://goo.gl/6uCKtf">the
+issue tracker</a>.</p>
+
+<h3 id="ki">Known Issues</h3>
+
+<h4>Accessibility</h4>
+
+<ul>
+  <li>Unable to listen to TTS output when pitch is set near maximum level.
+  </li>
+
+  <li>Accessibility features and settings may be disrupted with the user adds a
+  Work profile, including magnification gesture and setting. Accessibility
+  state is restored when the user next touches the associated settings.
+  </li>
+</ul>
+
+<h4>Camera</h4>
+
+<ul>
+  <li>The Camera app has exhibited instability; it may crash in various
+    circumstances, such as when launched in multi-window mode.
+  </li>
+
+  <li>Pressing the shutter continuously in panorama mode may cause the Camera
+  app to crash.
+  </li>
+</ul>
+
+<h4>Audio</h4>
+<ul>
+  <li>A platform audio player issue prevents some apps from functioning
+  normally. For example, Skype and other apps are affected by this issue.
+  </li>
+</ul>
+
+<h4>Connectivity</h4>
+
+
+<ul>
+  <li>When a Bluetooth Low Energy (BLE) peripheral role device advertises a
+  service and a BLE central role device connects, the peripheral role device
+  disconnects very quickly.
+  </li>
+
+  <li>Wi-Fi connection may be dropped when the screen is off.
+  </li>
+
+  <li>RFCOMM connections are unstable and may result in data corruption and
+  dangling connections.
+  </li>
+
+  <li>The active network state ({@link android.net.NetworkInfo#getState
+  NetworkInfo.getState()} and {@link android.net.NetworkInfo#getDetailedState
+  NetworkInfo.getDetailedState()}) might return incorrect values during some
+  restricted background scenarios.
+  </li>
+</ul>
+
+
+<h4>
+  Launcher
+</h4>
+
+<ul>
+  <li>The default launcher’s All Apps tray may become unresponsive after
+  cycling screen off / screen on. Returning to the homescreen and relaunching
+  the All Apps tray may resolve this issue.
+  </li>
+</ul>
+
+<h4>
+  Keyboard
+</h4>
+
+<ul>
+  <li>When updating a device running Android 6.0 or earlier to the N Developer
+  Preview, Google Keyboard does not preserve preferences data such as recent
+  emoji and sound settings.
+  </li>
+
+  <li>Google Indic Managed Keyboard may be unstable.
+  </li>
+
+  <li>When entering text in a password field, the user can select Russian as
+  the input language but the keyboard remains in English. This prevents the
+  user from entering Russian-language passwords.
+  </li>
+</ul>
+
+<h4>
+  Locale and languages
+</h4>
+
+<ul>
+  <li>When using a right-to-left (RTL) locale, the system may unexpectedly
+  switch to left-to-right (LTR) presentation after restarting the device.
+  </li>
+</ul>
+
+<h4>Media</h4>
+
+<ul>
+  <li>Media playback be be unreliable on Nexus 9 and Nexus Player, including
+  issues playing HD video.
+  </li>
+</ul>
+
+<h4>
+  Multi-window mode
+</h4>
+
+<ul>
+  <li>Device may freeze when changing orientation in multi-window mode.
+  </li>
+
+  <li>Several apps currently have issues with multi-window mode:
+    <ul>
+      <li>The system UI may crash when docking Settings &gt; Display &gt;
+      Screen brightness to multi-window.
+      </li>
+
+      <li>The Camera app may crash when launched in multi-window mode.
+      </li>
+
+      <li>YouTube may crash when launched into multi-window mode. To fix the
+      issue, you can clear the YouTube app’s data at Storage &gt; Apps &gt;
+      YouTube.
+      </li>
+    </ul>
+  </li>
+</ul>
+
+<h4>
+  Google Play services
+</h4>
+
+<ul>
+  <li>Apps using Google Cast through Google Play services may be unstable when
+  the user selects a system locale that uses letters and numbers outside of the
+  ASCII range.
+  </li>
+</ul>
+
+<h4>
+  Android for Work and Google Apps Device Policy
+</h4>
+
+<ul>
+  <li>The Device Policy app may crash when the user unlocks the device with the
+  "device policy status" screen pinned.
+  </li>
+
+  <li>After setting up a work profile with file-based encryption enabled and
+  then turning off Work, users must unlock primary profile screen lock to once
+  again access Work apps.
+  </li>
+
+  <li>Device reboots when removing the security pattern lock and opening work
+  app/personal app in the multi-window.
+  </li>
+
+  <li>Setting DISALLOW_VPN_CONFIG is causing the consent dialog to appear in
+  always-on-vpn set by Device Policy Client.
+  </li>
+
+  <li>Traffic is not locked down until VPN is connected in always-on-vpn mode.
+  </li>
+</ul>
+
+<h4>
+  External storage
+</h4>
+
+<ul>
+  <li>Apps may become unstable when the user moves them from internal storage
+  to adoptable external storage (this can include SD card or devices attached
+  over USB).
+  </li>
+</ul>
+
+<h4>
+  Screen zoom and multiple APKs in Google Play
+</h4>
+
+<ul>
+  <li>On devices running Android N, Google Play services 9.0.83 incorrectly reports
+  the current screen density rather than the stable screen density. When screen
+  zoom is enabled on these devices, this can cause Google Play to select a
+  version of a multi-APK app that’s designed for smaller screens. This issue is
+  fixed in the next version of Google Play services and will be included in a
+  later Developer Preview release.
+  </li>
+
+  <li>On devices running Android N, Google Play services 9.0.83 currently reports
+  Vulkan support but not Vulkan version. This can cause Google Play to select a
+  version of a multi-APK app that’s designed for lower Vulkan support on
+  devices with higher version support. Currently, the Google Play Store does
+  not accept uploads of Apps which use Vulkan version targeting. This support
+  will be added to the Google Play Store in the future and fixed in the next
+  version of Google Play services (to be included in a later Developer Preview
+  release) any N devices using the version of Google Play services 9.0.83 will
+  continue to receive versions of Apps targeting basic Vulkan support.
+  </li>
+</ul>
+
+<h4 id="">Notifications</h4>
+
+<ul>
+  <li>MessagingStyle does not show notifications with "null" (self) sender.
+  </li>
+</ul>
+
+<h4 id="">Developer Tools</h4>
+
+<ul>
+  <li>
+    <code>adb</code> may sometimes disconnect while using JDWP debugging.
+  </li>
+</ul>
+
+<!-- TBA, if any
+<h4>Device-specific issues</h4>
+
+<dl>
+  <dt>
+    <strong>Device Name</strong>
+  </dt>
+
+  <dd>
+    Issue 1
+  </dd>
+
+  <dd>
+    Issue 2
+  </dd>
+</dl>
+
+-->
+
+
+
+
+
+
+
+<!-- DP2 Release Notes Archive -->
+
 <h2 id="dp2">Developer Preview 2</h2>
 
 <div class="wrap">
@@ -31,7 +538,7 @@
   </div>
 </div>
 
-<h3 id="new">New in DP2</h3>
+<h3 id="dp2-new">New in DP2</h3>
 
 <ul>
   <li>Platform support for Vulkan, a new 3D rendering API that provides
@@ -87,7 +594,7 @@
   </li>
 </ul>
 
-<h3 id="general">General advisories</h3>
+<h3 id="dp2-general">General advisories</h3>
 
 <p>
   This Developer Preview release is for <strong>app developers only</strong>
@@ -145,7 +652,7 @@
   </li>
 </ul>
 
-<h3 id="ki">Known Issues</h3>
+<h3 id="dp2-ki">Known Issues</h3>
 
 <h4>Performance and battery</h4>
 
@@ -393,7 +900,7 @@
 
 <h3 id="dp1-platform">Platform Issues</h3>
 
-<h4 id="performance">Performance and battery</h4>
+<h4>Performance and battery</h4>
 
 <ul>
   <li>System and app performance is known to be <strong>periodically slow /
@@ -416,7 +923,7 @@
   </li>
 </ul>
 
-<h4 id="microphone">Microphone</h4>
+<h4>Microphone</h4>
 
 <ul>
    <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>
@@ -552,19 +1059,20 @@
   </li>
 </ul>
 
-<h4 id="keyboard">Keyboard</h4>
+<h4 >Keyboard</h4>
 
 <ul>
-<li>Bluetooth pairing between keyboards and Android devices may be unstable. </li>
+  <li>Bluetooth pairing between keyboards and Android devices may be unstable.
+  </li>
 </ul>
 
-<h4 id="video">Video</h4>
+<h4 >Video</h4>
 
 <ul>
 <li>Video playback may lag and show interruptions.</li>
 </ul>
 
-<h4 id="wifi">Wi-Fi</h4>
+<h4>Wi-Fi</h4>
 
 <ul>
   <li>Wi-Fi has undergone some refactoring which may change API corner case
@@ -577,7 +1085,7 @@
   </li>
 </ul>
 
-<h4 id="direct">Direct boot</h4>
+<h4>Direct boot</h4>
 
 <ul>
   <li>NFC doesn't function until first unlock.
@@ -607,7 +1115,7 @@
   </li>
 </ul>
 
-<h4 id="pip">Picture-in-picture for Android TV</h4>
+<h4>Picture-in-picture for Android TV</h4>
 
 <ul>
   <li>The PIP integration in the Recents UI is not finalized, and is subject to
@@ -624,7 +1132,7 @@
   </li>
 </ul>
 
-<h4 id="bugs">Bug reports</h4>
+<h4>Bug reports</h4>
 
 <ul>
   <li>Bug reports do not always complete successfully (as a workaround,
@@ -633,7 +1141,7 @@
   </li>
 </ul>
 
-<h4 id="split">Split-screen Multi-window</h4>
+<h4>Split-screen Multi-window</h4>
 
 <ul>
   <li>Apps may experience crashes and unexpected UI behavior when put into
@@ -656,7 +1164,7 @@
   </li>
 </ul>
 
-<h4 id="ime">Input method</h4>
+<h4>Input method</h4>
 
 <ul>
   <li>Google Keyboard unexpectedly falls back to the generic Google keyboard
@@ -670,26 +1178,31 @@
   </li>
 </ul>
 
-
-<h4 id="accessibility">Accessibility</h4>
+<h4>Accessibility</h4>
 
 <ul>
-   <li>TalkBack exhibits issues with features including Notifications, Quick Settings Tiles and Multi-window display that may cause system crashing or lack of spoken feedback from TalkBack. Future releases of the preview will address these issues.</li>
+  <li>TalkBack exhibits issues with features including Notifications, Quick
+  Settings Tiles and Multi-window display that may cause system crashing or
+  lack of spoken feedback from TalkBack. Future releases of the preview will
+  address these issues.
+  </li>
 </ul>
 
-<h3 id="device-sp">Device-Specific Notes and Issues</h3>
+<h3 id="dp1-device-sp">Device-Specific Notes and Issues</h3>
 
-<h4 id="player">Nexus Player</h4>
+<h4>Nexus Player</h4>
 <ul>
-<li>Video playback, app compatibility and stability issues are expected on Nexus Player in this release of the Preview.</li>
+  <li>Video playback, app compatibility and stability issues are expected on
+  Nexus Player in this release of the Preview.
+  </li>
 </ul>
 
-<h4 id="pixelc">Pixel C</h4>
+<h4>Pixel C</h4>
 <ul>
 <li>Multi-window resizing may cause crashing.</li>
 </ul>
 
-<h4 id="n9">Nexus 9</h4>
+<h4>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
diff --git a/docs/html/topic/instant-apps/_book.yaml b/docs/html/topic/instant-apps/_book.yaml
new file mode 100644
index 0000000..1f918f2
--- /dev/null
+++ b/docs/html/topic/instant-apps/_book.yaml
@@ -0,0 +1,5 @@
+toc:
+- title: Android Instant Apps
+  path: /topic/instant-apps/index.html
+- title: Frequently Asked Questions (FAQs)
+  path: /topic/instant-apps/faqs.html
\ No newline at end of file
diff --git a/docs/html/topic/instant-apps/faqs.jd b/docs/html/topic/instant-apps/faqs.jd
new file mode 100644
index 0000000..0a1f571
--- /dev/null
+++ b/docs/html/topic/instant-apps/faqs.jd
@@ -0,0 +1,69 @@
+page.title=Android Instant Apps: Frequently Asked Questions
+page.tags=Material,design
+footer.hide=true
+forcelocalnav=true
+@jd:body
+
+<p>
+  <strong>What devices are compatible with Android Instant Apps?</strong>
+  <br/>
+  Android Instant Apps is compatible with devices that are running Android 4.1
+  (API level 16) or higher and have Google Play services installed.
+</p>
+
+<p>
+  <strong>Do developers need to build two different Android apps now?</strong>
+  <br/>
+  Developers only need to maintain one project with one source tree.
+  Developers simply configure the project to create two build artifacts: the
+  installable APK and the instant version.
+  Some developers can take less than a day to get up and running,
+  though the effort involved varies depending on how the
+  app is structured.
+</p>
+
+<p>
+  <strong>What Android APIs and functionality can Instant Apps use?</strong>
+  <br/>
+  Android Instant Apps functionality complements an existing Android app,
+  but does not replace it. Android Instant Apps uses the same Android APIs, the
+  same project, the same source code. Android Instant Apps restricts some
+  features that might not match users' expectations of an app
+  that is not installed.
+  For example, an Instant App can't use background services, do background
+  notifications, or access unique device identifiers.
+</p>
+
+<p>
+  <strong>Can users choose to install the app permanently?</strong>
+  <br/>
+  Developers can allow users to download the app from the Google Play
+  Store. After download, the app remains on the phone after the user has left
+  the experience.
+</p>
+
+<p>
+  <strong>How do permissions work in Android Instant Apps?</strong>
+  <br/>
+  Android Instant Apps uses the runtime permissions model introduced in
+  Android 6.0.
+  If an app supports the permission model introduced in Android 6.0
+  (API level 23), it does not require any additional work to become an Instant
+  App that runs on older devices.
+</p>
+
+<p>
+  <strong>How do developers publish these apps?</strong>
+  <br/>
+  Developers publish their Instant Apps through the Google Play Developer
+  Console, similar to their existing Android apps.
+</p>
+
+<p>
+  <strong>How can developers get involved?</strong>
+  <br/>
+  Developers interested in upgrading their Android apps can visit
+  <a class="external-link" href="g.co/InstantApps">g.co/InstantApps</a> to
+  sign up. We will be reaching out to interested
+  developers in the coming months.
+</p>
\ No newline at end of file
diff --git a/docs/html/topic/instant-apps/index.jd b/docs/html/topic/instant-apps/index.jd
new file mode 100644
index 0000000..d8de0b5
--- /dev/null
+++ b/docs/html/topic/instant-apps/index.jd
@@ -0,0 +1,314 @@
+fullpage=true
+page.title=Android Instant Apps
+page.viewport_width=970
+meta.tags="instant apps, getstarted, sdk, appquality, landing"
+section.landing=true
+header.hide=1
+carousel=1
+tabbedList=1
+excludeFromSuggestions=true
+@jd:body
+
+<!-- Hero section -->
+<section class="dac-expand dac-hero dac-section-light">
+<div class="wrap">
+  <div class="cols dac-hero-content">
+
+    <div class="col-1of2 col-push-1of2 dac-hero-figure">
+      <div class="dev-bytes-video">
+        <iframe width="560" height="350" src=
+        "https://www.youtube.com/embed/cosqlfqrpFA" frameborder="0"
+        allowfullscreen=""></iframe>
+      </div>
+    </div>
+
+    <div class="col-1of2 col-pull-1of2" style="margin-bottom:40px">
+      <h1>
+        Android Instant Apps
+      </h1>
+
+      <p class="sub-head">
+        Native Android apps, without the installation
+      </p>
+
+      <p class="dac-hero-description">
+        An evolution in app sharing and discovery, Android Instant Apps enables
+        Android apps to run instantly, without requiring installation. Instant
+        Apps lets you experience what you love about apps&#8212fast and beautiful
+        user interfaces, high performance, and great capabilities&#8212with just a
+        tap.
+      </p>
+
+      <p class="dac-hero-description">
+        Request early access to the Instant Apps documentation today.
+      </p>
+
+      <p style="margin-top:24px">
+        <a class="landing-button green download-bundle-button" href=
+        "https://docs.google.com/a/google.com/forms/d/1S3MzsMVIlchLCqyNLaFbv64llxWaf90QSeYLeswco90/viewform"
+        target="_blank">I'M INTERESTED IN ANDROID INSTANT APPS<br></a>
+      </p>
+    </div>
+
+  </div> <!-- end cols dac-hero-content -->
+</div> <!-- end .wrap -->
+</section>
+
+<!-- Second section -->
+
+<div class="wrap" style="margin-top:60px">
+<div class="cols dac-hero-content">
+  <div class="col-1of2 dac-hero-figure">
+    <img src="/images/topic/instant-apps/instant-apps-section-2.png">
+  </div>
+<div class="col-1of2">
+<div class="dac-hero-tag"></div>
+
+  <h2 id="section-2">Run Android Apps Without Installation</h2>
+  <p class="dac-hero-description">
+    Android Instant Apps lets you experience beautiful and immersive
+    apps, with material design and smooth animations, without installing them
+    on your device.
+  </p>
+
+</div>
+</div>
+</div>
+
+<!-- Third section -->
+
+<div class="wrap" style="margin-top:60px">
+
+  <h2 id="section-3">Access Apps From Anywhere</h2>
+
+  <p>
+    Get people to your flagship Android experience from links that would
+    otherwise open your mobile web page &mdash; like
+    search, social media, messaging, and other deep links &mdash; without them
+    needing to stop and install your app first.
+  </p>
+
+  <div class="cols" style="margin-top:1em;">
+    <div class="col-4of12 gif-container">
+      <img class="partner-gifs"
+        src="/images/topic/instant-apps/s3-BandH-static.png"
+        data-stat="/images/topic/instant-apps/s3-BandH-static.png"
+        data-anim="/images/topic/instant-apps/s3-BandH-animated.gif">
+      <p class="figure-caption">
+        <em>B&amp;H Photo<br/>
+            (via Google Search)</em>
+      </p>
+    </div>
+
+    <div class="col-4of12 gif-container">
+      <img class="partner-gifs"
+        src="/images/topic/instant-apps/s3-BuzzFeed-static.png"
+        data-stat="/images/topic/instant-apps/s3-BuzzFeed-static.png"
+        data-anim="/images/topic/instant-apps/s3-BuzzFeed-animated.gif">
+      <p class="figure-caption">
+        <em>BuzzfeedVideo<br/>
+            (via a shared link)</em>
+      </p>
+    </div>
+
+    <div class="col-4of12 gif-container">
+      <img class="partner-gifs"
+        src="/images/topic/instant-apps/s3-ParkandPay-static.png"
+        data-stat="/images/topic/instant-apps/s3-ParkandPay-static.png"
+        data-anim="/images/topic/instant-apps/s3-ParkandPay-animated.gif">
+      <p class="figure-caption">
+        <em>Park and Pay<br/>
+            (via NFC)</em>
+      </p>
+    </div>
+  </div>
+</div>
+
+<!-- Fourth section -->
+
+<div class="wrap" style="margin-top:60px">
+<div class="cols dac-hero-content">
+  <div class="col-1of2 dac-hero-figure">
+    <img src="/images/topic/instant-apps/instant-apps-section-4.png">
+  </div>
+<div class="col-1of2">
+<div class="dac-hero-tag"></div>
+
+  <h2 id="section-4">Built On Google Play Services</h2>
+  <p class="dac-hero-description">
+    Take advantage of Google Play services features &mdash; like location, identity,
+    payments, and Firebase &mdash; which are built right in for a seamless user
+    experience.
+  </p>
+
+</div>
+</div>
+</div>
+
+<!-- Fifth section -->
+
+<div class="wrap" style="margin-top:60px">
+<div class="cols dac-hero-content">
+  <div class="col-1of2 col-push-1of2 dac-hero-figure">
+    <img src="/images/topic/instant-apps/instant-apps-section-5.png">
+  </div>
+<div class="col-1of2 col-pull-1of2">
+<div class="dac-hero-tag"></div>
+  <h2 id="section-5">Works On Most Android Devices</h2>
+
+  <p class="dac-hero-description">
+
+    Android Instant Apps can work on Android devices running Android 4.1+
+    (API Level 16) or higher with Google Play services.
+  </p>
+
+</div>
+</div>
+</div>
+
+<!-- Sixth section -->
+
+<div class="wrap" style="margin-top:60px">
+<div class="cols dac-hero-content">
+  <div class="col-1of2 dac-hero-figure">
+    <img src="/images/topic/instant-apps/upgrade-your-app-2x.png">
+  </div>
+<div class="col-1of2">
+<div class="dac-hero-tag"></div>
+
+  <h2 id="section-6">Upgrade Your Existing App</h2>
+  <p class="dac-hero-description">
+    Android Instant Apps functionality is an upgrade to your existing Android
+    app, not a new, separate app. It's the same Android APIs, the same
+    project, the same source code.  It can take less than a day to get
+    up and running for some developers, though the effort involved varies,
+    depending on how your app is structured. You modularize your app,
+    and Google Play downloads only the parts that are needed, on the fly.
+  </p>
+
+</div>
+</div>
+</div>
+
+<!-- Seventh section -->
+
+<div class="wrap" style="margin-top:60px" id="section-7">
+  <h2 id="sign-up-docs" style="margin-bottom: 0px;">
+    Sign up for access to Android Instant Apps documentation
+  </h2>
+
+  <p>
+    We’ll let you know if you’re selected for early access
+    to Android Instant
+    Apps.
+  </p>
+
+  <p>
+    <a class="landing-button green download-bundle-button"
+      href="https://docs.google.com/forms/d/1S3MzsMVIlchLCqyNLaFbv64llxWaf90QSeYLeswco90/viewform"
+      target="_blank">
+      I'M INTERESTED IN ANDROID INSTANT APPS<br>
+    </a>
+  </p>
+
+  <p style="margin-top:24px">
+    Check out our <a href="faqs.html">frequently asked questions</a> to find out
+    more about Android Instant Apps.
+  </p>
+</div>
+
+<style>
+
+  /* Sub-heading styling */
+  .sub-head {
+    font-size: 28px;
+    line-height: 125%;
+  }
+
+  /* Background color for hero module. */
+  .dac-section-light {
+    background: #B0BEC5;
+  }
+
+  /* Styling and layout for video. */
+  .dev-bytes-video {
+    margin-top: 30px;
+    position: relative;
+    padding-bottom: 56.25%; /* 16:9 */
+    padding-top: 30px;
+    height: 0;
+  }
+
+  .dev-bytes-video iframe,
+  .dev-bytes-video object,
+  .dev-bytes-video embed {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+  }
+
+  /* Increase top margin for sections */
+  .wrap {
+    margin-top: 1.5em;
+  }
+
+  #section-3, #sign-up-docs {
+    margin-top: 0px;
+    border-top: 0px;
+  }
+
+  /* Align the seventh section in the center. */
+  #section-7 {
+    text-align: center;
+  }
+
+  /* GIF section styling */
+  .figure-caption {
+    text-align: center;
+  }
+
+  .partner-gifs {
+    width: 80%;
+    height: auto;
+  }
+
+  .gif-container {
+     text-align: center;
+  }
+
+</style>
+
+<script>
+
+(function () {
+
+  function onMouseEnter(evt) {
+    if (evt.target.dataset && evt.target.dataset.anim) {
+      swap(evt.target, {
+        newStr: evt.target.dataset.anim
+      });
+    }
+  }
+
+  function onMouseOut(evt) {
+    if (evt.target.dataset && evt.target.dataset.stat) {
+      swap(evt.target, {
+        newStr: evt.target.dataset.stat
+      });
+    }
+  }
+
+  function swap(target, options) {
+    if (options && options.newStr) {
+      $(target).attr("src", options.newStr);
+    }
+  }
+
+  $(".partner-gifs").mouseenter(onMouseEnter);
+  $(".partner-gifs").mouseout(onMouseOut);
+
+})();
+
+</script>
\ No newline at end of file
diff --git a/docs/html/training/_book.yaml b/docs/html/training/_book.yaml
index 47c6904..00f9295 100644
--- a/docs/html/training/_book.yaml
+++ b/docs/html/training/_book.yaml
@@ -754,18 +754,6 @@
     - name: description
       value: How to use DHU to test Auto apps.
 
-- title: Building Apps for Work
-  path: /training/enterprise/index.html
-  section:
-  - title: Ensuring Compatibility with Managed Profiles
-    path: /training/enterprise/app-compatibility.html
-  - title: Implementing App Restrictions
-    path: /training/enterprise/app-restrictions.html
-  - title: Building a Device Policy Controller
-    path: /training/enterprise/work-policy-ctrl.html
-  - title: Configuring Corporate-Owned, Single-Use Devices
-    path: /training/enterprise/cosu.html
-
 - title: Best Practices for Interaction & Engagement
   path: /training/best-ux.html
   section:
@@ -1386,7 +1374,7 @@
     - name: description
       value: How to use the SafetyNet service to analyze a device where your app is running and get information about its compatibility with your app.
   - title: Enhancing Security with Device Management Policies
-    path: /training/enterprise/device-management-policy.html
+    path: /work/device-management-policy.html
     path_attributes:
     - name: description
       value: How to create an application that enforces security policies on devices.
diff --git a/docs/html/training/enterprise/index.jd b/docs/html/training/enterprise/index.jd
deleted file mode 100644
index d54607c..0000000
--- a/docs/html/training/enterprise/index.jd
+++ /dev/null
@@ -1,65 +0,0 @@
-page.title=Building Apps for Work
-meta.tags="work, enterprise, corporate"
-page.tags="work", "enterprise", "corporate"
-page.metaDescription=Learn how to build Android apps for the enterprise and take advantage of Google's Android for Work program.
-page.article=true
-
-@jd:body
-
-<iframe width="448" height="252"
-    src="//www.youtube.com/embed/jQWB_-o1kz4?autohide=1&amp;showinfo=0"
-    frameborder="0" allowfullscreen=""
-    style="float: right; margin: 0 0 20px 20px;"></iframe>
-
-<p>
-  The Android framework provides features to support the security, data separation, and
-  administration needs of a enterprise environment. As an app developer, you can make your app more
-  appealing to corporate customers by gracefully handling enterprise security and feature
-  restrictions. You can also modify your app so that technology administrators can remotely
-  configure it for use with enterprise resources.
-</p>
-
-<p>
-  To help businesses incorporate Android devices and apps into the workplace, Google provides the
-  <a href="http://www.google.com/work/android">Android for Work</a> program, which offers a suite
-  of APIs and services for device distribution and administration. Through this program companies
-  can connect with Enterprise Mobility Management (EMM) providers to help integrate Android with
-  their businesses.
-</p>
-
-<p>
-  For more information, follow the links below to learn how to update your Android app to support
-  the enterprise environment or build enterprise-specific solutions.
-</p>
-
-<h2 id="apps">App Development for Enterprises</h2>
-
-<p>
-  Learn how to make your app function smoothly in corporate environments that restrict device
-  features and data access. Go further to support enterprise use of your app by enabling
-  restrictions that corporate technology administrators can use to remotely configure your app:
-</p>
-
-<div class="dynamic-grid">
-  <div class="resource-widget resource-flow-layout landing col-12"
-    data-query="collection:training/work/apps"
-    data-cardSizes="6x6"
-    data-maxResults="6">
-  </div>
-</div>
-
-
-<h2 id="admin">Device and App Administration</h2>
-
-<p>
-  Learn how to build policy controller apps that enable enterprise technology administrators
-  to manage devices, manage corporate apps, and provide access to company resources:
-</p>
-
-<div class="dynamic-grid">
-  <div class="resource-widget resource-flow-layout landing col-12"
-    data-query="collection:training/work/admin"
-    data-cardSizes="6x6"
-    data-maxResults="4">
-  </div>
-</div>
diff --git a/docs/html/training/enterprise/work-policy-ctrl.jd b/docs/html/training/enterprise/work-policy-ctrl.jd
deleted file mode 100644
index 8225ea3..0000000
--- a/docs/html/training/enterprise/work-policy-ctrl.jd
+++ /dev/null
@@ -1,339 +0,0 @@
-page.title=Building a Device Policy Controller
-page.metaDescription=Learn how to develop a device policy controller to create and administer a managed profile on an employee's device.
-page.tags="work policy controller,WPC,device policy controller,DPC"
-@jd:body
-
-<div id="tb-wrapper">
-<div id="tb">
-
-<h2>This lesson teaches you to</h2>
-<ol>
- <li><a href="#after_creating_profile">Create a Managed Profile</a></li>
- <li><a href="#set_up_policies">Set Up Device Policies</a></li>
- <li><a href="#apply_restrictions">Apply App Restrictions</a></li>
-</ol>
-
-<!-- related docs (NOT javadocs) -->
-
-<h2>
-  You should also read
-</h2>
-
-<ul>
-  <li>
-    <a href="{@docRoot}guide/topics/admin/device-admin.html">Device
-    Administration</a>
-  </li>
-</ul>
-
-<h2>Resources</h2>
-<ul>
-
-  <li>
-    <a href=
-    "{@docRoot}samples/BasicManagedProfile/index.html">BasicManagedProfile</a>
-  </li>
-
-  <li>
-    <a href=
-    "{@docRoot}samples/AppRestrictionEnforcer/index.html">AppRestrictionEnforcer</a>
-  </li>
-</ul>
-
-</div>
-</div>
-
-
-<p>
-  In an Android for Work deployment, an enterprise needs to maintain control
-  over certain aspects of the employees' devices. The enterprise needs to
-  ensure that work-related information is encrypted and is kept separate from
-  employees' personal data. The enterprise may also need to limit device
-  capabilities, such as whether the device is allowed to use its camera. And
-  the enterprise may require that approved apps provide app restrictions, so
-  the enterprise can turn app capability on or off as needed.
-</p>
-
-<p>
-  To handle these tasks, an enterprise develops and deploys
-  a <em>device policy controller</em> app (previously known as a
-  <em>work policy controller</em>). This app is installed on each employee's device. The
-  controller app installed on each employee's device and creates a work user
-  profile, which accesses enterprise apps and data separately from the user's
-  personal account. The controller app also acts as the
-  bridge between the enterprise's management software and the device; the
-  enterprise tells the controller app when it needs to make configuration
-  changes, and the controller app makes the appropriate settings changes for the
-  device and for other apps.
-</p>
-
-<p>
-  This lesson describes how to develop a device policy controller app for devices
-  in an Android for Work deployment. The lesson describes how to create a work
-  user profile, how to set device policies, and how to apply
-  restrictions to other apps running on the managed profile.
-</p>
-
-<p class="note">
-  <strong>Note:</strong> This lesson does not cover the situation where the
-  only profile on the device is the managed profile, under the enterprise's
-  control.
-</p>
-
-<h2 id="overview">Device Administration Overview</h2>
-
-<p>
-  In an Android for Work deployment, the enterprise administrator can set
-  policies to control the behavior of employees' devices and apps. The
-  enterprise administrator sets these policies with software provided by their
-  Enterprise Mobility Management (EMM) provider. The EMM software communicates
-  with a device policy controller on each device. The device policy controller, in
-  turn, manages the settings and behavior of the work user profile on each
-  individual’s device.
-</p>
-
-<p class="note">
-  <strong>Note:</strong> A device policy controller is built on the existing
-  model used for device administration applications, as described in <a href=
-  "{@docRoot}guide/topics/admin/device-admin.html">Device Administration</a>.
-  In particular, your app needs to create a subclass of {@link
-  android.app.admin.DeviceAdminReceiver}, as described in that document.
-</p>
-
-<h3 id="managed_profiles">Managed profiles</h3>
-
-<p>
-  Users often want to use their personal devices in an enterprise setting. This
-  situation can present enterprises with a dilemma. If the user can use their
-  own device, the enterprise has to worry that confidential information (like
-  employee emails and contacts) are on a device the enterprise does not
-  control.
-</p>
-
-<p>
-  To address this situation, Android 5.0 (API level 21) allows enterprises to
-  set up a special work user profile using the Managed Profile API. This
-  user profile is called a <em>managed profile</em>, or a <em>work profile</em>
-  in the Android for Work program. If a device has a
-  managed profile for work, the profile's settings are under the control of the
-  enterprise administrator. The administrator can choose which apps are allowed
-  for that profile, and can control just what device features are available to
-  the profile.
-</p>
-
-<h2 id="create_profile">Create a Managed Profile</h2>
-
-<p>To create a managed profile on a device that already has a personal profile,
-first check that the device can support a managed profile, by seeing if the
-device supports the {@link
-android.content.pm.PackageManager#FEATURE_MANAGED_USERS FEATURE_MANAGED_USERS}
-system feature:</p>
-
-<pre>PackageManager pm = getPackageManager();
-if (!pm.hasSystemFeature(PackageManager.FEATURE_MANAGED_USERS)) {
-
-    // This device does not support native managed profiles!
-
-}</pre>
-
-<p>If the device supports managed profiles, create one by sending an intent with
-an {@link android.app.admin.DevicePolicyManager#ACTION_PROVISION_MANAGED_PROFILE
-ACTION_PROVISION_MANAGED_PROFILE} action. Include the device admin package
-name as an extra.</p>
-
-<pre>Activity provisioningActivity = getActivity();
-
-// You'll need the package name for the WPC app.
-String myWPCPackageName = "com.example.myWPCApp";
-
-// Set up the provisioning intent
-Intent provisioningIntent =
-        new Intent("android.app.action.PROVISION_MANAGED_PROFILE");
-intent.putExtra(myWPCPackageName,
-        provisioningActivity.getApplicationContext().getPackageName());
-
-if (provisioningIntent.resolveActivity(provisioningActivity.getPackageManager())
-         == null) {
-
-    // No handler for intent! Can't provision this device.
-    // Show an error message and cancel.
-} else {
-
-    // REQUEST_PROVISION_MANAGED_PROFILE is defined
-    // to be a suitable request code
-    startActivityForResult(provisioningIntent,
-            REQUEST_PROVISION_MANAGED_PROFILE);
-    provisioningActivity.finish();
-}</pre>
-
-<p>The system responds to this intent by doing the following:</p>
-
-<ul>
-  <li>Verifies that the device is encrypted. If it is not, the system prompts
-  the user to encrypt the device before proceeding.
-  </li>
-
-  <li>Creates a managed profile.
-  </li>
-
-  <li>Removes non-required applications from the managed profile.
-  </li>
-
-  <li>Copies the device policy controller app into the managed profile and
-    sets it as the profile owner.
-  </li>
-</ul>
-
-<p>Override {@link android.app.Activity#onActivityResult onActivityResult()} to
-see whether the provisioning was successful, as shown in the following 
-example code:</p>
-
-<pre>&#64;Override
-public void onActivityResult(int requestCode, int resultCode, Intent data) {
-
-    // Check if this is the result of the provisioning activity
-    if (requestCode == REQUEST_PROVISION_MANAGED_PROFILE) {
-
-        // If provisioning was successful, the result code is 
-        // Activity.RESULT_OK
-        if (resultCode == Activity.RESULT_OK) {
-            // Hurray! Managed profile created and provisioned!
-        } else {
-            // Boo! Provisioning failed!
-        }
-        return;
-
-    } else {
-        // This is the result of some other activity, call the superclass
-        super.onActivityResult(requestCode, resultCode, data);
-    }
-}</pre>
-
-<h3 id="after_creating_profile">After Creating the Managed Profile</h3>
-
-<p>When the profile has been provisioned, the system calls the device policy
-controller app's {@link android.app.admin.DeviceAdminReceiver#onProfileProvisioningComplete
-DeviceAdminReceiver.onProfileProvisioningComplete()} method. Override this
-callback method to finish enabling the managed profile.</p>
-
-<p>Typically, your {@link
-android.app.admin.DeviceAdminReceiver#onProfileProvisioningComplete
-DeviceAdminReceiver.onProfileProvisioningComplete()} callback implementation
-would perform these tasks:</p>
-
-<ul>
-  <li>Verify that the device is complying with the EMM's device policies, as
-  described in <a href="#set_up_policies">Set Up Device Policies</a>
-  </li>
-
-  <li>Enable any system applications that the administrator chooses to make
-  available within the managed profile, using {@link
-  android.app.admin.DevicePolicyManager#enableSystemApp
-  DevicePolicyManager.enableSystemApp()}   </li>
-
-  <li>If the device uses Google Play for Work, add the Google account
-  to the managed profile with {@link android.accounts.AccountManager#addAccount
-  AccountManager.addAccount()}, so administrators can install
-  applications to the device
-  </li>
-</ul>
-
-<p>Once you have completed these tasks, call the device policy manager's
-{@link android.app.admin.DevicePolicyManager#setProfileEnabled
-setProfileEnabled()} method to activate the managed profile:</p>
-
-
-<pre>// Get the device policy manager
-DevicePolicyManager myDevicePolicyMgr =
-        (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
-
-ComponentName componentName = myDeviceAdminReceiver.getComponentName(this);
-
-// Set the name for the newly created managed profile.
-myDevicePolicyMgr.setProfileName(componentName, "My New Managed Profile");
-
-// ...and enable the profile
-manager.setProfileEnabled(componentName);</pre>
-
-<h2 id="set_up_policies">Set Up Device Policies</h2>
-
-<p>
-  The device policy controller app is responsible for applying the enterprise's
-  device policies. For example, a particular enterprise might require that all
-  devices become locked after a certain number of failed attempts to enter the
-  device password. The controller app queries the EMM to find out what
-  the current policies are, then uses the <a href=
-  "{@docRoot}guide/topics/admin/device-admin.html">Device Administration</a>
-  API to apply those policies.
-</p>
-
-<p>For information on how to apply device policies, see the 
-<a href="{@docRoot}guide/topics/admin/device-admin.html#policies">Device
-Administration</a> guide.</p>
-
-
-<h2 id="apply_restrictions">Apply App Restrictions</h2>
-
-<p>Enterprise environments may require that approved apps implement security
-or feature restrictions. App developers must implement these restrictions
-and declare them for use by enterprise administrators, as described in
-<a href="{@docRoot}training/enterprise/app-restrictions.html">Implementing
-App Restrictions</a>. The device policy controller receives restriction changes
-from the enterprise administrator, and forwards those restriction changes to the apps.</p>
-
-<p>For example, a particular news app might have a restriction setting that
-controls whether the app is allowed to download videos over a cellular
-network. When the EMM wants to disable cellular downloads, it sends a
-notification to the controller app. The controller app, in turn,
-notifies the news app that the restriction setting has changed.</p>
-
-<p class="note"><strong>Note:</strong> This document covers how the device policy
-controller app changes the restriction settings for the other apps on the
-managed profile. Details on how the device policy controller app communicates with
-the EMM are out of scope for this document.</p>
-
-<p>To change an app's restrictions, call the {@link
-android.app.admin.DevicePolicyManager#setApplicationRestrictions
-DevicePolicyManager.setApplicationRestrictions()} method. This method is passed
-three parameters: the controller app's {@link
-android.app.admin.DeviceAdminReceiver}, the package name of the app whose
-restrictions are being changed, and a {@link android.os.Bundle Bundle} that
-contains the restrictions you want to set.</p>
-
-<p>For example, suppose there's an app on the managed profile with the package
-name <code>"com.example.newsfetcher"</code>. This app has a single boolean
-restriction that can be configured, with the key
-<code>"downloadByCellular"</code>. If this restriction is set to
-<code>false</code>, the newsfetcher app is not allowed to download data through
-a cellular network; it must use a Wi-Fi network instead.</p>
-
-<p>
-  If your device policy controller app needs to turn off cellular downloads, it
-  would first fetch the device policy service object, as described above. It
-  then assembles a restrictions bundle and passes this bundle to {@link
-  android.app.admin.DevicePolicyManager#setApplicationRestrictions
-  setApplicationRestrictions()}:
-</p>
-
-<pre>// Fetch the DevicePolicyManager
-DevicePolicyManager myDevicePolicyMgr =
-        (DevicePolicyManager) thisActivity
-                .getSystemService(Context.DEVICE_POLICY_SERVICE);
-
-// Set up the restrictions bundle
-bundle restrictionsBundle = new Bundle();
-restrictionsBundle.putBoolean("downloadByCellular", false);
-
-// Pass the restrictions to the policy manager. Assume the WPC app
-// already has a DeviceAdminReceiver defined (myDeviceAdminReceiver).
-myDevicePolicyMgr.setApplicationRestrictions(
-        myDeviceAdminReceiver, "com.example.newsfetcher", restrictionsBundle);</pre>
-
-
-<p class="note"><strong>Note:</strong> The device policy service conveys the restrictions
-change to the app you name. However, it is up to that app to actually implement
-the restriction. For example, in this case, the app would be responsible for
-disabling its ability to use cellular networks for video downloads. Setting the
-restriction does not cause the system to enforce this restriction on the app.
-For more information, see <a href="{@docRoot}training/enterprise/app-
-restrictions.html">Implementing App Restrictions</a>.</p>
diff --git a/docs/html/training/training_toc.cs b/docs/html/training/training_toc.cs
index 2c0fb4e..e2aa5f4 100644
--- a/docs/html/training/training_toc.cs
+++ b/docs/html/training/training_toc.cs
@@ -1187,37 +1187,6 @@
   </li>
   <!-- End: Building for Auto -->
 
-
-  <!-- Start: Building for Work -->
-  <li class="nav-section">
-    <div class="nav-section-header">
-      <a href="<?cs var:toroot ?>training/enterprise/index.html">
-      <span class="small">Building Apps for</span><br/>
-              Work
-      </a>
-    </div>
-    <ul>
-      <li><a href="<?cs var:toroot ?>training/enterprise/app-compatibility.html">
-        Ensuring Compatibility with Managed Profiles
-      </a>
-      </li>
-      <li><a href="<?cs var:toroot ?>training/enterprise/app-restrictions.html">
-        Implementing App Restrictions
-      </a>
-      </li>
-      <li><a href="<?cs var:toroot ?>training/enterprise/work-policy-ctrl.html">
-        Building a Device Policy Controller
-      </a>
-      </li>
-      <li><a href="<?cs var:toroot ?>training/enterprise/cosu.html">
-        Configuring Corporate-Owned, Single-Use Devices
-      </a>
-      </li>
-    </ul>
-  </li>
-  <!-- End: Building for Work -->
-
-
   <li class="nav-section">
     <div class="nav-section-header">
       <a href="<?cs var:toroot ?>training/best-ux.html">
@@ -2118,7 +2087,7 @@
       </li>
 
       <li>
-        <a href="<?cs var:toroot ?>training/enterprise/device-management-policy.html"
+        <a href="<?cs var:toroot ?>work/device-management-policy.html"
             description="How to create an application that enforces security policies on devices."
             >Enhancing Security with Device Management Policies</a>
       </li>
diff --git a/docs/html/wear/index.jd b/docs/html/wear/index.jd
index 62c0253..f5e9e87 100644
--- a/docs/html/wear/index.jd
+++ b/docs/html/wear/index.jd
@@ -68,14 +68,43 @@
         </div>
       </div> <!-- end .wrap -->
       <div class="landing-scroll-down-affordance">
-        <a class="landing-down-arrow" href="#extending-android-to-wearables">
+        <a class="landing-down-arrow" href="#next-section">
           <img src="{@docRoot}wear/images/carrot.png" alt="Scroll down to read more">
         </a>
       </div>
     </div> <!-- end .landing-section .landing-hero -->
 
 
-    <div class="landing-rest-of-page">
+    <div class="landing-rest-of-page" id="next-section">
+
+
+      <section class="dac-expand dac-hero dac-light" style="background-color:#FFFFFF">
+        <div class="wrap" style="max-width:1100px;margin-top:0">
+          <div class="cols dac-hero-content" style="padding-bottom:1em;">
+
+            <div class="col-7of16 col-push-9of16" style="padding-left:2em">
+              <h1 class="dac-hero-title">Android Wear 2.0 Developer Preview</h1>
+              <p class="dac-hero-description">
+                Get ready for the next version of Android Wear!
+                Support stand-alone Wear devices and apps.
+                Create enhanced user interaction and glanceable experiences.
+                Test your apps on Wear devices.
+              </p>
+
+              <a class="dac-hero-cta" href="{@docRoot}wear/preview/index.html">
+                <span class="dac-sprite dac-auto-chevron"></span>
+                Get started
+              </a>
+            </div>
+            <div class="col-9of16 col-pull-7of16 dac-hero-figure" style="margin-top:1.5em;padding-right:1.5em;">
+              <img class="dac-hero-image" src="{@docRoot}wear/preview/images/hero-1x.png"
+                   srcset="{@docRoot}wear/preview/images/hero-1x.png 1x,
+                   {@docRoot}wear/preview/images/hero-2x.png 2x">
+            </div>
+          </div>
+        </div>
+      </section>
+
       <div class="landing-section" id="extending-android-to-wearables">
         <div class="wrap">
           <div class="landing-section-header">
diff --git a/docs/html/wear/preview/_book.yaml b/docs/html/wear/preview/_book.yaml
new file mode 100644
index 0000000..a4acad0
--- /dev/null
+++ b/docs/html/wear/preview/_book.yaml
@@ -0,0 +1,32 @@
+toc:
+- title: Wear Developer Preview
+  path: /wear/preview/index.html
+
+- title: Program Overview
+  path: /wear/preview/program.html
+
+- title: API Overview
+  path: /wear/preview/api-overview.html
+  section:
+  - title: Notification Improvements
+    path: /wear/preview/features/notifications.html
+  - title: Input Method Framework
+    path: /wear/preview/features/ime.html
+  - title: Complications
+    path: /wear/preview/features/complications.html
+  - title: Navigation and Actions
+    path: /wear/preview/features/ui-nav-actions.html
+  - title: Bridging for Notifications
+    path: /wear/preview/features/bridger.html
+
+- title: Get Started
+  path: /wear/preview/start.html
+
+- title: Download and Test
+  path: /wear/preview/downloads.html
+
+- title: License Agreement
+  path: /wear/preview/license.html
+
+- title: Support and Release Notes
+  path: /wear/preview/support.html
diff --git a/docs/html/wear/preview/api-overview.jd b/docs/html/wear/preview/api-overview.jd
new file mode 100644
index 0000000..384cb0a
--- /dev/null
+++ b/docs/html/wear/preview/api-overview.jd
@@ -0,0 +1,333 @@
+page.title=Preview API Overview
+meta.tags="wear", "wear-preview"
+page.tags="wear"
+page.image=images/cards/card-n-apis_2x.png
+@jd:body
+
+
+
+
+<div id="qv-wrapper">
+<div id="qv">
+  <h2>Key developer features</h2>
+  <ol>
+      <ul style="list-style-type:none;">
+        <li><a href="#ui">User Interface Improvements</a>
+          <ol>
+            <li><a href="#complications">Complications</a></li>
+            <li><a href="#drawers">Navigation and Action Drawers</a></li>
+          </ol>
+        </li>
+
+        <li><a href="#notify">Notifications and Input</a>
+          <ol>
+            <li><a href="#expanded">Expanded Notification</a></li>
+            <li><a href="#messaging">Messaging Style Notification</a></li>
+            <li><a href="#smart-replies">Smart Reply</a></li>
+            <li><a href="#content-action">Notification Content Action</a>
+            <li><a href="#remote-input">Remote Input</a></li>
+            <li><a href="#bridging">Bridging Mode</a></li>
+            <li><a href="#imf">Input Method Framework</a></li>
+          </ol>
+        </li>
+
+        <li><a href="#stand-alone">Standalone Devices</a>
+          <ol>
+            <li><a href="#wear-apk">Wear-Specific APKs</a></li>
+            <li><a href="#network">Network Access</a></li>
+            <li><a href="#auth">Authentication</a></li>
+          </ol>
+        </li>
+      </ol>
+</div>
+</div>
+
+
+
+<p>
+  The Android Wear Preview API is still in active development, but you can try
+  it now as part of the Wear 2.0 Developer Preview. The sections below
+  highlight some of the new features for Wear developers.
+</p>
+
+
+<h2 id="ui">User Interface Improvements</h2>
+
+<p>The preview introduces powerful additions to the user interface, opening up
+exciting possibilities to developers.
+A complication is any feature in a watch face that displays more than hours and
+minutes. With the Complications API,
+ watch faces can display extra information and separate apps can expose complication
+  data.
+The navigation and action drawers provide users with new ways to interact with apps.
+</p>
+
+
+<h3 id="complications">Complications</h3>
+<img src="{@docRoot}wear/preview/images/complications-main-image.png"
+  height="320" style="float:right;margin:10px 0 0 40px" />
+
+<p>
+  A <a href=
+  "https://en.wikipedia.org/wiki/Complication_(horology)">complication</a> is a
+  feature of a watch face that displays more than hours and minutes, such as a
+  battery indicator or a step counter. The Complications API helps watch face
+  developers create these features visual features and data connections they
+  require.
+</p>
+
+<p>
+  Watch faces that use this API can display extra information without needing
+  code for getting the underlying data. Data providers can supply data to any
+  watch face using the API.
+</p>
+
+<p>For examples of how to use this feature,
+see <a href="{@docRoot}wear/preview/features/complications.html">
+ Watch Face Complications</a>.
+</p>
+
+
+<h3 id="drawers">Navigation and Action drawers</h3>
+
+<p>Wear 2.0 introduces two new widgets, navigation drawer and action drawer. These
+ widgets give your users new ways to interact with your app. The navigation drawer
+  appears at the top of the screen and allows users to navigate between app views.
+   The  action drawer appears at the bottom of the screen and allows users to choose
+    from a list of actions associated with the current usage context.  These drawers
+     are accessible to users when they edge swipe from the top or bottom of the
+     screen; they peek when users scroll in an opposite direction.
+</p>
+
+<div class="cols">
+  <div class="col-2of6">
+    <img src="{@docRoot}wear/preview/images/nav_drawer.gif"
+      height="240" alt="" style="padding:.5em">
+  </div>
+  <div class="col-2of6">
+    <img src="{@docRoot}wear/preview/images/action_drawer.gif"
+      height="240" alt="" style="padding:.5em;">
+  </div>
+</div>
+
+<p>
+  To learn how to add these widgets to your app, see
+  <a href="{@docRoot}wear/preview/features/ui-nav-actions.html">
+  Wear Navigation and Actions</a>.
+</p>
+
+
+<h2 id="notify">Notifications and Input</h2>
+
+<p>In Wear 2.0, we’ve redesigned the key experiences on the watch to be even more
+ intuitive and provide users new ways to respond to messages. Some of the highlights
+  are below; for a complete list of changes, see
+  <a href="{@docRoot}wear/preview/features/notifications.html">Notification Changes in Wear 2.0</a>.
+
+
+<img src="{@docRoot}wear/preview/images/expanded_diagram.png" height="340"
+  style="float:left;margin:10px 20px 0 0" />
+<h3 id="expanded">Expanded notifications</h3>
+
+<p>
+  When a user taps on a notification that is bridged from the phone to the
+  watch or that lacks a
+  <a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.Builder.html#setContentIntent(android.app.PendingIntent)">
+  {@code contentIntent}</a>, the user will be taken to the expanded view of
+  that notification. When you <a href=
+  "{@docRoot}training/wearables/notifications/pages.html">specify additional
+  content pages</a> and actions for a notification, those are available to the
+  user within the expanded notification. Each expanded notification follows
+  <a href="https://google.com/design/spec-wear">Material Design for Android
+  Wear</a>, so the user gets an app-like experience.
+</p>
+
+
+<h3 id="messaging">Messaging Style notification</h3>
+<p> If you have a chat messaging app, your notifications should use
+{@code Notification.MessagingStyle}, which is new in Android 6.0. Wear 2.0 uses
+the chat messages included in a
+<a href="{docRoot}preview/features/notification-updates.html#style">{@code MessagingStyle}</a>
+ notification
+(see {@code addMessage()}) to provide a rich chat app-like experience in the
+expanded notification.
+</p>
+
+
+<h3 id="smart-replies">Smart Reply</h3>
+
+<p>Android Wear 2.0 introduces support for Smart Reply in
+<a href="{@docRoot}wear/preview/features/notifications.html#messaging">{@code MessagingStyle}</a>
+ notifications. Smart Reply provides the user with contextually relevant,
+ touchable choices in the expanded notification and in
+ <a href="{@docRoot}reference/android/app/RemoteInput.html">{@code RemoteInput}</a>.
+</p>
+
+<p>By enabling Smart Reply for your {@code MessagingStyle} notifications, you provide
+users a fast (single tap), discreet (no speaking aloud), and reliable way to respond
+ to chat messages they receive.
+ </p>
+
+
+<img src="{@docRoot}wear/preview/images/remoteinput.png" height="350"
+  style="float:right;margin:10px 0 0 40px" />
+
+<h3 id="remote-input">Remote Input</h3>
+
+<p>Wear 2.0 users can choose between various input options from
+<a href="{@docRoot}reference/android/app/RemoteInput.html">Remote Input</a>.
+ These options include:
+</p>
+<ul>
+<li>Dictation</li>
+<li>Emoji</li>
+<li>Canned responses</li>
+<li>Smart Reply</i>
+<li>Default IME </i>
+</ul>
+
+<p>
+For messaging notifications with Smart Reply, the system-generated Smart Reply
+ appears within <a href="{@docRoot}reference/android/app/RemoteInput.html">{@code RemoteInput}</a>
+  above the developer-provided list of canned responses.
+  You can also use the
+  <a href="{@docRoot}reference/android/app/RemoteInput.Builder.html#setChoices(java.lang.CharSequence[])">setChoices()</a>
+   method in the {@code RemoteInput} API to enable users to select from a list
+   of canned responses.
+</p>
+
+<h3 id="bridging"> Bridging Mode </h3>
+<p>By default, notifications are
+<a href="{@docRoot}training/wearables/notifications/index.html">
+bridged</a> (shared) from an app on a companion phone
+to the watch. Since a phone app and a standalone watch app may be sources of the
+ same notifications, the Android Wear 2.0 Preview includes a Bridging mode feature.
+  Developers can begin planning to change the behavior of notifications with the
+  following:
+</p>
+
+<ul>
+<li>Specifying in the standalone app's Android manifest file that notifications from
+ the corresponding phone app should not be bridged to the watch. </li>
+<li>Setting a dismissal ID so notification dismissals (by users) are synced across
+devices.</li>
+</ul>
+
+<p>For an example of how to use this feature, see <a href="{@docRoot}wear/preview/features/bridger.html">
+Bridging Mode for Notifications</a>.</p>
+
+<h3 id="imf">Input Method Framework</h3>
+
+<p>Wear 2.0 extends the Android input method framework (IMF) to Android Wear.
+This allows users to enter text on Wear using the system default IME or third party
+ IMEs.  The Wear IME lets the user enter text via gesture typing as well as tapping
+  individual keys. The IMF APIs used for Wear devices are the same as other form
+  factors, though usage is slightly different due to limited screen real estate.
+</p>
+
+<p>Wear provides user settings on the watch that let the user:</p>
+<ul>
+<li>Enable multiple IMEs from the list of installed IMEs.</li>
+<li>Set a single default IME from the list of enabled IMEs.</li>
+<li>Change languages for various IMEs.</li>
+</ul>
+
+<p>To learn how to create an IME for Wear, see <a href="{@docRoot}wear/preview/features/ime.html">
+Input Method Framework</a>.
+</p>
+
+
+<h2 id="stand-alone">Standalone Devices</h2>
+
+<p>Standalone watches will enable Android Wear apps to work independently of phone
+ apps. This means your app can continue to offer full functionality even if the
+ paired phone is far away or turned off. </p>
+
+<h3 id="wear-apk">Wear-Specific APKs</h3>
+
+<p>For delivery to a watch, an Android Wear app is currently embedded in its corresponding
+phone app. This delivery method can result in an increased download size for users,
+ regardless of whether they have an Android Wear device.
+</p>
+
+<p>With standalone devices, the
+<a href ="{@docRoot}google/play/publishing/multiple-apks.html">Multi-APK</a>
+ delivery method will be used. Developers will have the ability to release Android
+  Wear apps independently of the corresponding phone apps. Please stay tuned for
+   more information about this change.
+</p>
+
+<h3 id="network">Network Access</h3>
+
+<p>Since Android Wear apps will work independently of phone apps, Android Wear's
+ network access will no longer require the
+ <a href="{@docRoot}training/wearables/data-layer/index.html">
+ Wearable Data Layer API</a>. Android Wear apps will have the ability to make
+ their own network requests. Additionally, they will be able to directly use
+ Google Cloud Messaging.
+</p>
+
+<p>No APIs for network access or GCM are specific to Android Wear; refer to the
+existing documentation about
+<a href="{@docRoot}training/basics/network-ops/connecting.html">
+Connecting to the Network</a> and
+<a href="https://developers.google.com/cloud-messaging/">Cloud Messaging</a>.
+</p>
+
+<p>We recommend using the following libraries:</p>
+<ul>
+<li><a href="{@docRoot}reference/android/app/job/JobScheduler.html">
+JobScheduler</a> for asynchronous jobs, including polling at regular intervals
+</li>
+<li>Multi-networking APIs if you need to connect to specific network types; see
+the <a href="{@docRoot}about/versions/android-5.0.html#Wireless">
+Multiple Network Connections</a>
+</li>
+</ul>
+
+<p>You will still be able to use the
+<a href="{@docRoot}training/wearables/data-layer/index.html">
+ Wearable Data Layer API</a> to communicate with a phone app.
+ However, use of this API to connect to a network will be discouraged.
+ </p>
+
+
+<h3 id="auth">Authentication</h3>
+
+<p>Since Android Wear apps will work independently of phone apps, Android Wear's
+ authentication capabilities will be more powerful; apps will have new ways to
+ authenticate.</p>
+
+ <h4> Authentication tokens can be passed over the Wearable Data Layer </h4>
+
+<p>For Android-paired watches (only), the phone will securely transfer authentication
+ data to a watch app via the
+ <a href="{@docRoot}training/wearables/data-layer/index.html">
+ Wearable Data Layer API</a>. The data can be transferred as
+ Messages or Data Items. </p>
+
+<p>If your watch app needs to determine if your phone app is installed, you can
+advertise a capability on the phone app and retrieve the capability on the watch.
+ For more information, see following sections of
+ <a href="{@docRoot}training/wearables/data-layer/messages.html">
+ Sending and Receiving Messages</a>:
+ <ul>
+ <li>Advertise Capabilities</li>
+ <li>Retrieve the Nodes with the Required Capabilities</li>
+ </ul>
+<h4>Users can enter a username and password on a watch</h4>
+
+<p>Google Keyboard will be standard on Android Wear, allowing for direct text entry.
+ This feature will work as expected with standard
+ <a href="{@docRoot}reference/android/widget/EditText.html">
+  EditText widgets</a>. For passwords, the {@code textPassword} attribute will be
+   used.
+
+<h4>Utilizing Account Manager</h4>
+Android Wear will include the <a href="{@docRoot}reference/android/accounts/AccountManager.html">
+AccountManager</a>, which will be accessible for syncing and storing account
+ data, as it is on an Android phone.
+</p>
+
+
+
diff --git a/docs/html/wear/preview/downloads.jd b/docs/html/wear/preview/downloads.jd
new file mode 100644
index 0000000..b119d57
--- /dev/null
+++ b/docs/html/wear/preview/downloads.jd
@@ -0,0 +1,650 @@
+page.title=Download and Test with a Device
+meta.keywords="wear-preview"
+page.tags="wear-preview"
+page.image=images/cards/card-n-downloads_2x.png
+
+@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 Wear 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 Wear SDK Preview License Agreement (the “License Agreement”).
+
+1. Introduction
+
+1.1 The Android Wear 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">
+
+    <div id="qv-wrapper">
+      <div id="qv">
+        <ol>
+          <li>
+            <a href="#set_up_a_watch">Set Up a Watch</a>
+          </li>
+
+          <li>
+            <a href="#set_up_an_emulator">Set Up an Emulator</a>
+          </li>
+        </ol>
+      </div>
+    </div>
+
+    <p>
+      You can run and test your app with the Android Wear 2.0 Developer Preview
+      in either of these ways:
+    </p>
+
+    <ul>
+      <li>Install Android Wear 2.0 on a supported watch, or
+      </li>
+
+      <li>Set up an emulator that is running Android Wear 2.0
+      </li>
+    </ul>
+
+    <p>
+      If you want an environment for basic compatibility
+      testing of your app, you can use your current APK and a
+      supported watch or an emulator. As described below, you don't necessarily
+      need to update your full development environment to do basic testing.
+    </p>
+
+    <p>
+      However, if you want to modify your app to target
+      Android Wear 2.0 or use new APIs, you need to update your development
+      environment. See <a href="{@docRoot}wear/preview/start.html">Get Started
+      with the Preview</a>.
+    </p>
+
+    <h2 id="set_up_a_watch">
+      Set Up a Watch
+    </h2>
+
+    <p>
+      You can download a system image and manually flash it to a matching
+      watch. See the table below to download the image for your test
+      watch.
+    </p>
+
+    <p>
+      Manually flashing a watch is useful if you need precise control over the
+      test environment or need to reinstall frequently, such as for automated
+      testing.
+    </p>
+
+    <p class="warning">
+      <strong>Warning:</strong> Installing a system image on a watch removes all data from the
+      watch, so you should back up your data first.
+    </p>
+
+    <h3 id="preview_system_images">
+      Preview system images
+    </h3>
+
+    <p>
+      The preview includes system images for testing your app. Based on your
+      device, you can download a preview system image from the following tables
+      and flash it to the corresponding device.
+    </p>
+
+    <h4 id="preview_image_for_lge_watch_urbane_2nd_edition">
+      Preview image for LGE Watch Urbane 2nd Edition
+    </h4>
+
+    <p class="caution">
+      <strong>Caution:</strong> Flashing your device will
+      require unlocking the bootloader which may
+      void the device's warranty--proceed at your own risk.
+     </p>
+
+    <table>
+      <tr>
+        <th style="width:300px">
+          Type of LGE Watch Urbane 2nd Edition image
+        </th>
+        <th>
+          Download/Checksums
+        </th>
+      </tr>
+
+      <tr id="nemo-preview">
+        <td>
+          Preview image for testing
+        </td>
+        <td><a href="#top" onclick="onDownload(this)">nemo-nvd36i-factory-9cdd2ac0.tgz</a><br>
+          MD5: b33ba8e59780fbe5c83d8936b108640f<br>
+          SHA-1: 9cdd2ac01f2976cafe5a21958298dac159b7a325
+        </td>
+      </tr>
+
+      <tr id="nemo-non-preview">
+        <td>
+          Non-preview image (for after testing)
+        </td>
+        <td><a href="#top" onclick="onDownload(this)">nemo-mnc40x-factory-fa528bec.tgz</a><br>
+          MD5: 0b8ba3653d5a93cb854f4d7409d7b6c9<br>
+          SHA-1: fa528bec8aba3bf6c7d901ba63cd6ea0a08dbeb0
+        </td>
+      </tr>
+
+    </table>
+
+    <h4 id="preview_image_for_huawei_watch">
+      Preview image for Huawei Watch
+    </h4>
+
+    <p class="caution">
+      <strong>Caution:</strong> Flashing your device will require unlocking
+      the bootloader which
+      shall void the device's warranty--proceed at your own risk.
+    </p>
+
+    <table>
+      <tr>
+        <th style="width:300px">
+          Type of Huawei Watch image
+        </th>
+        <th>
+          Download/Checksums
+        </th>
+      </tr>
+      <tr id="sturgeon-preview">
+        <td>
+          Preview image for testing
+        </td>
+        <td><a href="#top" onclick="onDownload(this)">sturgeon-nvd36i-factory-2cbe5080.tgz</a><br>
+          MD5: ccc972cdc33cba778a2f624066ef5713<br>
+          SHA-1: 2cbe5080ded060ce43ba65ff27e2290b28981634
+        </td>
+      </tr>
+      <tr id="sturgeon-non-preview">
+        <td>
+          Non-preview image (for after testing)
+        </td>
+        <td><a href="#top" onclick="onDownload(this)">sturgeon-mec23l-factory-48003078.tgz</a><br>
+          MD5: 417b5cbddb29a2262bce133e283d2732<br>
+          SHA-1: 4800307843580f818557dd7c43d8ba2161e289b2
+        </td>
+      </tr>
+    </table>
+
+    <h3 id="flash_a_watch">
+      Flash a watch
+    </h3>
+
+    <p>
+      The steps for flashing an image to a watch are similar to the <a href=
+      "https://developers.google.com/android/nexus/images">steps provided for
+      flashing to a phone</a>. After you back up your watch
+      data, use steps in this section to flash the image to the
+      specific watch that matches the image (e.g., you must
+      use an LGE Watch Urbane 2nd Edition for the corresponding image).
+    </p>
+
+    <p class="warning">
+      <strong>Warning:</strong> Installing a system image on a watch removes all data from the
+      watch, so you should back up your data first.
+    </p>
+
+    <h4 id="set_up_the_watch_to_be_flashed">
+      Set up the watch to be flashed
+    </h4>
+
+    <p>
+      From the phone, unpair ("Forget") the watch.
+      Then on the watch, enable the Developer Options menu and ADB debugging as
+      follows:
+    </p>
+
+    <ol>
+      <li>Open the Settings menu on the watch.
+      </li>
+
+      <li>Scroll to the bottom of the menu. If no <strong>Developer
+      Options</strong> item is provided, tap <strong>About</strong>.
+      </li>
+
+      <li>Tap the build number 7 times.
+      </li>
+
+      <li>From the Settings menu, tap the <strong>Developer Options</strong>
+      item.
+      </li>
+
+      <li>Enable ADB debugging.
+      </li>
+    </ol>
+
+    <h4 id="confirm_installation_of_the_fastboot_tool">
+      Confirm installation of the fastboot tool
+    </h4>
+
+    <p>
+      To flash a device using one of the <a href=
+      "#preview_system_images">system images</a>, confirm that you have the
+      <code>fastboot</code> tool in the <code>platform-tools/</code> directory
+      of the <a href="https://developer.android.com/sdk">Android SDK</a>. Be
+      sure that you have the latest version of the <strong>Android SDK
+      Platform-tools</strong> from the <a href=
+      "{@docRoot}tools/help/sdk-manager.html">SDK Manager</a>.
+    </p>
+
+    <p>
+      After you confirm that you have the <code>fastboot</code> tool, add the
+      tool to your PATH environment variable so the tool can be found when you
+      flash the watch.
+    </p>
+
+    <h4 id="transfer_the_image_to_the_watch">
+      Transfer the image to the watch
+    </h4>
+
+    <p>
+      To download a preview image and flash it to the watch:
+    </p>
+
+    <ol>
+      <li>Download and unzip the appropriate system image from a "Preview
+      image for testing" row in a <a href="#preview_system_images">table
+      above</a>.
+      </li>
+
+      <li>Attach the watch charger to the watch and plug the USB cord (from the
+      charger) into your computer.
+      </li>
+
+      <li>Use the following <a href="{@docRoot}tools/help/adb.html">adb
+      command</a> to confirm that the watch is available for flashing:
+      <code>adb devices</code>
+      </li>
+
+      <li>Use the following adb command to start the device in fastboot mode:
+      <code>adb reboot bootloader</code>
+      </li>
+
+      <li>If necessary, use one of following two commands to
+      unlock the device's bootloader. This step erases all data on the
+      device: <code>fastboot flashing unlock</code> or, for some
+      devices, <code>fastboot oem unlock</code>
+      </li>
+
+      <li>Navigate to the directory where you unzipped the system image in Step
+      1.
+      </li>
+
+      <li>Execute the <code>flash-all</code> script by typing
+      <code>flash-all.sh</code> or, in the case of Windows,
+      <code>flash-all.bat</code>.
+      </li>
+    </ol>
+
+
+    <h4 id="set_up_watch">
+      Set up the watch and begin testing
+    </h4>
+
+      <p>
+        After the <code>flash-all</code> script finishes, your watch reboots
+        and soon will be ready for testing with the preview image.
+      </p>
+
+    <ol>
+      <li>Attach the watch charger to the watch and plug the USB cord
+      into your computer, if it is not already plugged in.
+      </li>
+
+      <li>Use the following <a href="{@docRoot}tools/help/adb.html">adb
+      command</a> to confirm that the watch is available:
+      <code>adb devices</code>
+      </li>
+
+      <li>Use the following adb command to start the device in fastboot mode:
+      <code>adb reboot bootloader</code>
+      </li>
+
+      <li>Use the following command to
+      lock the device's bootloader: <code>fastboot flashing lock</code> or, for some
+      devices, <code>fastboot oem lock</code>
+      </li>
+
+      <li>On the watch, continue the boot by touching <strong>'0'</strong>.
+      </li>
+
+    </ol>
+
+
+    <p>
+      Pair the watch with a
+      phone or tablet. The preview now is available for testing on the watch.
+      Before installing an app, enable the Developer Options menu, and ADB
+      debugging, on the watch as follows:
+    </p>
+
+    <ol>
+      <li>Open the Settings menu (on the watch).
+      </li>
+
+      <li>Scroll to the bottom of the menu and tap <strong>About</strong>.
+      </li>
+
+      <li>Tap the build number 7 times.
+      </li>
+
+      <li>From the Settings menu, tap the <strong>Developer Options</strong>
+      item.
+      </li>
+
+      <li>Enable ADB debugging.
+      </li>
+
+      <li>Connect the watch to your computer and tap <strong>Always allow from
+      this computer</strong>.
+      </li>
+    </ol>
+
+    <p>
+      Your watch is ready for you to <a href=
+      "{@docRoot}training/wearables/apps/creating.html#Install">install and run
+      your app</a>:
+    </p>
+
+    <ol>
+      <li>Open your app in Android Studio.
+      </li>
+
+      <li>Select <strong>wear</strong> from the Run/Debug configuration
+      drop-down menu.
+      </li>
+
+      <li>Click the Play button.
+      </li>
+
+      <li>In the Select Deployment Target box, click your device.
+      </li>
+    </ol>
+
+    <p>
+      After your app is installed on the watch, you are prompted to start the
+      app on the watch.
+    </p>
+
+    <p>
+      When testing is completed, follow the steps for <a href=
+      "#remove_the_preview_from_a_watch">removing the preview</a>.
+    </p>
+
+    <h3 id="remove_the_preview_from_a_watch">
+      Remove the preview from a watch
+    </h3>
+
+    <p>
+      When testing with the preview is done, unpair ("Forget") the watch from the phone and
+      restore the watch as follows:
+    </p>
+
+    <ol>
+      <li>Download and unzip the appropriate system image from a "Non-preview
+      image" row in a <a href="#preview_system_images">table
+      above</a>.
+      </li>
+
+      <li>Manually flash the image to the watch using steps similar to those in
+      <a href="#transfer_the_image_to_the_watch">Transfer the image to the
+      watch</a>, except that you flash the <strong>non-preview</strong> image
+      to the watch.
+      </li>
+    </ol>
+
+    <p>
+      <strong>Note</strong>: Removing a preview system image requires a full
+      device reset and removes all user data on the device.
+    </p>
+
+    <h2 id="set_up_an_emulator">
+      Set Up an Emulator
+    </h2>
+
+    <p>
+      To test with the Android Emulator, create a virtual device in Android
+      Studio as follows:
+    </p>
+
+    <ol>
+      <li>Open the AVD Manager by selecting <strong>Tools &gt; Android &gt; AVD
+      Manager</strong>.
+      </li>
+
+      <li>Click <strong>Create Virtual Device</strong>.
+      </li>
+
+      <li>In the <strong>Category</strong> pane, select Wear, choose a hardware profile,
+       and click <strong>Next</strong>. The Android Wear 2.0 Developer Preview
+       is only optimized for round devices currently, so we recommend not
+       using the square or chin profiles for now.
+      </li>
+
+      <li>Select an <strong>N</strong> image to download. The images may be on
+      the <strong>x86</strong> tab instead of the <strong>Recommended</strong>
+      tab, until installed. For example, select the image with the
+      <strong>Release Name</strong> of N, the <strong>API Level</strong> of N,
+      and the <strong>Target</strong> of "Android 6.X (with Android Wear)".
+      When the download and installation are complete, click
+      <strong>Finish</strong> and then click <strong>Next</strong>.
+      </li>
+
+      <li>Verify the configuration of the Android Virtual Device (AVD) and
+      click <strong>Finish</strong>.
+      </li>
+    </ol>
+
+    <p>
+      You can now test an application in the <a href=
+      "{@docRoot}tools/devices/emulator.html">Android Emulator</a>. For more
+      information about using virtual devices, see <a href=
+      "{@docRoot}tools/devices/managing-avds.html">Managing AVDs with the AVD
+      Manager</a>.
+    </p>
+ </div><!-- landing -->
+
+</div><!-- relative wrapper -->
+
+
+<script>
+  var urlRoot = "http://storage.googleapis.com/androiddevelopers/shareables/wear-preview/";
+  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>
\ No newline at end of file
diff --git a/docs/html/wear/preview/features/bridger.jd b/docs/html/wear/preview/features/bridger.jd
new file mode 100644
index 0000000..b7be093
--- /dev/null
+++ b/docs/html/wear/preview/features/bridger.jd
@@ -0,0 +1,147 @@
+page.title=Bridging Mode for Notifications
+meta.keywords="wear-preview"
+page.tags="wear-preview"
+
+@jd:body
+
+    <div id="qv-wrapper">
+      <div id="qv">
+        <ol>
+          <li>
+            <a href=
+            "#preventing_bridging_with_the_bridging_mode_feature">Preventing
+            Bridging with the Bridging Mode Feature</a>
+          </li>
+
+          <li>
+            <a href=
+            "#using_a_dismissal_id_to_sync_notification_dismissals">Using a
+            Dismissal ID to Sync Notification Dismissals</a>
+          </li>
+        </ol>
+      </div>
+    </div>
+
+    <p>
+      By default, notifications <a href=
+      "{@docRoot}training/wearables/notifications/index.html">are bridged
+      (shared)</a> from an app on a companion phone to the watch. If you build
+      a standalone watch app and have a companion phone app, they may duplicate
+      notifications. The Android Wear 2.0 Preview includes a Bridging mode
+      feature to handle this problem of repeated notifications.
+    </p>
+
+    <p>
+      With the Android Wear 2.0 Preview, developers can change the
+      behavior of notifications with the following:
+    </p>
+
+    <ul>
+      <li>Specifying in the standalone app's Android manifest file that
+      notifications from the corresponding phone app should not be
+      bridged to the watch
+      </li>
+
+      <li>Setting a dismissal ID so notification dismissals are synced across
+      devices
+      </li>
+    </ul>
+
+    <h2 id="preventing_bridging_with_the_bridging_mode_feature">
+      Preventing Bridging with the Bridging Mode Feature
+    </h2>
+
+    <p>
+      To prevent bridging of notifications from a phone app, you can use an
+      entry in the manifest file of the watch app (e.g. the standalone watch
+      app), as follows:
+    </p>
+
+    <pre>
+com.google.android.wearable.notificationBridgeMode
+    </pre>
+
+    <p>
+      Setting that entry to <code>NO_BRIDGING</code> will prevent bridging:
+    </p>
+
+    <pre>
+&lt;meta-data android:name="com.google.android.wearable.notificationBridgeMode"
+                   android:value="NO_BRIDGING" /&gt;
+</pre>
+    <p>
+      The default bridging behavior occurs if you do not include the entry or
+      if you specify a value of <code>BRIDGING</code> instead of
+      <code>NO_BRIDGING</code>.
+    </p>
+
+    <h3 id="existing_method_of_preventing_bridging">
+      Existing method of preventing bridging
+    </h3>
+
+    <p>
+      An existing way to prevent bridging is with the
+      <code>Notification.Builder</code> class; specify <code>true</code> in the
+      <a href=
+      "{@docRoot}reference/android/app/Notification.Builder.html#setLocalOnly(boolean)">
+      setLocalOnly</a> method.
+    </p>
+
+    <p>
+      However, this way to prevent bridging may not be preferable. For example,
+      if a user installs a phone app but not the corresponding watch app, the
+      <code>setLocalOnly</code> method could prevent the bridging of helpful
+      notifications. Additionally, users may have multiple paired watches and
+      the watch app may not be installed on all of them.
+    </p>
+
+    <p>
+      Thus, if bridging should be prevented when the watch app
+      is installed, use the <a href=
+      "#preventing_bridging_with_the_bridging_mode_feature">Bridging mode
+      feature</a>.
+    </p>
+
+    <h2 id="using_a_dismissal_id_to_sync_notification_dismissals">
+      Using a Dismissal ID to Sync Notification Dismissals
+    </h2>
+
+    <p>
+      If you prevent bridging with the Bridging mode feature, dismissals
+      (cancellations) of notifications are not synced across a user's devices.
+      However, the following methods of the <a href=
+      "{@docRoot}reference/android/support/v4/app/NotificationCompat.WearableExtender.html">
+      NotificationCompat.WearableExtender</a> class enable you to use dismissal
+      IDs:
+    </p>
+
+    <pre>
+public WearableExtender setDismissalId(String dismissalId)
+public String getDismissalId()
+    </pre>
+    <p>
+      To enable a dismissal to be synced, use the <code>setDismissalId()</code>
+      method. For each notification, pass a globally unique ID, as a string,
+      when you call the <code>setDismissalId()</code> method. When the
+      notification is dismissed, all other notifications with the same
+      dismissal ID are dismissed on the watch(es) and on the companion phone.
+      To retrieve a dismissal ID, use <code>getDismissalId()</code>.
+    </p>
+
+    <p>
+      In the following example, syncing of dismissals is enabled because a
+      globally unique ID is specified for a new notification:
+    </p>
+
+    <pre>
+NotificationCompat.WearableExtender wearableExtender =
+new NotificationCompat.WearableExtender().setDismissalId(“abc123”);
+Notification notification = new NotificationCompat.Builder(context)
+&lt;set other fields&gt;
+.extend(wearableExtender)
+.build();
+    </pre>
+    <p>
+      Dismissal IDs work if a watch is paired to an Android phone, but not if a
+      watch is paired to an iPhone.
+    </p>
diff --git a/docs/html/wear/preview/features/complications.jd b/docs/html/wear/preview/features/complications.jd
new file mode 100644
index 0000000..d33fd2a
--- /dev/null
+++ b/docs/html/wear/preview/features/complications.jd
@@ -0,0 +1,813 @@
+page.title=Watch Face Complications
+meta.keywords="wear-preview"
+page.tags="wear-preview"
+page.image=/wear/preview/images/complications-main-image.png
+@jd:body
+
+    <div id="qv-wrapper">
+      <div id="qv">
+    <h2>In this document</h2>
+      <ol>
+          <li>
+            <a href="#adding_complications_to_a_watch_face">Adding
+            Complications to a Watch Face</a>
+          </li>
+          <li>
+            <a href="#exposing_data_to_complications">Exposing Data to
+            Complications</a>
+          </li>
+          <li>
+            <a href="#using_complication_types">Using Complication Types</a>
+          </li>
+          <li>
+            <a href="#using_fields_for_complication_data">Using Fields for
+            Complication Data</a>
+          </li>
+          <li>
+            <a href="#api_additions">API Additions</a>
+          </li>
+      </ol>
+    <h2>See Also</h2>
+      <ol>
+        <li><a class="external-link"
+          href="https://github.com/googlesamples/android-WatchFace">Watch
+          Face sample app with complications</a></li>
+      </ol>
+      </div>
+    </div>
+
+    <p>
+      A complication is any feature in a watch face that displays <a href=
+      "https://en.wikipedia.org/wiki/Complication_(horology)">more than hours and
+      minutes</a>. For example, a battery indicator is a complication. The
+      Complications API is for both watch faces and data provider apps.
+    </p>
+
+    <div class="col-4of10">
+      <img src="../images/complications-main-image.png" alt="Complications"
+      id="img-split-screen">
+    </div>
+
+    <p>
+      Watch faces can display extra information without needing code for
+      getting the underlying data. Data providers can supply data (such as
+      battery level, weather, or step-count data) to any watch face using the
+      API.
+    </p>
+
+    <p>
+      Along with reviewing this page, download the Android Wear 2.0 Preview
+      Reference (see the Complications API <a href=
+      "#api_additions">additions</a>) and review the Javadoc for complications.
+    </p>
+
+    <p>
+      Apps that provide data to watch faces for complications are called
+      "complication data providers." These apps are not responsible for controlling
+      how their data is rendered on the watch face.
+      This allows a watch face to integrate the data naturally with the
+      watch face design.
+      The consuming watch faces are responsible for drawing
+      the complications.
+    </p>
+
+    <p>
+      Watch faces can receive complication data of
+      <a href="#using_complication_types">various types</a> (e.g. small text
+      data or icon data) and then display it.
+    </p>
+
+    <p>
+      As indicated in the diagram below, Android Wear mediates the flow of data
+      from providers to watch faces.
+    </p>
+
+    <img src="../images/complications-data-flow.png" width="" alt=
+    "Complications data flow" title="Complications data flow">
+
+    <p>
+      For creating or modifying watch faces, see <a href=
+      "#adding_complications_to_a_watch_face">Adding complications to a watch
+      face</a>.
+    </p>
+
+    <p>
+      For writing apps that provide data to watch faces, see <a href=
+      "#exposing_data_to_complications">Exposing data to complications</a>.
+    </p>
+
+    <h2 id="adding_complications_to_a_watch_face">
+      Adding Complications to a Watch Face
+    </h2>
+
+    <p>
+      Watch face developers can receive complication data and enable users to
+      select providers for that data. Additionally, Android Wear provides a
+      <a href="#allowing_users_to_choose_data_providers">user interface for
+      data source selection</a>.
+    </p>
+
+    <h3 id="receiving_data_and_rendering_complications">
+      Receiving data and rendering complications
+    </h3>
+
+    <p>
+      To start receiving complication data, a watch face calls
+      <code>setActiveComplications</code> within the
+      <code>WatchFaceService.Engine</code> class with a list of watch face
+      complication IDs. A watch face creates these IDs to uniquely identify
+      slots on the watch face where complications can appear, and passes them
+      to the <code>createProviderChooserIntent</code> method (of the
+      <code>ProviderChooserIntent</code> class) to allow the user to decide
+      which complication should go in which slot.
+    </p>
+
+    <p>
+      Complication data is delivered via the
+      <code>onComplicationDataUpdate</code> (of
+      <code>WatchFaceService.Engine</code>) callback.
+    </p>
+
+    <p>
+      The watch face may render the data as desired as long as the expected
+      fields are represented; the required fields should always be included and
+      the data should be represented in some way. Depending on the type, some
+      of the optional fields should also be included (see the Notes column in
+      the <a href="#types_and_fields">table</a> below).
+    </p>
+
+    <p>
+      We provide design guidelines for our style, as a suggestion for standard
+      complications, but developers can use their own styles or incorporate the
+      data into the watch face in different ways.
+    </p>
+
+    <h3 id="allowing_users_to_choose_data_providers">
+      Allowing users to choose data providers
+    </h3>
+
+    <p>
+      Android Wear provides a user interface (via an Activity) that enables
+      users to choose providers for a particular complication. Watch faces can
+      call the <code>createProviderChooserIntent</code> method to obtain an
+      intent that can be used to show the chooser interface.
+    </p>
+
+    <p>
+      This intent must be used with <code>startActivityForResult</code>. When a
+      watch face calls <code>createProviderChooserIntent</code>, the watch face
+      supplies a watch face complication ID and a list of supported types. The
+      types should be listed in order of preference, usually with types
+      offering more information, such as ranged value, given higher preference.
+    </p>
+
+    <p>
+      When the user selects a data provider, the configuration is saved
+      automatically; nothing more is required from the watch face.
+    </p>
+
+    <h3 id="user_interactions_with_complications">
+      User interactions with complications
+    </h3>
+
+    <p>
+      Providers can specify an action that occurs if the user taps on a
+      complication, so it should be possible for most complications to be
+      tappable. This action will be specified as a <code>PendingIntent</code>
+      included in the <code>ComplicationData</code> object. The watch face is
+      responsible for detecting taps on complications, and should fire the
+      pending intent when a tap occurs.
+    </p>
+
+    <p>
+      It may be infeasible to make some complications tappable (e.g., in the
+      case of a complication that fills the entire background of the watch
+      face), but it is expected that watch faces accept taps on complications
+      where possible.
+    </p>
+
+    <h2 id="exposing_data_to_complications">
+      Exposing Data to Complications
+    </h2>
+
+    <p>
+      A complication data provider is a service that extends
+      <code>ComplicationProviderService</code>. To respond to update requests
+      from the system, your data provider must implement the
+      <code>onComplicationUpdate</code> method of the
+      <code>ComplicationProviderService</code> class. This method will be
+      called when the system wants data from your provider - this could be when
+      a complication using your provider becomes active, or when a fixed amount
+      of time has passed. A <code>ComplicationManager</code> object is passed
+      as a parameter to the <code>onComplicationUpdate</code> method, and can
+      be used to send data back to the system.
+    </p>
+
+    <p>
+      In your app's manifest, declare the service and add an intent filter for
+      the following:
+    </p>
+
+    <pre>
+android.support.wearable.complications.ACTION_COMPLICATION_UPDATE_REQUEST
+</pre>
+    <p>
+      The service's manifest entry should also include an
+      <code>android:icon</code> attribute. The provided icon should be a
+      single-color white icon. Vector drawables are recommended for the icons.
+      An icon should represent the provider and will be shown in the provider
+      chooser.
+    </p>
+
+    <p>
+      Include metadata to specify the supported types, update period, and
+      configuration action, if required; for details, download the Android Wear
+      2.0 Preview Reference and see the keys listed for the
+      <code>ComplicationProviderService</code> class (in the Javadoc; see
+      <a href="#api_additions">API Additions</a>).
+    </p>
+
+    <h3 id="update_period">
+      Update period
+    </h3>
+
+    <p>
+      Your provider can specify an update period using the following metadata
+      key in the manifest:
+    </p>
+
+    <pre>
+android.support.wearable.complications.UPDATE_PERIOD_SECONDS
+</pre>
+    <p>
+      This should be set to as long a time as possible, as updating too
+      frequently may impact battery life. Note that update requests are not
+      guaranteed to be sent with this frequency. The system does apply a
+      minimum update period, and in particular, updates requests may come less
+      often when the device is in ambient mode or is not being worn.
+    </p>
+
+    <p>
+      You can alternatively use a "push style" to send updates, rather than
+      requesting updates on a fixed schedule. To do so, you can set the update
+      period to 0 so scheduled update requests do not occur (or set it to a
+      non-zero value) and use a <code>ProviderUpdateRequester</code> to trigger
+      calls to <code>onComplicationUpdate</code> as required.
+    </p>
+
+    <h3 id="provider_configuration">
+      Provider configuration
+    </h3>
+
+    <p>
+      If required, a provider can include a configuration activity that is
+      shown to the user when the user chooses a data provider. To include the
+      configuration activity, include a metadata item in the provider service
+      declaration in the manifest with a key of the following:
+    </p>
+
+    <p>
+      <code>android.support.wearable.complications.PROVIDER_CONFIG_ACTION</code>
+    </p>
+
+    <p>
+      The value can be an action of your choice.
+    </p>
+
+    <p>
+      Then create the configuration activity with an intent filter for that
+      action. The configuration activity must reside in the same package as the
+      provider. The configuration activity must return <code>RESULT_OK</code> or
+      <code>RESULT_CANCELED</code>, to tell the system whether the provider
+      should be set.
+    </p>
+
+    <p>
+      The configuration activity may also be used as an opportunity to request
+      any permissions required by the provider.
+    </p>
+
+    <p>
+      For details, download the Android Wear 2.0 Preview Reference (see
+      <a href="#api_additions">API Additions</a>), containing the Javadoc, and
+      see the following in the <code>ComplicationProviderService</code> class:
+    </p>
+
+    <pre>
+METADATA_KEY_PROVIDER_CONFIG_ACTION
+    </pre>
+
+    <h2 id="using_complication_types">
+      Using Complication Types
+    </h2>
+
+    <p>
+      Complication types determine the kinds of data shown in a complication.
+      For example, the <code>SHORT_TEXT</code> type is available when the key
+      data is a short string. In the example of the <code>SHORT_TEXT</code>
+      type, optional data are an icon and a short title.
+    </p>
+
+    <p>
+      Data providers use these complication types differently from the way
+      watch face providers use these types:
+    </p>
+
+    <ul>
+      <li>A data provider chooses the types of complication data to supply. For
+      example, a step count provider might support the
+      <code>RANGED_VALUE</code> and <code>SHORT_TEXT</code> types, whereas a
+      "next meeting" provider might support the <code>SHORT_TEXT</code> and
+      <code>LONG_TEXT</code> types. The data provider also chooses which
+      optional fields of those types to include.
+      </li>
+
+      <li>A watch face provider chooses how many complication types to support.
+      For example, a round complication on a watch face might support the
+      <code>SHORT_TEXT</code>, <code>ICON</code> and <code>RANGED_VALUE</code>
+      types, whereas a gauge on the watch face might support only the
+      <code>RANGED_VALUE</code> type.
+      </li>
+    </ul>
+
+    <p>
+      A <code>ComplicationData</code> object will always have a single
+      complication type. Each complication type has required and optional
+      fields. Generally, a required field represents the primary piece of data;
+      most types take their name from the required field.
+    </p>
+
+    <p>
+      A given type may include different sets of fields. For example,
+      <code>SHORT_TEXT</code> may be just a single piece of text, or a title
+      and text, or an icon and text. A complication that supports a given type
+      must be able to display all the expected variants. However, some optional
+      fields do not need to be displayed (see the <em>Notes</em> column of the
+      table below). For example, the Short title field of the
+      <code>RANGED_VALUE</code> type is not required so that, for example,
+      gauges can be shown without including text.
+    </p>
+
+    <h3 id="examples_of_complication_types">
+      Examples of Complication Types
+    </h3>
+
+    <p>
+      The following shows examples of complication types:
+    </p>
+    <img src="../images/complication-type-exs.png" width="" alt=
+    "Complication types" title="Complications types - examples">
+
+
+    <h3 id="types_and_fields">
+      Types and fields
+    </h3>
+
+    <p>
+      The following table describes the types and fields of the
+      <code>ComplicationData</code> object.
+    </p>
+
+    <table>
+      <tr>
+        <th style="width:175px">
+          Type
+        </th>
+        <th style="width:175px">
+          Required fields
+        </th>
+        <th style="width:175px">
+          Optional fields
+        </th>
+        <th>
+          Notes
+        </th>
+      </tr>
+
+      <tr>
+        <td>
+          SHORT_TEXT
+        </td>
+        <td>
+          Short text
+        </td>
+        <td>
+          Icon<br>
+          Short title
+        </td>
+        <td>
+          Exactly one of Icon/Short title is expected to be shown if either or
+          both are provided.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          ICON
+        </td>
+        <td>
+          Icon
+        </td>
+        <td>
+        </td>
+        <td>
+          Used when text is not needed.The icon is expected to be single-color,
+          and may be tinted by the watch face.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          RANGED_VALUE
+        </td>
+        <td>
+          Value<br>
+          Min value<br>
+          Max value
+        </td>
+        <td>
+          Icon<br>
+          Short text<br>
+          Short title
+        </td>
+        <td>
+          Optional fields are not guaranteed to be displayed.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          LONG_TEXT
+        </td>
+        <td>
+          Long text
+        </td>
+        <td>
+          Long title<br>
+          Icon<br>
+          Small image
+        </td>
+        <td>
+          Title is expected to be shown if provided.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          SMALL_IMAGE
+        </td>
+        <td>
+          Small image
+        </td>
+        <td>
+        </td>
+        <td>
+          A small image has one of two styles: <em>photo style</em> or <em>icon
+          style</em>. Photo style means it should fill the space and can be
+          cropped; icon style means it should not be cropped and may be padded.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          LARGE_IMAGE
+        </td>
+        <td>
+          Large image
+        </td>
+        <td>
+        </td>
+        <td>
+          This image is expected to be large enough to fill the watch face.
+        </td>
+      </tr>
+    </table>
+
+    <p>
+      In addition, the following two types have no fields. These two types may
+      be sent for any complication slot and do not need to be included in a
+      list of supported types:
+    </p>
+
+    <table>
+      <tr>
+        <th style="width:175px">
+          Type
+        </th>
+        <th style="width:175px">
+          Required fields
+        </th>
+        <th style="width:175px">
+          Optional fields
+        </th>
+        <th>
+          Notes
+        </th>
+      </tr>
+
+      <tr>
+        <td>
+          NOT_CONFIGURED
+        </td>
+        <td>
+          None
+        </td>
+        <td>
+          None
+        </td>
+        <td>
+          Sent when a provider has not yet been chosen for a complication.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          EMPTY
+        </td>
+        <td>
+          None
+        </td>
+        <td>
+          None
+        </td>
+        <td>
+          Sent by a provider when there is no data to display in a
+          complication, or sent by the system when nothing should be shown in a
+          complication.
+        </td>
+      </tr>
+    </table>
+
+    <h2 id="using_fields_for_complication_data">
+      Using Fields for Complication Data
+    </h2>
+
+    <p>
+      The fields of a <code>ComplicationData</code> object have different
+      functions. For example, a text field contains the primary data while a
+      title field is descriptive; a step count complication might have a text
+      field value of "2,543" with a title field value of "steps."
+    </p>
+
+    <p>
+      The following table contains descriptions of the fields in a
+      <code>ComplicationData</code> object. The fields may or may not be
+      populated, depending on the complication type.
+    </p>
+
+    <table>
+      <tr>
+        <th style="width:175px">
+          Field
+        </th>
+        <th>
+          Description
+        </th>
+      </tr>
+
+      <tr>
+        <td>
+          Short text
+        </td>
+        <td>
+          Primary text field for small complications. Should not exceed 7
+          characters.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Icon
+        </td>
+        <td>
+          A single-color image representing the data or the source of the data.
+          Must be tintable. Vector drawables are recommended for this field.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Short title
+        </td>
+        <td>
+          Descriptive field for small complications. Should not exceed 7
+          characters. May only be meaningful in combination with <em>Short
+          text</em>.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Long text
+        </td>
+        <td>
+          Primary data field for large, text-based complications.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Long title
+        </td>
+        <td>
+          Descriptive field for large, text-based complications. May only be
+          meaningful in combination with <em>Long text</em>.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Value
+        </td>
+        <td>
+          A numerical (float) representation of the data. Expected to be
+          depicted relative to the bounds the <em>Min value</em> and <em>Max
+          value</em> fields (but not required to be between those bounds).
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Min value
+        </td>
+        <td>
+          The lower bound for the range within which <em>Value</em> should be
+          depicted. Only meaningful in combination with <em>Value</em> and
+          <em>Max value</em>.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Max value
+        </td>
+        <td>
+          The upper bound for the range within which <em>value</em> should be
+          depicted. Only meaningful in combination with <em>Value</em> and
+          <em>Min value</em>.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Small image
+        </td>
+        <td>
+          A small image to represent the data or the source of the data. May be
+          full color. Not expected to fill the entire watch face.
+        </td>
+      </tr>
+
+      <tr>
+        <td>
+          Large image
+        </td>
+        <td>
+          An image with sufficient resolution to fill the watch face. May be
+          full color.
+        </td>
+      </tr>
+    </table>
+
+    <h3 id="providing_time-dependent_values">
+      Providing time-dependent values
+    </h3>
+
+    <p>
+      Some complications need to display a value that relates to the current
+      time. Examples include the current date, the time until the next meeting,
+      or the time in another time zone.
+    </p>
+
+    <p>
+      Providers of such data should not need to update a complication every
+      second/minute to keep those values up to date. Instead, they can specify
+      the values as relative to the current date or time.
+    </p>
+
+    <p>
+      Providers can use the builders in the <code>ComplicationText</code> class
+      to create these time-dependent values.
+    </p>
+
+    <h2 id="api_additions">
+      API Additions
+    </h2>
+
+    <p>
+      The Complications API includes new classes in the Wearable Support
+      Library. For more information, download the <a href=
+      "{@docRoot}wear/preview/start.html#get_the_preview_reference_documentation">
+      Android Wear 2.0 Preview Reference</a>.
+    </p>
+
+    <ul>
+      <li>
+        <code>ComplicationData</code>
+        <ul>
+          <li>Parcelable (using a Bundle internally); immutable
+          </li>
+
+          <li>Represents all types of complication data
+          </li>
+
+          <li>Includes a Builder for instance creation
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>ComplicationText</code>
+        <ul>
+          <li>Used to supply text-based values in a
+          <code>ComplicationData</code> object
+          </li>
+
+          <li>Includes options for time-dependent values, whose text value
+          depends on the current time
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>ComplicationProviderService</code>
+        <ul>
+          <li>Extends <code>Service</code> and includes callback methods to
+          respond to the complication system
+          </li>
+
+          <li>Callback methods are all called on the main thread
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>ComplicationManager</code>
+        <ul>
+          <li>A wrapper for the complication manager service, for use by
+          providers
+          </li>
+
+          <li>Allows providers to send complication data to the system
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>ProviderChooserIntent</code>
+        <ul>
+          <li>Non-instantiable utility class
+          </li>
+
+          <li>Includes a method that a watch face can call for starting a
+          provider chooser (to allow a user to configure complications)
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>ProviderInfoRetriever</code>
+        <ul>
+          <li>Can be used (by watch face configuration activities) to retrieve
+          the current data provider information (app, provider name, icon) for
+          all complications belonging to a watch face
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>ProviderUpdateRequester</code>
+        <ul>
+          <li>Can be used by data provider apps to trigger calls to
+          <code>onComplicationUpdated</code> in their provider service, to
+          enable the push of updates
+          </li>
+        </ul>
+      </li>
+    </ul>
+
+    <p>
+      Additionally, the <code>WatchFaceService.Engine</code> class contains the
+      following new methods:
+    </p>
+
+    <ul>
+      <li>
+        <code>setActiveComplications</code>
+        <ul>
+          <li>Should be called by the watch face to tell the
+          <code>ComplicationManager</code> object what complication slots are
+          available and what types are supported
+          </li>
+        </ul>
+      </li>
+
+      <li>
+        <code>onComplicationDataUpdate</code>
+        <ul>
+          <li>Called by the <code>ComplicationManager</code> object to send
+          complication data to the watch face
+          </li>
+        </ul>
+      </li>
+    </ul>
diff --git a/docs/html/wear/preview/features/ime.jd b/docs/html/wear/preview/features/ime.jd
new file mode 100644
index 0000000..1301be9
--- /dev/null
+++ b/docs/html/wear/preview/features/ime.jd
@@ -0,0 +1,133 @@
+page.title=Wear Input Method Framework
+meta.tags="wear", "wear-preview", "input-method", "ime"
+page.tags="wear"
+
+@jd:body
+
+
+<div id="qv-wrapper">
+<div id="qv">
+
+    <h2>In this document</h2>
+    <ol>
+      <li><a href="#creating">Creating an Input Method for Wear</a></li>
+      <li><a href="#invoking">Invoking IME</a></li>
+      <li><a href="#considerations">General IME Considerations</a></li>
+    </ol>
+
+</div>
+</div>
+
+
+<p>Wear 2.0 supports input methods beyond voice by extending the Android 
+Input Method Framework (IMF) to Android Wear. IMF allows for virtual, on-screen
+ keyboards and other input methods to be used for text entry. The IMF APIs used 
+ for Wear devices are the same as other form factors, though usage is slightly 
+ different due to limited screen real estate.</p>
+
+<p>Wear 2.0 comes with the system default Input Method Editor (IME) 
+and opens up the IMF APIs for third-party developers to create custom input 
+methods for Wear.</p>
+
+<p><img src="{@docRoot}wear/preview/images/new_input_methods.png"></p>
+<p><b>Figure 1</b>. Sample input methods </p>
+
+<h2 id="creating">Creating an Input Method for Wear</h2>
+<p>The Android platform provides a standard framework for creating IMEs. To create
+ a Wear-specific IME, you need to optimize your IME for limited screen size.
+  </p>
+
+<p>This document provides guidance that can help you create a Wear-specific IME.
+Before you continue with this guide, it's important that you read the
+documentation for
+<a href="{@docRoot}guide/topics/text/creating-input-method.html">Creating an Input Method</a>
+ on handsets.
+</p>
+
+
+<h2 id="invoking">Invoking an Input Method</h2>
+If you are developing an IME for Wear, remember that the 
+feature is supported only on Android 6.0 (API level 23) and higher versions of 
+the platform. 
+To ensure that your IME can only be installed on Wearables that support input 
+methods beyond voice, add the following to your app's manifest:
+<pre>
+&lt;uses-sdk android:minSdkVersion="23" />
+</pre>
+This indicates that your app requires Android 6.0 or higher. 
+For more information, see <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API Levels</a>
+ and the documentation for the <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">&lt;uses-sdk></a> 
+element.
+<p>
+To control how your app is filtered from devices that do not support Wear
+IMEs (for example, on Phone), add the following to your app's manifest:
+</p>
+<pre>
+&lt;uses-feature android:required="true" android:name="android.hardware.type.watch" />
+</pre>
+
+<p>Wear provides user settings on the watch that lets the user to enable multiple
+ IMEs from the list of installed IMEs. Once the users enable your IME, they 
+ can invoke your IME from:</p>
+<ul>
+<li>A notification or an app using the 
+<a href="{@docRoot}reference/android/support/v4/app/RemoteInput.html">RemoteInput</a></code> API.</li>
+<li>Wear apps with an 
+<a href="{@docRoot}reference/android/widget/EditText.html">EditText</a>
+ field. Touching a text field places the cursor in the field and automatically 
+ displays the IME on focus.</li>
+</ul>
+
+
+<h2 id="considerations">General IME Considerations</h2>
+
+<p>Here are some things to consider when implementing IME for Wear:</p>
+
+<ul>
+<li><strong>Set Default Action</strong>
+<p>
+<a href="http://developer.android.com/reference/android/support/v4/app/RemoteInput.html">{@code RemoteInput}</a> 
+and Wear apps expect only single-line text entry. The ENTER key should always trigger
+ a call to <a href="{@docRoot}reference/android/inputmethodservice/InputMethodService.html#sendDefaultEditorAction(boolean)">sendDefaultEditorAction</a>,
+  which causes the app to dismiss the keyboard and continue on to the next step 
+  or action.</p>
+</li>
+
+<li><Strong>Use full-screen-mode IME</strong>
+<p>
+Input methods on Wear consume most of the screen, leaving very little of the
+ app visible; using full-screen mode ensures an optimal user experience regardless
+  of the app UI.  In full-screen mode, an 
+  <a href="{@docRoot}reference/android/view/inputmethod/ExtractedText.html">{@code ExtractEditText}</a> provides a mirrored
+   view of the text field being edited and can be styled to blend with the rest of
+    the input method UI. For more details on full-screen mode, see 
+    <a href="{@docRoot}reference/android/inputmethodservice/InputMethodService.html">InputMethodService</a>.
+</p>
+</li>
+
+<li><strong>Handle InputType flags</strong>
+<p>
+For privacy reasons, at a minimum you should handle the {@code InputType} 
+flag {@code TYPE_TEXT_VARIATION_PASSWORD} in your IME. When your IME is in 
+password mode, make sure that your keyboard is optimized for single key press 
+(auto spelling correction, auto completion and gesture input are disabled). 
+Most importantly, keyboard in password mode should support ASCII symbols 
+regardless of the input language.  For more details, see 
+<a href="{@docRoot}training/keyboard-input/style.html">Specifying The Input Method Type</a>.
+</p>
+</li>
+
+<li><strong>Provide a key for switching to the next input method</strong>
+<p>
+Android allows users to easily switch between all IMEs supported by the platform.
+ In your IME implementation, set the boolean 
+ <a href="{@docRoot}guide/topics/text/creating-input-method.html#Switching">supportsSwitchingToNextInputMethod = true</a>
+ to enable your IME to support the switching mechanism 
+ (so that apps can switch to the next platform-supported IME).
+</p>
+</li>
+</ul>
+
+
+
+
diff --git a/docs/html/wear/preview/features/notifications.jd b/docs/html/wear/preview/features/notifications.jd
new file mode 100644
index 0000000..0962eb4
--- /dev/null
+++ b/docs/html/wear/preview/features/notifications.jd
@@ -0,0 +1,231 @@
+page.title=Notification Changes in Android Wear 2.0
+meta.tags="wear", "wear-preview", "notifications"
+page.tags="wear"
+page.image=/wear/preview/images/expanded_diagram.png
+
+
+@jd:body
+
+<div id="qv-wrapper">
+  <div id="qv">
+    <!-- table of contents -->
+    <h2>This document includes</h2>
+    <ol>
+      <li><a href="#visual">Visual Updates</a></li>
+      <li><a href="#expanded">Expanded Notifications</a></li>
+      <li><a href="#messaging">MessagingStyle</a></li>
+    </ol>
+  </div>
+</div>
+
+<p>Android Wear 2.0 updates the visual style and interaction paradigm of notifications
+  as well as introduces expanded notifications, which provide substantial additional
+  content and actions in an app-like experience.
+</p>
+
+<p>The visual and interaction changes make it much easier for users to read and
+  interact with notifications from your app. Expanded notifications enable
+  you to deliver Wear users an app-like experience even if you haven't built an
+  Android Wear app.
+</p>
+
+<p class="note">
+  <strong>Note:</strong> When developing for Wear 2.0, ensure that
+  you have the latest version of the Android Wear app on your phone.
+</p>
+
+<h2 id="visual">Visual Updates</h2>
+<p>Notifications receive important visual updates in Wear 2.0, with
+<a href="http://www.google.com/design/spec-wear">
+material design</a> visual changes.
+</p>
+
+<p><img src="{@docRoot}wear/preview/images/comparison_diagram.png" /> </p>
+<p><b>Figure 1.</b> Comparison of the same notification in Android Wear 1.x and 2.0.</p> 
+
+<p>Some of the visual updates include:</p>
+<ul>
+<li><strong>Updated touch targets of a notification</strong>:
+  If no <a href="{@docRoot}reference/android/app/Notification.html#contentIntent">{@code contentIntent}</a>
+  is set or if the notification is
+  <a href="{@docRoot}design/wear/structure.html#Bridged">bridged</a>
+  from a paired phone, then tapping the notification opens an <a href="{@docRoot}wear/preview/features/notifications.html#expanded">expanded notification</a>.
+  If the notification is generated locally by a Wear app and if a
+  <a href="{@docRoot}reference/android/app/Notification.html#contentIntent">{@code contentIntent}</a>
+  is set, tapping the notification fires the
+  <a href="{@docRoot}reference/android/app/Notification.html#contentIntent">{@code contentIntent}</a>.
+  </li>
+
+<li><strong>Dark background color</strong>:
+  If you have notifications that are bridged to wearables, you need to be careful
+   with regards to using color for the notifications. Since a bridged
+  notification needs to support both light (Wear 1.x) and dark (Wear 2.0)
+  backgrounds, it is unlikely that any colors will work well on both.
+  <a href="{@docRoot}reference/android/app/Notification.WearableExtender.html#setDisplayIntent(android.app.PendingIntent)">{@code DisplayIntent}</a>
+   notifications render with both light and dark backgrounds
+  as well, and need to be checked for the same reason.
+  We recommended that you don't set color for bridged notifications.
+
+  When Wear apps post local notifications, you can work around this by checking
+  <a href="{@docRoot}training/basics/supporting-devices/platforms.html#version-codes">the API level of the device</a> they're running on and using an appropriate color
+  for Wear 1.x and a different color for Wear 2.0.
+</li>
+
+<li><strong>Updated horizontal swipe gesture on a notification</strong>:
+  To dismiss a notification in Wear 2.0, the user swipes horizontally in either
+  direction. So if your notification instructs the user to swipe left or right, 
+  you must update the text of your notification.
+</li>
+</ul>
+<h2 id="expanded">Expanded Notifications</h2>
+<p>Android Wear 2.0 introduces <i>expanded notifications</i>, which provide
+  substantial additional content and actions for each notification.
+</p>
+<p>When you <a href="{@docRoot}training/wearables/notifications/pages.html">specify additional content pages</a>
+ and actions for a notification, those are available to the user within the 
+ expanded notification. Each expanded notification follows 
+ <a href="http://www.google.com/design/spec-wear">Material Design for Android Wear</a>,
+  so the user gets an app-like experience.
+</p>
+<p><img src="{@docRoot}wear/preview/images/expanded_diagram.png" /> </p>
+<p><b>Figure 2</b>. An expanded notification with content and actions.</p>
+<p>If the first action in the expanded notification has a
+<a href=" {@docRoot}reference/android/support/v4/app/RemoteInput.html">{@code RemoteInput}</a>
+  (e.g., a Reply action), then the choices you set with <a href="http://developer.android.com/reference/android/support/v4/app/RemoteInput.Builder.html#setChoices(java.lang.CharSequence[])">{@code setChoices()}</a>
+  appear within the expanded notification below the first action.
+</p>
+
+<p>The user can view the expanded notification by tapping on a notification when
+  either of the following is true:
+</p>
+<ul>
+  <li>The notification is generated by an app on the paired phone and
+    bridged to Wear.
+  </li>
+  <li>The notification does not have a 
+  <a href="http://developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html#setContentIntent(android.app.PendingIntent)">{@code contentIntent}</a>.
+  </li>
+</ul>
+<h3>Best practices for expanded notifications</h3>
+<p>To decide when to use expanded notifications, follow these guidelines:</p>
+<ul>
+  <li>All notifications bridged from the paired phone to the Wear device will
+  use expanded notifications.
+  </li>
+  <li>If a notification is generated by an app running locally on Wear 2.0,
+    you should <a href="{@docRoot}training/notify-user/build-notification.html#action">
+    make the touch target of your notification </a> launch
+    <a href="{@docRoot}training/notify-user/build-notification.html#action"> an Activity</a>
+    within your app by calling <a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.Builder.html#setContentIntent(android.app.PendingIntent)">{@code setContentIntent()}</a>.
+    We recommend that you do not use expanded notifications for notifications generated
+    by an app running locally on Wear 2.0.
+  </li>
+</ul>
+
+<h3>Adding expanded notifications</h3>
+<p>
+ Expanded Notifications allow you to include additional content and actions
+   for a notification. You choose the level of detail that your app's notifications
+    will provide; however be judicious with the amount of detail you include in a 
+    notification. 
+</p>
+<h4>Adding additional content</h4>
+To show additional content in your expanded notification, see <a href="{@docRoot}training/wearables/notifications/pages.html">Adding Pages to a Notification</a>.</p>
+<p>Additional content pages are stacked vertically in the expanded notification
+ and appear in the order they were added.
+  These additional content pages can optionally use a style such as <a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.BigTextStyle.html">{@code BigTextStyle}</a> or <a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.BigPictureStyle.html">{@code BigPictureStyle}</a>.
+</p>
+<h4>Primary action</h4>
+The expanded notification will contain one primary action, which is the first
+action in the notification unless a different action is specified using
+<a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.WearableExtender.html#setContentAction(int)">{@code setContentAction()}</a>.
+</p>
+<h4>Additional actions</h4>
+<p>
+  To specify additional actions, use
+  <a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.WearableExtender.html#addAction(android.support.v4.app.NotificationCompat.Action)">{@code addAction()}</a>
+   or <a href="{@docRoot}reference/android/support/v4/app/NotificationCompat.WearableExtender.html#addActions(java.util.List<android.support.v4.app.NotificationCompat.Action>)">{@code addActions()}</a>.
+    The action drawer of the expanded notification contains all available actions.
+</p>
+<h2 id="messaging">MessagingStyle</h2>
+
+<p>If you have a chat messaging app, your notifications should use
+<a href="{@docRoot}preview/features/notification-updates.html#style">{@code Notification.MessagingStyle}</a>,
+ which is new in Android 6.0. Wear 2.0 uses the chat messages included
+  in a <a href="{@docRoot}preview/features/notification-updates.html#style">{@code MessagingStyle}</a> notification 
+  (see <a href="{@docRoot}preview/features/notification-updates.html#style">{@code addMessage()}</a>) to provide
+  a rich chat app-like experience in the expanded notification.
+</p>
+<p class="note">Note: <a href="{@docRoot}preview/features/notification-updates.html#style">{@code MessagingStyle}</a> 
+expanded notifications require that you have at least version 1.5.0.2861804 of the
+  <a href="https://play.google.com/store/apps/details?id=com.google.android.wearable.app">Android Wear app</a>
+  on your paired Android phone. That version will be available within the next
+  few weeks in the Play Store.
+</p>
+<h3 id="smart-reply">Smart Reply</h3>
+<p>Wear 2.0 also introduces <i>Smart Reply</i> for <a href="{@docRoot}preview/features/notification-updates.html#style">{@code MessagingStyle}</a> notifications.
+  Smart Reply provides the user with contextually relevant, touchable choices in
+  the expanded notification and in {@code RemoteInput}. These augment the fixed
+  list of choices that the developer provides in 
+   <a href="http://developer.android.com/reference/android/support/v4/app/RemoteInput.html">{@code RemoteInput}</a>
+    using the 
+    <a href="{@docRoot}reference/android/support/v4/app/RemoteInput.Builder.html#setChoices(java.lang.CharSequence[])">{@code setChoices()}</a> method.
+</p>
+<p>By enabling Smart Reply for your MessagingStyle notifications,
+  you provide users with a fast (single tap), discreet (no speaking aloud), and
+  reliable way to respond to chat messages.
+</p>
+<p><img src="{@docRoot}wear/preview/images/messaging_style.png" /></p>
+<p><b>Figure 3</b>. The expanded notification includes contextually relevant
+  Smart Reply responses below the primary action.
+</p>
+
+<p>Responses generated by Smart Reply are shown in addition to those set using the
+  <a href="{@docRoot}reference/android/support/v4/app/RemoteInput.Builder.html#setChoices(java.lang.CharSequence[])">{@code setChoices()}</a> method.
+</p>
+<p>To enable Smart Reply for your notification action, you need to do the
+following:
+</p>
+<ol>
+  <li>Use <a href="{@docRoot}preview/features/notification-updates.html#style">{@code Notification.MessagingStyle}</a>.
+  </li>
+  <li>Call the method 
+  <a href="{@docRoot}wear/preview/start.html#get_the_preview_reference_documentation">{@code setAllowGeneratedReplies()}</a>
+   for the notification action.</li>
+  <li>Ensure that the notification action has a
+    <a href="{@docRoot}reference/android/app/RemoteInput.html">{@code RemoteInput}</a>
+     (where the responses will reside).
+  </li>
+</ol>
+<p>The following example shows how to create a MessagingStyle notification with
+Smart Reply responses.</p>
+<pre>
+// Create an intent for the reply action
+Intent replyIntent = new Intent(this, ReplyActivity.class);
+PendingIntent replyPendingIntent =
+ PendingIntent.getActivity(this, 0, replyIntent,
+  PendingIntent.FLAG_UPDATE_CURRENT);
+
+// Create the reply action and add the remote input
+NotificationCompat.Action action =
+ new NotificationCompat.Action.Builder(R.drawable.ic_reply_icon,
+  getString(R.string.label), replyPendingIntent)
+ .addRemoteInput(remoteInput)
+
+// 1) allow generated replies
+.setAllowGeneratedReplies(true)
+ .build();
+
+Notification noti = new NotificationCompat.Builder()
+ .setContentTitle(messages.length + " new messages with " + sender.toString())
+ .setContentText(subject)
+ .setSmallIcon(R.drawable.new_message)
+ .setLargeIcon(aBitmap)
+ // 2) set the style to MessagingStyle
+ .setStyle(new NotificationCompat.MessagingStyle(resources.getString(R.string.reply_name)).addMessage(messages[0].getText(), messages[0].getTime(), messages[0].getSender())
+  .addMessage(messages[1].getText(), messages[1].getTime(), messages[1].getSender()))
+
+
+// 3) add an action with RemoteInput
+.extend(new WearableExtender().addAction(action)).build();
+</pre>
diff --git a/docs/html/wear/preview/features/ui-nav-actions.jd b/docs/html/wear/preview/features/ui-nav-actions.jd
new file mode 100644
index 0000000..800fc8e
--- /dev/null
+++ b/docs/html/wear/preview/features/ui-nav-actions.jd
@@ -0,0 +1,191 @@
+page.title=Wear Navigation and Actions
+meta.tags="wear", "wear-preview", "navigation", "action"
+page.tags="wear"
+page.image=/wear/preview/images/card_drawer.png
+
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+    <h2>In this document</h2>
+    <ol>
+      <li><a href="#create a drawer">Create a Drawer Layout</a></li>
+      <li><a href="#initialize">Initialize the Drawer List</a></li>
+      <li><a href="#creating">Create a Custom View Drawer</a></li>
+      <li><a href="#listen to events">Listen for Drawer Events</a></li>
+      <li><a href=#peeking">Peeking Drawers</a></li>
+    </ol>
+
+   <h2>You should also read</h2>
+   <ul>
+   <li><a href="http://www.google.com/design/wear-spec/components/navigation-drawer.html">
+   Navigation Drawer Design</a> </li>
+   <li>
+   <a href="http://www.google.com/design/wear-spec/components/action-drawer.html">
+   Action Drawer Design</a>
+   </ul>
+
+  <h2>See Also</h2>
+  <ol>
+  <li>
+  <a href="https://github.com/googlesamples/android-WearDrawers">Sample app with
+  navigation and action drawers</a>
+  </li>
+  </ol>
+
+</div>
+</div>
+<p>As part of the <a href="http://www.google.com/design/spec-wear">Material Design</a>
+ for Android Wear, Wear 2.0 adds interactive navigation and action drawers. 
+ The navigation drawer appears at the top of the screen and lets users jump to 
+ different views within
+the app, similar to the navigation drawer on a phone. The action drawer appears
+at the bottom of the screen and provides context-specific actions for the user,
+similar to the action bar on a phone. These drawers are accessible when the user
+swipes from the top or bottom of the screen, and they peek when users scroll in
+the opposite direction. </p>
+<div class="cols">
+<div class="col-2of6">
+  <img src="{@docRoot}wear/preview/images/nav_drawer.gif" alt="" style="padding:.5em">
+  <p class="img-caption">
+      <strong>Figure 1.</strong> Navigation and Action Drawers.
+    </p>
+</div>
+<div class="col-2of6">
+  <img src="{@docRoot}wear/preview/images/action_drawer.gif" alt="" style="padding:.5em;"">
+</div>
+</div>
+<div class="cols">
+
+<p>This lesson describes how to implement action and navigation drawers in your
+app using the {@code WearableDrawerLayout} APIs.
+</p>
+
+<h2 id="create a drawer">Create a Drawer Layout</h2>
+To add an action or a navigation drawer, declare your user interface with a
+<code>WearableDrawerLayout</code> object as the root view of your layout.  Inside
+ the <code>WearableDrawerLayout</code>, add one view that contains the main content
+  for the screen (your primary layout when the drawer is hidden) and additional
+  child views that contain the contents of the drawer.</h2>
+<p>For example, the following layout uses a <code>WearableDrawerLayout</code> with
+ three child views: a <code>FrameLayout</code> to contain the main content, a
+ navigation drawer, and an action drawer.</p>
+
+<pre>
+&lt;android.support.wearable.view.drawer.WearableDrawerLayout
+    android:id="@+id/drawer_layout"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:deviceIds="wear">
+
+    &lt;FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/content_frame"/>
+
+    &lt;android.support.wearable.view.drawer.WearableNavigationDrawer
+        android:id="@+id/top_navigation_drawer"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+
+    &lt;android.support.wearable.view.drawer.WearableActionDrawer
+        android:id="@+id/bottom_action_drawer"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+
+&lt;/android.support.wearable.view.drawer.WearableDrawerLayout>
+
+</pre>
+<h2 id="initialize">Initialize the Drawer List</h2>
+<p>One of the first things you need to do in your activity is to initialize the
+drawers list of items. You should implement {@code WearableNavigationDrawerAdapter}
+to populate the navigation drawer contents. To populate the action drawer with
+a list of actions, inflate an XML file into the Menu (via MenuInflater).</p>
+
+<p>The following code snippet shows how to initialize the contents of your drawers:
+</p>
+<pre>
+public class MainActivity extends  WearableActivity implements
+WearableActionDrawer.OnMenuItemClickListener{
+    private WearableDrawerLayout mwearableDrawerLayout;
+    private WearableNavigationDrawer mWearableNavigationDrawer;
+    private WearableActionDrawer mWearableActionDrawer;
+    
+    ...
+    
+    &#64;Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        
+        ......
+        
+        
+        // Main Wearable Drawer Layout that wraps all content
+        mWearableDrawerLayout = (WearableDrawerLayout) findViewById(R.id.drawer_layout);
+        
+        // Top Navigation Drawer
+        mWearableNavigationDrawer = (WearableNavigationDrawer) findViewById(R.id.top_navigation_drawer);
+        mWearableNavigationDrawer.setAdapter(new YourImplementationNavigationAdapter(this));
+
+        // Peeks Navigation drawer on the top.
+        mWearableDrawerLayout.peekDrawer(Gravity.TOP);
+        
+        // Bottom Action Drawer
+        mWearableActionDrawer = (WearableActionDrawer) findViewById(R.id.bottom_action_drawer);
+
+        // Populate Action Drawer Menu
+        Menu menu = mWearableActionDrawer.getMenu();
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.action_drawer_menu, menu);
+        mWearableActionDrawer.setOnMenuItemClickListener(this);
+
+        // Peeks action drawer on the bottom.
+        mWearableDrawerLayout.peekDrawer(Gravity.BOTTOM);
+    }
+}
+
+</pre>
+<h2 id="creating">Create a Custom View Drawer</h2>
+
+<p>To use custom views in drawers,  add  <code>WearableDrawerView</code> to  the
+<code>WearableDrawerLayout</code>. To set the contents of the drawer, call <code>
+<a href="https://x20web.corp.google.com/~psoulos/docs/reference/android/support/wearable/view/drawer/WearableDrawerView.html#setDrawerContent(android.view.View)">setDrawerContent(View)</a></code>
+ instead of manually adding the view to the hierarchy. You must also specify the
+  drawer position with the <code>android:layout_gravity</code> attribute. </p>
+<p> The following example specifies a top drawer:</p>
+<pre>
+&lt;android.support.wearable.view.drawer.WearableDrawerLayout&gt;
+    &lt;FrameLayout 
+    android:id=”@+id/content” /&gt;
+
+    &lt;WearableDrawerView
+        android:layout_width=”match_parent”
+        andndroid:layout_height=”match_parent”
+        android:layout_gravity=”top”&gt;
+        &lt;FrameLayout 
+            android:id=”@+id/top_drawer_content” /&gt;
+    &lt;/WearableDrawerView&gt;
+&lt;/android.support.wearable.view.drawer.WearableDrawerView&gt;
+
+</pre>
+
+<h2 id="listen to events">Listen for Drawer Events</h2>
+<p>To listen for drawer events, call {@code setDrawerStateCallback()}on your
+{@code WearableDrawerLayout} and pass it an implementation of
+{@code WearableDrawerLayout.DrawerStateCallback}. This interface provides callbacks
+ for drawer events such as <code>onDrawerOpened()</code>,
+ <code>onDrawerClosed(),</code> and <code>onDrawerStatechanged()</code>.</p>
+
+<h2 id="peeking">Peeking Drawers</h2>
+<p>To  set the drawers to temporarily appear, call  <code>peekDrawer()</code> on
+your {@code WearableDrawerLayout} and pass it the {@code Gravity} of the drawer.
+ This feature is especially useful because it allows immediate access to the
+ alternate drawer views or actions associated with it. </p>
+
+<pre>{@code mWearableDrawerLayout.peekDrawer</code>(<code>Gravity.BOTTOM);}</pre>
+
+<p>You can also call {@code setPeekContent()} on your drawer to display a custom
+ view when the drawer is peeking.</p>
diff --git a/docs/html/wear/preview/images/action_drawer.gif b/docs/html/wear/preview/images/action_drawer.gif
new file mode 100644
index 0000000..b823137
--- /dev/null
+++ b/docs/html/wear/preview/images/action_drawer.gif
Binary files differ
diff --git a/docs/html/wear/preview/images/card_drawer.png b/docs/html/wear/preview/images/card_drawer.png
new file mode 100644
index 0000000..3614f95
--- /dev/null
+++ b/docs/html/wear/preview/images/card_drawer.png
Binary files differ
diff --git a/docs/html/wear/preview/images/comparison_diagram.png b/docs/html/wear/preview/images/comparison_diagram.png
new file mode 100644
index 0000000..7dbf65f2
--- /dev/null
+++ b/docs/html/wear/preview/images/comparison_diagram.png
Binary files differ
diff --git a/docs/html/wear/preview/images/complication-type-exs.png b/docs/html/wear/preview/images/complication-type-exs.png
new file mode 100644
index 0000000..6e2287c
--- /dev/null
+++ b/docs/html/wear/preview/images/complication-type-exs.png
Binary files differ
diff --git a/docs/html/wear/preview/images/complications-data-flow.png b/docs/html/wear/preview/images/complications-data-flow.png
new file mode 100644
index 0000000..2415535
--- /dev/null
+++ b/docs/html/wear/preview/images/complications-data-flow.png
Binary files differ
diff --git a/docs/html/wear/preview/images/complications-main-image.png b/docs/html/wear/preview/images/complications-main-image.png
new file mode 100644
index 0000000..dd37b25
--- /dev/null
+++ b/docs/html/wear/preview/images/complications-main-image.png
Binary files differ
diff --git a/docs/html/wear/preview/images/expanded_diagram.png b/docs/html/wear/preview/images/expanded_diagram.png
new file mode 100644
index 0000000..03bca9a
--- /dev/null
+++ b/docs/html/wear/preview/images/expanded_diagram.png
Binary files differ
diff --git a/docs/html/wear/preview/images/hero-1x.png b/docs/html/wear/preview/images/hero-1x.png
new file mode 100644
index 0000000..1d0cb6f
--- /dev/null
+++ b/docs/html/wear/preview/images/hero-1x.png
Binary files differ
diff --git a/docs/html/wear/preview/images/hero-2x.png b/docs/html/wear/preview/images/hero-2x.png
new file mode 100644
index 0000000..9f4eb66
--- /dev/null
+++ b/docs/html/wear/preview/images/hero-2x.png
Binary files differ
diff --git a/docs/html/wear/preview/images/messaging_style.png b/docs/html/wear/preview/images/messaging_style.png
new file mode 100644
index 0000000..966e524
--- /dev/null
+++ b/docs/html/wear/preview/images/messaging_style.png
Binary files differ
diff --git a/docs/html/wear/preview/images/messaging_style_diagram.png b/docs/html/wear/preview/images/messaging_style_diagram.png
new file mode 100644
index 0000000..3b21c7973
--- /dev/null
+++ b/docs/html/wear/preview/images/messaging_style_diagram.png
Binary files differ
diff --git a/docs/html/wear/preview/images/nav_drawer.gif b/docs/html/wear/preview/images/nav_drawer.gif
new file mode 100644
index 0000000..1c3b1dc
--- /dev/null
+++ b/docs/html/wear/preview/images/nav_drawer.gif
Binary files differ
diff --git a/docs/html/wear/preview/images/new_input_methods.png b/docs/html/wear/preview/images/new_input_methods.png
new file mode 100644
index 0000000..c035996
--- /dev/null
+++ b/docs/html/wear/preview/images/new_input_methods.png
Binary files differ
diff --git a/docs/html/wear/preview/images/remoteinput.png b/docs/html/wear/preview/images/remoteinput.png
new file mode 100644
index 0000000..9d80498
--- /dev/null
+++ b/docs/html/wear/preview/images/remoteinput.png
Binary files differ
diff --git a/docs/html/wear/preview/index.jd b/docs/html/wear/preview/index.jd
new file mode 100644
index 0000000..4b3c1f2
--- /dev/null
+++ b/docs/html/wear/preview/index.jd
@@ -0,0 +1,111 @@
+page.title=Android Wear 2.0 Developer Preview
+page.tags="wear","wear-preview"
+meta.tags="wear","preview"
+fullpage=true
+forcelocalnav=true
+header.hide=1
+footer.hide=1
+@jd:body
+
+<script>
+  $(document).ready(function() {
+    if (useUpdatedTemplates) {
+      $("#useUpdatedTemplates").css("display","block");
+    } else {
+      $("#useOldTemplates").css("display","block");
+    }
+  })
+</script>
+
+<section class="dac-expand dac-hero dac-light" style="background-color:#FFFFFF">
+  <div class="wrap" style="max-width:1100px;margin-top:0">
+    <div class="cols dac-hero-content" style="padding-bottom:1em;">
+
+      <div class="col-7of16 col-push-9of16" style="padding-left:2em">
+        <h1 class="dac-hero-title">Android Wear 2.0 Developer Preview</h1>
+        <p class="dac-hero-description">
+          Get ready for the next version of Android Wear!
+          Support <strong>stand-alone</strong> Wear devices and apps.
+          Create <strong>enhanced user interaction</strong> and
+          <strong>glanceable experiences</strong>.
+          Test your apps on <strong>Wear devices</strong>.
+        </p>
+
+        <a class="dac-hero-cta" href="{@docRoot}wear/preview/program.html">
+          <span class="dac-sprite dac-auto-chevron"></span>
+          Learn about the Preview
+        </a>
+        <a class="dac-hero-cta" href="https://www.google.com/design/spec-wear">
+          <span class="dac-sprite dac-auto-chevron"></span>
+          Material Design for Wear
+        </a>
+      </div>
+      <div class="col-9of16 col-pull-7of16 dac-hero-figure" style="margin-top:1.5em;padding-right:1.5em;">
+        <img class="dac-hero-image" src="{@docRoot}wear/preview/images/hero-1x.png"
+             srcset="{@docRoot}wear/preview/images/hero-1x.png 1x,
+             {@docRoot}wear/preview/images/hero-2x.png 2x">
+      </div>
+    </div>
+    <div class="dac-section dac-small">
+      <div class="resource-widget resource-flow-layout col-16"
+           data-query="collection:wear/preview/landing"
+           data-cardSizes="6x2"
+           data-maxResults="6"></div>
+    </div>
+  </div>
+</section>
+
+<div id="useUpdatedTemplates" style="display:none" class="dac-section dac-slim dac-gray dac-expand">
+  <div class="wrap dac-offset-parent">
+    <a class="dac-fab dac-scroll-button" data-scroll-button href="#build-apps">
+      <i class="dac-sprite dac-arrow-down-gray"></i>
+    </a>
+    <ul class="dac-actions">
+      <li class="dac-action">
+        <a class="dac-action-link" href="http://g.co/wearpreviewbug">
+          <i class="dac-action-sprite dac-sprite dac-auto-chevron-large"></i>
+          Report an issue
+        </a>
+      </li>
+      <li class="dac-action">
+        <a class="dac-action-link" href="http://g.co/androidweardev">
+          <i class="dac-action-sprite dac-sprite dac-auto-chevron-large"></i>
+          Join developer community
+        </a>
+      </li>
+    </ul>
+  </div><!-- end .wrap -->
+</div><!-- end .dac-actions -->
+
+<div id="useOldTemplates" style="display:none;color:black" class="actions-bar dac-expand dac-invert">
+  <div class="wrap dac-offset-parent">
+
+    <div class="actions">
+      <div><a href="{@docRoot}wear/preview/bug">
+        <span class="dac-sprite dac-auto-chevron-large"></span>
+        Report an issue
+      </a></div>
+      <div><a href="http://g.co/androidweardev">
+        <span class="dac-sprite dac-auto-chevron-large"></span>
+        Join developer community
+      </a></div>
+    </div><!-- end .actions -->
+  </div><!-- end .wrap -->
+</div>
+
+<section class="dac-section dac-light"><div class="wrap">
+  <h1 class="dac-section-title">Resources</h1>
+  <div class="dac-section-subtitle">
+    Essential information to help you get your apps ready for the next version of Android Wear.
+  </div>
+
+  <div class="resource-widget resource-flow-layout col-16"
+       data-query="collection:wear/preview/landing/resources"
+       data-cardSizes="6x6"
+       data-items-per-page="6"
+       data-maxResults="15"
+       data-initial-results="6"></div>
+
+  </div>
+</section>
+
diff --git a/docs/html/wear/preview/license.jd b/docs/html/wear/preview/license.jd
new file mode 100644
index 0000000..e7a7547
--- /dev/null
+++ b/docs/html/wear/preview/license.jd
@@ -0,0 +1,145 @@
+page.title=License Agreement
+
+@jd:body
+
+<p>
+To get started with the Android Wear SDK Preview, you must agree to the following terms and conditions.
+As described below, please note that this is a preview version of the Android Wear SDK, subject to change, that you use at your own risk.  The Android Wear SDK Preview is not a stable release, and may contain errors and defects that can result in serious damage to your computer systems, devices and data.
+</p>
+
+<p>
+This is the Android Wear SDK Preview License Agreement (the “License Agreement”).
+</p>
+<div class="sdk-terms" style="height:auto;border:0;padding:0;width:700px">
+1. Introduction
+
+1.1 The Android Wear 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>
\ No newline at end of file
diff --git a/docs/html/wear/preview/preview_toc.cs b/docs/html/wear/preview/preview_toc.cs
new file mode 100644
index 0000000..f96bf1f
--- /dev/null
+++ b/docs/html/wear/preview/preview_toc.cs
@@ -0,0 +1,132 @@
+<ul id="nav">
+
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>preview/overview.html"
+   es-lang="Información general del programa"
+   ja-lang="プログラム概要"
+   ko-lang="프로그램 개요"
+   pt-br-lang="Visão geral do programa"
+   ru-lang="Обзор программы"
+   zh-cn-lang="计划概览"
+   zh-tw-lang="程式總覽">
+   Program Overview</a></div>
+  </li>
+
+
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>preview/support.html">
+      Support and Release Notes</a></div>
+  </li>
+  
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>preview/setup-sdk.html"
+      es-lang="Configurar el SDK de la versión preliminar"
+      ja-lang="Preview SDK のセットアップ"
+      ko-lang="미리 보기 SDK 설정하기"
+      pt-br-lang="Configuração do Preview SDK"
+      ru-lang="Настройка пакета SDK Preview"
+      zh-cn-lang="设置预览版 SDK"
+      zh-tw-lang="設定預覽版 SDK">
+      Set Up to Develop</a></div>
+  </li>
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>preview/download.html">
+      Test on a Device</a></div>
+  </li>
+
+
+  <li class="nav-section">
+    <div class="nav-section-header"><a href="<?cs var:toroot ?>preview/behavior-changes.html"
+      es-lang="Cambios en los comportamientos"
+      ja-lang="動作の変更点"
+      ko-lang="동작 변경"
+      pt-br-lang="Mudanças de comportamento"
+      ru-lang="Изменения в работе"
+      zh-cn-lang="行为变更"
+      zh-tw-lang="行為變更">Behavior Changes
+       </a></div>
+      <ul>
+        <li><a href="<?cs var:toroot ?>preview/features/background-optimization.html"
+        >Background Optimizations</a></li>
+        <li><a href="<?cs var:toroot ?>preview/features/multilingual-support.html"
+        >Language and Locale</a></li>
+      </ul>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header"><a href="<?cs var:toroot ?>preview/api-overview.html"
+      es-lang="Información general de la API"
+      ja-lang="API の概要"
+      ko-lang="API 개요"
+      pt-br-lang="Visão geral da API"
+      ru-lang="Обзор API-интерфейсов"
+      zh-cn-lang="API 概览"
+      zh-tw-lang="API 總覽">Android N for Developers
+      </a></div>
+      <ul>
+
+        <li><a href="<?cs var:toroot ?>preview/features/multi-window.html"
+        >Multi-Window Support</a></li>
+
+        <li><a href="<?cs var:toroot ?>preview/features/notification-updates.html"
+        >Notifications</a></li>
+
+        <li><a href="<?cs var:toroot ?>preview/features/data-saver.html"
+        >Data Saver</a></li>
+
+        <li><a href="<?cs var:toroot ?>preview/features/tv-recording-api.html"
+        >TV Recording</a></li>
+
+        <li><a href="<?cs var:toroot ?>preview/features/security-config.html"
+        >Network Security Configuration</a></li>
+
+        <li><a href="<?cs var:toroot ?>preview/features/icu4j-framework.html"
+        >ICU4J Support</a></li>
+        
+        <li><a href="<?cs var:toroot ?>preview/j8-jack.html"
+        >Java 8 Language Features</a></li>
+
+        <li><a href="<?cs var:toroot ?>preview/features/afw.html"
+        >Android for Work Updates</a></li>
+      </ul>
+  </li>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>preview/samples.html"
+      es-lang="Ejemplos"
+      ja-lang="サンプル"
+      ko-lang="샘플"
+      pt-br-lang="Exemplos"
+      ru-lang="Примеры"
+      zh-cn-lang="示例"
+      zh-tw-lang="範例">
+      Samples</a></div>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>preview/license.html"
+      es-lang="Contrato de licencia"
+      ja-lang="使用許諾契約"
+      ko-lang="라이선스 계약"
+      pt-br-lang="Contrato de licença"
+      ru-lang="Лицензионное соглашение"
+      zh-cn-lang="许可协议"
+      zh-tw-lang="授權協議">
+      License Agreement</a></div>
+  </li>
+
+</ul>
diff --git a/docs/html/wear/preview/program.jd b/docs/html/wear/preview/program.jd
new file mode 100644
index 0000000..a130663
--- /dev/null
+++ b/docs/html/wear/preview/program.jd
@@ -0,0 +1,269 @@
+page.title=Android Wear Preview Program Overview
+meta.keywords="wear-preview"
+page.tags="wear-preview"
+page.image=images/cards/card-n-sdk_2x.png
+
+@jd:body
+
+    <p>
+      Welcome to the Android Wear 2.0 Developer Preview! This program gives you
+      everything you need to get started with the next version of Android Wear.
+      It’s free, and you can get started right away by downloading the
+      Developer Preview resources.
+    </p>
+
+    <h3 id="program_highlights">
+      Program Highlights
+    </h3>
+
+    <div style="background-color:#eceff1;padding:1em;">
+      <div class="wrap">
+        <div class="cols">
+          <div class="col-4of12">
+            <h5>
+              Hardware and emulator images
+            </h5>
+
+            <p>
+              Run and test your apps on supported Wear devices or the emulator.
+            </p>
+          </div>
+
+          <div class="col-4of12">
+            <h5>
+              Latest platform code
+            </h5>
+
+            <p>
+              We'll provide frequent updates during the preview, so you'll be
+              testing against the latest platform changes.
+            </p>
+          </div>
+
+          <div class="col-4of12">
+            <h5>
+              Priority for developer issues
+            </h5>
+
+            <p>
+              During the first several weeks, we'll give priority to
+              developer-reported issues, so test and give feedback as soon as
+              possible.
+            </p>
+          </div>
+        </div>
+
+        <div class="cols">
+          <div class="col-4of12">
+            <h5>
+              New behaviors and capabilities
+            </h5>
+
+            <p>
+              Start work early to support new platform behaviors such as
+              complications and Material Design for Wear.
+            </p>
+          </div>
+
+          <div class="col-4of12">
+            <h5>
+              Feedback and support
+            </h5>
+
+            <p>
+              Report issues and give us feedback using our
+              <a href="https://g.co/wearpreviewbug">issue tracker</a>.
+              Connect with other developers in
+              the <a href="https://g.co/androidweardev">Wear Developer Community</a>.
+            </p>
+          </div>
+
+          <div class="col-4of12">
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <h2 id="timeline_and_updates">
+      Timeline and Updates
+    </h2>
+
+    <p>
+      The Android Wear 2.0 Developer Preview runs from 18 May 2016 until the
+      final Android Wear public release to OEMs, planned for Q4 2016.
+    </p>
+
+    <p>
+      At key development milestones, we'll deliver updates for your development
+      and testing environment. In general you can expect updates in
+      approximately 6-week intervals. The release milestones are:
+    </p>
+
+    <ul>
+      <li>Milestone 1 (initial release, alpha)
+      </li>
+
+      <li>Milestone 2 (incremental update, beta)
+      </li>
+
+      <li>Milestone 3 (incremental update, beta)
+      </li>
+
+      <li>Milestone 4 (final APIs and official SDK, Play publishing)
+      </li>
+
+      <li>Near-final system image
+      </li>
+
+      <li>Final release to OEMs
+      </li>
+    </ul>
+
+    <p>
+      Each update includes an updated support library, preview system images,
+      emulator, reference documentation, and API diffs.
+    </p>
+
+    <p>
+      The first three milestones provide an early test and development
+      environment to help you identify compatibility issues in your current
+      apps and plan migration or feature work needed to target the new
+      platform. This is the priority period in which to give us your feedback
+      on features and APIs and file compatibility issues — for all of these,
+      please use the <a href="https://g.co/wearpreviewbug">issue tracker</a>.
+      You can expect some API changes across
+      these updates.
+    </p>
+
+    <p>
+      At milestones 4 and 5 you'll have access to the final Android Wear 2.0
+      APIs and SDK to develop with, as well as near-final system images to test
+      system behaviors and features. Android Wear 2.0 will use the Android N
+      API level at this time. You can begin final compatibility testing of your
+      legacy apps and refine any new code that is using the Android Wear 2.0
+      APIs or features.
+    </p>
+
+    <p>
+      As you test and develop on Android Wear 2.0, we strongly recommend
+      keeping your development environment up-to-date as updates are released.
+    </p>
+
+    <p>
+      We'll notify you when updates are available via the Android Developers
+      Blog, as well as via this site and the <a href=
+      "http://g.co/androidweardev">Android Wear Developer Community on G+</a>.
+    </p>
+
+    <h2 id="what's_in_the_android_wear_2_0_developer_preview">
+      What's in the Android Wear 2.0 Developer Preview
+    </h2>
+
+    <p>
+      The preview includes everything you need to test your existing apps on a
+      variety of hardware configurations.
+    </p>
+
+    <h3 id="developer_resources">
+      Developer resources
+    </h3>
+
+    <p>
+      You can download these components through the SDK Manager in <a href=
+      "{@docRoot}sdk/installing/adding-packages.html">Android Studio</a>. For
+      more information, see <a href=
+      "{@docRoot}wear/preview/downloads.html">Download and Test with a
+      Device</a>.
+    </p>
+
+    <ul>
+      <li>Android Wear 2.0 Developer Preview <strong>SDK/support
+      library</strong>
+      </li>
+
+      <li>Android Wear 2.0 Developer Preview <strong>emulator system
+      image</strong>
+      </li>
+    </ul>
+
+    <p>
+      We'll provide updates to these development tools at each milestone as
+      needed.
+    </p>
+
+    <h3 id="hardware_system_images">
+      Hardware system images
+    </h3>
+
+    <p>
+      You can download these hardware system images at <a href=
+      "{@docRoot}wear/preview/downloads.html">Download and Test with a
+      Device</a>:
+    </p>
+
+    <ul>
+      <li>LGE Watch Urbane 2nd Edition
+      </li>
+
+      <li>Huawei Watch
+      </li>
+    </ul>
+
+    <p>
+     Please keep in mind that the Developer Preview system images
+     are for app developers only, and for compatibility testing and
+     early development only, and are not ready for day-to-day use.
+    </p>
+
+    <h3 id="documentation_and_sample_code">
+      Documentation and sample code
+    </h3>
+
+    <p>
+      These documentation resources help you learn about the preview:
+    </p>
+
+    <ul>
+      <li><a href=
+      "{@docRoot}wear/preview/start.html">Get Started</a>
+      has step-by-step instructions for
+      setting up the SDK.
+      </li>
+
+      <li>Documentation of new APIs, including an
+      <a href="{@docRoot}wear/preview/api-overview.html">API Overview</a>,
+      downloadable
+      <a href="{@docRoot}wear/preview/start.html#get_the_preview_reference_documentation">API Reference</a>,
+      and developer guides on key features such as
+      <a href="{@docRoot}wear/preview/features/complications.html">complications</a>
+      and design patterns for Wear.
+      </li>
+
+      <li>Sample code that demonstrates how to implement
+      complications and other new features.
+      </li>
+    </ul>
+
+    <h3 id="support_resources">
+      Support Resources
+    </h3>
+
+    <p>
+      Use these support resources as you test and develop on the Android Wear
+      2.0 Developer Preview:
+    </p>
+
+    <ul>
+      <li>Wear Developer Preview
+      <a href="https://g.co/wearpreviewbug">Issue Tracker</a> is your primary feedback
+      channel. You can report bugs, performance issues, and general feedback
+      through the issue tracker. You can also check for known issues and find
+      workaround steps.
+      </li>
+
+      <li>The <a href="http://g.co/androidweardev">Wear Developer Community</a>
+      is a Google+ community where you can connect with other developers
+      working with Android Wear. You can share observations or ideas or find
+      answers to questions about Android Wear.
+      </li>
+    </ul>
diff --git a/docs/html/wear/preview/start.jd b/docs/html/wear/preview/start.jd
new file mode 100644
index 0000000..65d4b56
--- /dev/null
+++ b/docs/html/wear/preview/start.jd
@@ -0,0 +1,207 @@
+page.title=Get Started with the Preview
+meta.keywords="wear-preview"
+page.tags="wear-preview"
+page.image=images/cards/card-n-sdk_2x.png
+
+@jd:body
+
+
+    <div id="qv-wrapper">
+      <div id="qv">
+        <ol>
+          <li>
+            <a href="#install_android_studio_and_the_latest_packages">Install
+            Android Studio and the Latest Packages</a>
+          </li>
+
+          <li>
+            <a href="#get_the_preview_reference_documentation">Get the Preview
+            Reference Documentation</a>
+          </li>
+
+          <li>
+            <a href="#update_or_create_a_project">Update or Create a
+            Project</a>
+          </li>
+        </ol>
+      </div>
+    </div>
+
+    <p>
+      If you want an environment for basic compatibility
+      testing of your app, you can use your current APK and a
+      supported watch or an emulator. You don't necessarily need to update your
+      full development environment to do basic testing. To simply test your
+      app's compatibility with a preview system image, see <a href=
+      "{@docRoot}wear/preview/downloads.html">Download and Test with a
+      Device</a>.
+    </p>
+
+    <p>
+      However, to develop apps for the Android Wear 2.0 Developer Preview, you
+      need to make some updates to your development environment, as described
+      below.
+    </p>
+
+    <h2 id="install_android_studio_and_the_latest_packages">
+      Install Android Studio and the Latest Packages
+    </h2>
+
+    <p>
+      1. For compatibility with the <a href="{@docRoot}preview/overview.html">N
+      Developer Preview</a>, follow the <a href=
+      "{@docRoot}preview/setup-sdk.html">setup instructions</a> for installing
+      the latest version of Android Studio.
+    </p>
+
+    <p>
+      2. Use the <a href="{@docRoot}tools/help/sdk-manager.html">SDK
+      manager</a> to install or confirm that you have the latest installations
+      of the following packages:
+    </p>
+
+    <ul>
+      <li>Under the <strong>SDK Platforms tab</strong>:
+        <ul>
+          <li>Android N Preview
+          </li>
+        </ul>
+      </li>
+
+      <li>Under the <strong>SDK Tools tab</strong>:
+        <ul>
+          <li>Android Support Library
+          </li>
+
+          <li>Google Play services
+          </li>
+
+          <li>Google Repository
+          </li>
+
+          <li>Android Support Repository
+          </li>
+        </ul>
+      </li>
+    </ul>
+
+    <h2 id="get_the_preview_reference_documentation">
+      Get the Preview Reference Documentation
+    </h2>
+
+    <p>
+      Detailed information about the preview is available in the preview
+      reference documentation, which you can download from the following table.
+      The zip file includes an updated API reference for the preview.
+    </p>
+
+    <table>
+      <tr>
+        <th style="width:300px">
+          Reference documentation
+        </th>
+        <th>
+          Checksums
+        </th>
+      </tr>
+
+      <tr>
+        <td>
+          <a href="http://storage.googleapis.com/androiddevelopers/shareables/wear-preview/wearable-support-preview-1-docs.zip">wearable-support-preview-1-docs.zip</a>
+        </td>
+        <td>MD5: 02f9dc7714c00076b323c9081655c3b2<br>
+            SHA-1: 075f3821ee9b66a919a0e8086f79c12bc9576fb2
+        </td>
+      </tr>
+    </table>
+
+    <h2 id="update_or_create_a_project">
+      Update or Create a Project
+    </h2>
+
+    <p>
+      To use the APIs, your project must be configured appropriately in Android
+      Studio.
+    </p>
+
+    <h3 id="update_an_existing_project">
+      Update an existing project
+    </h3>
+
+    <p>
+      To update an existing project for development:
+    </p>
+
+    <ol>
+      <li>Start Android Studio, click <strong>Open an existing Android Studio
+      Project</strong>, and select a project.
+      </li>
+
+      <li>If prompted by the Android SDK Manager for the SDK version to use for
+      the project, select <strong>Use Android Studio's
+      SDK</strong>.
+      </li>
+
+      <li>If prompted to update the Gradle plugin, update the version of the
+      plugin.
+      </li>
+
+      <li>In the <code>build.gradle</code> file for the Wear module, in the
+      <code>dependencies</code> section, update the existing reference to the
+      Wearable Support Library (for example, <code>compile
+      'com.google.android.support:wearable:1.4.0'</code>) by changing it to the
+      following, which requires that your the Google Repository <a href=
+      "#install_android_studio_and_the_latest_packages">is the latest
+      version</a>:
+      <pre>
+compile 'com.google.android.support:wearable:2.0.0-alpha1'
+      </pre>
+      </li>
+
+      <li>See the following page for setting up a watch or emulator with a
+      preview system image, in order to begin testing your app: <a href=
+      "{@docRoot}wear/preview/downloads.html">Download and Test with a
+      Device</a>
+      </li>
+    </ol>
+
+    <h3 id="create_a_new_project">
+      Create a new project
+    </h3>
+
+    <p>
+      To create a new project for development:
+    </p>
+
+    <ol>
+      <li>Click <strong>File &gt; New Project</strong> and follow the steps in
+      the Create New Project wizard until you reach the Target Android Devices
+      page.
+      </li>
+
+      <li>Optionally, select the <strong>Phone and Tablet</strong> option. If
+      you plan to use N Preview APIs in a phone app, then the Minimum SDK
+      option list, select <strong>API N: Android 6.x (N Preview)</strong>.
+      </li>
+
+      <li>Select the <strong>Wear</strong> option, and in the Minimum SDK
+      option list, select the latest available (<strong>N Preview</strong>)
+      option. Click <strong>Next</strong> until you exit the Create New Project
+      wizard.
+      </li>
+
+      <li>In the <code>build.gradle</code> file for the Wear module, in the
+      <code>dependencies</code> section, update the existing reference to the
+      Wearable Support Library (perhaps <code>compile
+      'com.google.android.support:wearable:1.4.0'</code>) to:
+      <pre>
+compile 'com.google.android.support:wearable:2.0.0-alpha1'
+      </pre>
+      </li>
+
+      <li>See the following page for setting up a watch or emulator with a
+      preview system image, in order to begin testing your app: <a href=
+      "{@docRoot}wear/preview/downloads.html">Download and Test with a
+      Device</a>
+      </li>
+    </ol>
diff --git a/docs/html/wear/preview/support.jd b/docs/html/wear/preview/support.jd
new file mode 100644
index 0000000..d03edf31
--- /dev/null
+++ b/docs/html/wear/preview/support.jd
@@ -0,0 +1,139 @@
+page.title=Support and Release Notes
+meta.keywords="preview", "wear"
+page.tags="preview", "developer preview"
+
+@jd:body
+
+<p>
+  If you experience problems when developing and testing with the
+  Wear 2.0 Developer Preview, please file bugs at
+  <a href="https://g.co/wearpreviewbug">https://g.co/wearpreviewbug</a>.
+</p>
+
+<p>
+  To discuss issues or ideas with other developers working with Android Wear,
+  join the <a href="https://plus.google.com/communities/113381227473021565406">
+  Wear Developer Google+ community</a>.
+</p>
+
+<h2 id="dp">Developer Preview 1</h2>
+
+<div class="wrap">
+  <div class="cols">
+    <div class="col-6of12">
+      <p><em>Date: May 2016<br />
+      Builds: Wearable Support 2.0.0-alpha1, NVD36I <br />
+      Emulator support: x86 & ARM (32-bit)<br/>
+      </em></p>
+    </div>
+  </div>
+</div>
+
+
+<h3 id="general_advisories">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.
+</p>
+
+<h4 id="deprecations">Deprecations</h4>
+
+
+<p>The following fields are deprecated in the Preview:</p>
+
+<ul>
+  <li>The <code>Notification.WearableExtender#setCustomSizePreset(int)</code>
+  method no longer accepts <code>SIZE_FULL_SCREEN</code> and this value is now
+  undefined.
+  </li>
+
+  <li>The <code>Notification.WearableExtender#setContentIcon(int)</code> method
+  is deprecated.
+  </li>
+</ul>
+
+<h3 id="known_issues">Known Issues</h3>
+
+
+<h4 id="notifications">Notifications</h4>
+
+
+<ul>
+  <li>This preview release does not include support for notification groups,
+  but will be supported in a future release.
+  </li>
+  <li>Tapping on next and previous controls in a notification while playing
+  music does not work.
+  </li>
+  <li>Bottom drawer actions user interface overlaps with media card
+  notifications.
+  </li>
+  <li>The system does not generate Smart Reply responses even if
+  <code>setAllowGeneratedReplies(true)</code> is set.
+  </li>
+</ul>
+
+
+<h4 id="complications">Complications</h4>
+
+<ul>
+  <li>Battery information is not synchronized between watch face and drop down
+  quick menu.
+  </li>
+  <li>Play music crashes when tapping on music complication in watch face.
+  </li>
+</ul>
+
+
+<h4 id="system_user_interface">System User Interface</h4>
+
+<ul>
+  <li>Pressing the hardware button in ambient mode triggers active mode with
+  the app launcher instead of active mode only.
+  </li>
+  <li>Double pressing the power hardware button while on the launcher causes
+  the watch screen to turn black.
+  </li>
+  <li>Dismissing multiple notifications can cause app to force close.
+  </li>
+  <li>Turning screen lock to off (Enable and disable) functionality is not
+  reliable.
+  </li>
+  <li>Airplane mode does not work from quick settings.
+  </li>
+  <li>Tapping Google keyboard English (United States) displays a <em>Settings
+  under construction</em> message.
+  </li>
+  <li>First calendar event notification must be dismissed in order to show the
+  rest of the event card.
+  </li>
+  <li>Unable to turn off the Wifi on wearable.
+  </li>
+  <li>Voice transcription may not work reliably at this time.
+  </li>
+</ul>
+
+
+<h4 id="companion_app">Companion App</h4>
+
+<ul>
+  <li>'More actions' via Companion app shows a blank screen on phone running
+  nyc-release and watch running feldspar-release.
+  </li>
+  <li>Select watch face on companion wear app will not change watch face on
+  wearable.
+  </li>
+</ul>
+
+
+<h4 id="devices">Devices</h4>
+
+<ul>
+  <li>On the Huawei Watch, selecting the language, followed by multiple
+  acknowledgement dialogues results in a black screen.
+  </li>
+  <li>On the LG Watch Urbane LTE, when answering call from the watch, the watch
+  does not provide audio from the caller.
+  </li>
+</ul>
diff --git a/docs/html/wear/wear_toc.cs b/docs/html/wear/wear_toc.cs
index 65ac2e9..93f554f 100644
--- a/docs/html/wear/wear_toc.cs
+++ b/docs/html/wear/wear_toc.cs
@@ -1,74 +1,53 @@
 <ul id="nav">
 
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/preview/start.html">Get Started
-      </a></div>
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>wear/preview/index.html">
+        Wear Developer Preview
+        </a></div>
   </li>
 
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/design/user-interface.html">UI Overview
-      </a></div>
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>wear/preview/program.html">
+        Program Overview
+        </a></div>
   </li>
 
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/design/index.html">Design Principles
-      </a></div>
+    <div class="nav-section-header">
+      <a href="<?cs var:toroot ?>wear/preview/api-overview.html">
+        API Overview
+        </a></div>
+
+      <ul>
+        <li><a href="<?cs var:toroot ?>wear/preview/features/wear-apk.html">
+          Wear APKs</a></li>
+        <li><a href="<?cs var:toroot ?>wear/preview/features/complications.html">
+          Complications</a></li>
+       </ul>
+
   </li>
 
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/notifications/creating.html">Creating Notifications for Android Wear
-      </a></div>
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>wear/preview/downloads.html">
+        Downloads
+        </a></div>
   </li>
 
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/notifications/remote-input.html">Receiving Voice Input from a Notification
-      </a></div>
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>wear/preview/start.html">
+        Get Started
+        </a></div>
   </li>
 
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/notifications/pages.html">Adding Pages to a Notification
-      </a></div>
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>wear/preview/license.html">
+        License Agreement
+        </a></div>
   </li>
 
-  <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/notifications/stacks.html">Stacking Notifications
-      </a></div>
-  </li>
-
-  <li class="nav-section">
-    <div class="nav-section-header"><a href="<?cs var:toroot ?>reference/android/preview/support/package-summary.html">Notification Reference</a></div>
-    <ul class="tree-list-children">
-<li class="nav-section">
-<div class="nav-section-header-ref"><span class="tree-list-subtitle package" title="android.preview.support.v4.app">android.preview.support.v4.app</span></div>
-  <ul>
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/v4/app/NotificationManagerCompat.html">NotificationManagerCompat</a></li>
-  </ul>
-</li>
-
-<li class="nav-section">
-<div class="nav-section-header-ref"><span class="tree-list-subtitle package" title="android.preview.support.wearable.notifications">android.preview.support.wearable.notifications</span></div>
-<ul>
-
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/wearable/notifications/RemoteInput.html">RemoteInput</a></li>
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/wearable/notifications/RemoteInput.Builder.html" >RemoteInput.Builder</a></li>
-
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/wearable/notifications/WearableNotifications.html">WearableNotifications</a></li>
-
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/wearable/notifications/WearableNotifications.Action.html">WearableNotifications.Action</a></li>
-
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/wearable/notifications/WearableNotifications.Action.Builder.html">WearableNotifications.Action.Builder</a></li>
-
-<li><a href="<?cs var:toroot ?>reference/android/preview/support/wearable/notifications/WearableNotifications.Builder.html">WearableNotifications.Builder</a></li>
-	</ul>
-  </li>
-</ul>
-</li>
-
-
-
-  <li class="nav-section">
-    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>wear/license.html">License Agreement</a></div>
-  </li>
-
-
 </ul>
diff --git a/docs/html/work/_book.yaml b/docs/html/work/_book.yaml
new file mode 100644
index 0000000..82571f3
--- /dev/null
+++ b/docs/html/work/_book.yaml
@@ -0,0 +1,18 @@
+toc:
+- title: Android for Work Home
+  path: /work/index.html
+
+- title: Overview
+  path: /work/overview.html
+
+- title: Developer Guide
+  path: /work/guide.html
+
+- title: Set up Managed Profiles
+  path: /work/managed-profiles.html
+
+- title: Set up App Restrictions
+  path: /work/app-restrictions.html
+
+- title: Set up Single-Purpose Devices
+  path: /work/cosu.html
diff --git a/docs/html/training/enterprise/app-restrictions.jd b/docs/html/work/app-restrictions.jd
similarity index 78%
rename from docs/html/training/enterprise/app-restrictions.jd
rename to docs/html/work/app-restrictions.jd
index 07b1de7..4122988b 100644
--- a/docs/html/training/enterprise/app-restrictions.jd
+++ b/docs/html/work/app-restrictions.jd
@@ -1,27 +1,18 @@
-page.title=Implementing App Restrictions
+page.title=Set up App Restrictions
 page.metaDescription=Learn how to implement app restrictions and configuration settings that can be changed by other apps on the same device.
+page.image=images/work/cards/briefcase_600px.png
+
 @jd:body
 
-<div id="tb-wrapper">
-<div id="tb">
-
-<h2>This lesson teaches you to</h2>
-<ol>
- <li><a href="#define_restrictions">Define App Restrictions</a></li>
- <li><a href="#check_restrictions">Check App Restrictions</a></li>
- <li><a href="#listen">Listen for App Restriction Changes</a></li>
-</ol>
-
-<!-- related docs (NOT javadocs) -->
-<h2>Resources</h2>
-<ul>
-  <li><a href="{@docRoot}samples/AppRestrictionSchema/index.html">AppRestrictionSchema</a>
-    sample app</li>
-  <li><a href="{@docRoot}samples/AppRestrictionEnforcer/index.html">AppRestrictionEnforcer</a>
-    sample app</li>
-</ul>
-
-</div>
+<div id="qv-wrapper">
+  <div id="qv">
+    <h2>In this document</h2>
+    <ol>
+      <li><a href="#define_restrictions">Define App Restrictions</a></li>
+      <li><a href="#check_restrictions">Check App Restrictions</a></li>
+      <li><a href="#listen">Listen for App Restriction Changes</a></li>
+    </ol>
+  </div>
 </div>
 
 <p>If you are developing apps for the enterprise market, you may need to satisfy
@@ -152,10 +143,10 @@
 &lt;restrictions xmlns:android="http://schemas.android.com/apk/res/android" &gt;
 
   &lt;restriction
-    android:key="download_on_cell"
-    android:title="@string/download_on_cell_title"
+    android:key="downloadOnCellular"
+    android:title="App is allowed to download data via cellular"
     android:restrictionType="bool"
-    android:description="@string/download_on_cell_description"
+    android:description="If 'false', app can only download data via Wi-Fi"
     android:defaultValue="true" /&gt;
 
 &lt;/restrictions&gt;
@@ -166,12 +157,6 @@
   documented in the reference for {@link android.content.RestrictionsManager}.
 </p>
 
-<p class="note">
-  <strong>Note:</strong> <code>bundle</code> and
-  <code>bundle_array</code> restriction types are not supported by Google Play
-  for Work.
-</p>
-
 <p>
   You use each restriction's <code>android:key</code> attribute to read its
   value from a restrictions bundle. For this reason, each restriction must have
@@ -217,7 +202,7 @@
   </li>
 
   <li>When the app is notified of a restriction change, as described in
-    <a href="#listen">Listen for App Configuration
+    <a href="#listen">Listen for Device Configuration
     Changes</a>
   </li>
 </ul>
@@ -260,30 +245,9 @@
   the {@link android.content.Intent#ACTION_APPLICATION_RESTRICTIONS_CHANGED
   ACTION_APPLICATION_RESTRICTIONS_CHANGED} intent to find out if restrictions
   change while your app is active, as described in <a href="#listen">Listen for
-  App Restriction Changes</a>.
+  Device Configuration Changes</a>.
 </p>
 
-<p>
-  When your app checks for restrictions using
- {@link android.content.RestrictionsManager#getApplicationRestrictions
- RestrictionsManager.getApplicationRestrictions()}, we recommend that you
- check to see if the enterprise administrator has set the key-value pair
- {@link android.os.UserManager#KEY_RESTRICTIONS_PENDING} to true. If so, you
- should block the user from using the app, and prompt them to contact their
- enterprise administrator. The app should then proceed as normal, registering
- for the {@link android.content.Intent#ACTION_APPLICATION_RESTRICTIONS_CHANGED
- ACTION_APPLICATION_RESTRICTIONS_CHANGED} broadcast.
-</p>
-
-<img src="{@docRoot}images/training/enterprise/app_restrictions_diagram.png"
-width="620" srcset="{@docRoot}images/training/enterprise/app_restrictions_diagram.png 1x,
-{@docRoot}images/training/enterprise/app_restrictions_diagram_2x.png 2x" />
-
- <p class="img-caption">
-   <strong>Figure 1.</strong> Checking whether restrictions are pending before
-   registering for the broadcast.
- </p>
-
 <h3 id="read_restrictions">
   Reading and applying restrictions
 </h3>
@@ -293,11 +257,11 @@
   getApplicationRestrictions()} method returns a {@link android.os.Bundle}
   containing a key-value pair for each restriction that has been set. The
   values are all of type <code>Boolean</code>, <code>int</code>,
-  <code>String</code>, <code>String[]</code>, <code>Bundle</code>, and
-  <code>Bundle[]</code>. Once you have the restrictions {@link android.os.Bundle},
-  you can check the current restrictions settings with the standard
-  {@link android.os.Bundle} methods for those data types, such as
-  {@link android.os.Bundle#getBoolean getBoolean()} or
+  <code>String</code>, and <code>String[]</code>. Once you have the
+  restrictions {@link android.os.Bundle}, you can check the current
+  restrictions settings with the standard {@link android.os.Bundle} methods for
+  those data types, such as {@link android.os.Bundle#getBoolean getBoolean()}
+  or
   {@link android.os.Bundle#getString getString()}.
 </p>
 
@@ -311,11 +275,10 @@
 
 <p>
   It is up to your app to take appropriate action based on the current
-  restrictions settings. For example, if your app has a restriction schema
-  to specify whether it can download over a cellular connection (like the
-  example in <a href="#define_restrictions">Define App Restrictions</a>),
-  and you find that the restriction is set to false, you would have to disable
-  data download except when the device has a Wi-Fi connection, as shown in the
+  restrictions settings. For example, if your app has a restriction specifying
+  whether it can download data over a cellular connection, and you find that
+  the restriction is set to <code>false</code>, you would have to disable data
+  download except when the device has a Wi-Fi connection, as shown in the
   following example code:
 </p>
 
@@ -335,13 +298,6 @@
     // ...show appropriate notices to user
 }</pre>
 
-<p class="note">
-   <strong>Note:</strong> The restrictions schema should be
-   backward and forward compatible, since Google Play for Work
-   gives the EMM only one version of the App Restrictions
-   Schema per app.
- </p>
-
 <h2 id="listen">
   Listen for App Restriction Changes
 </h2>
@@ -389,8 +345,8 @@
   <strong>Note:</strong> Ordinarily, your app does not need to be notified
   about restriction changes when it is paused. Instead, you should unregister
   your broadcast receiver when the app is paused. When the app resumes, you
-  first check for the current restrictions (as discussed in
-  <a href="#check_restrictions">Check App Restrictions</a>), then register
-  your broadcast receiver to make sure you're notified about restriction changes
+  first check for the current restrictions (as discussed in <a href=
+  "#check_restrictions">Check Device Restrictions</a>), then register your
+  broadcast receiver to make sure you're notified about restriction changes
   that happen while the app is active.
 </p>
diff --git a/docs/html/training/enterprise/cosu.jd b/docs/html/work/cosu.jd
similarity index 90%
rename from docs/html/training/enterprise/cosu.jd
rename to docs/html/work/cosu.jd
index 1d6388b..3058365 100644
--- a/docs/html/training/enterprise/cosu.jd
+++ b/docs/html/work/cosu.jd
@@ -1,27 +1,20 @@
-page.title=Configuring Corporate-Owned, Single-Use Devices
+page.title=Set up Single-Purpose Devices
+page.tags=work, cosu
+page.keywords=cosu, work
 page.metaDescription=Learn how to develop single-use solutions for Android devices.
+page.image=images/work/cards/briefcase_600px.png
 
 @jd:body
 
-<div id="tb-wrapper">
-<div id="tb">
-
-<h2>This lesson teaches you to</h2>
-<ol>
- <li><a href="#locktask">How to use LockTask mode</a></li>
- <li><a href="#cosu-solutions">Build COSU solutions</a></li>
- <li><a href="#create-dpc">Create your own DPC app</a></li>
-</ol>
-
-<!-- related docs (NOT javadocs) -->
-<h2>You should also read</h2>
-<ul>
-  <li><a href="{@docRoot}training/enterprise/work-policy-ctrl.html">
-Building a Device Policy Controller</a>
-  </li>
-</ul>
-
-</div>
+<div id="qv-wrapper">
+  <div id="qv">
+    <h2>In this document</h2>
+    <ol>
+      <li><a href="#locktask">How to use LockTask mode</a></li>
+      <li><a href="#cosu-solutions">Build COSU solutions</a></li>
+      <li><a href="#create-dpc">Create your own DPC app</a></li>
+    </ol>
+  </div>
 </div>
 
 <p>
@@ -73,9 +66,9 @@
 This graphic compares the features of app pinning and lock task mode:
 </p>
 
-<img src="{@docRoot}images/training/enterprise/pinning_vs_locktaskmode.png"
-width="640" srcset="{@docRoot}images/training/enterprise/pinning_vs_locktaskmode.png 1x,
-{@docRoot}images/training/enterprise/pinning_vs_locktaskmode_2x.png 2x" />
+<img src="{@docRoot}images/work/cosu-pinning_vs_locktaskmode.png"
+width="640" srcset="{@docRoot}images/work/cosu-pinning_vs_locktaskmode.png 1x,
+{@docRoot}images/work/cosu-pinning_vs_locktaskmode_2x.png 2x" />
 
  <p class="img-caption">
    <strong>Figure 1.</strong> Comparing the features of app pinning in Lollipop
@@ -422,7 +415,7 @@
         // set System Update policy
 
         if (active){
-        	mDevicePolicyManager.setSystemUpdatePolicy(mAdminComponentName, 
+          mDevicePolicyManager.setSystemUpdatePolicy(mAdminComponentName,
                 SystemUpdatePolicy.createWindowedInstallPolicy(60,120));
         }
         else
@@ -431,7 +424,7 @@
         // set this Activity as a lock task package
 
         mDevicePolicyManager.setLockTaskPackages(mAdminComponentName,
-    	    active ? new String[]{getPackageName()} : new String[]{});
+          active ? new String[]{getPackageName()} : new String[]{});
 
         IntentFilter intentFilter = new IntentFilter(Intent.ACTION_MAIN);
         intentFilter.addCategory(Intent.CATEGORY_HOME);
@@ -460,18 +453,18 @@
     }
 
     private void enableStayOnWhilePluggedIn(boolean enabled) {
-    	if (enabled) {
-    		mDevicePolicyManager.setGlobalSetting(
-    			mAdminComponentName, 
-                        Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
-    			BatteryManager.BATTERY_PLUGGED_AC 
-    			| BatteryManager.BATTERY_PLUGGED_USB 
-    			| BatteryManager.BATTERY_PLUGGED_WIRELESS);
-    	} else {
-    		mDevicePolicyManager.setGlobalSetting(
-    			mAdminComponentName, 
-                        Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
-    	}
+      if (enabled) {
+        mDevicePolicyManager.setGlobalSetting(
+          mAdminComponentName,
+          Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
+          BatteryManager.BATTERY_PLUGGED_AC
+          | BatteryManager.BATTERY_PLUGGED_USB
+          | BatteryManager.BATTERY_PLUGGED_WIRELESS);
+      } else {
+        mDevicePolicyManager.setGlobalSetting(
+          mAdminComponentName,
+          Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
+      }
 
     }
 
diff --git a/docs/html/training/enterprise/device-management-policy.jd b/docs/html/work/device-management-policy.jd
similarity index 98%
rename from docs/html/training/enterprise/device-management-policy.jd
rename to docs/html/work/device-management-policy.jd
index 5190a22..d564b89 100644
--- a/docs/html/training/enterprise/device-management-policy.jd
+++ b/docs/html/work/device-management-policy.jd
@@ -24,7 +24,7 @@
 <h2>Try it out</h2>
 
 <div class="download-box">
- <a href="http://developer.android.com/shareables/training/DeviceManagement.zip"
+ <a href="{@docRoot}shareables/training/DeviceManagement.zip"
 class="button">Download the sample</a>
  <p class="filename">DeviceManagement.zip</p>
 </div>
diff --git a/docs/html/work/guide.jd b/docs/html/work/guide.jd
new file mode 100644
index 0000000..a93bfa5
--- /dev/null
+++ b/docs/html/work/guide.jd
@@ -0,0 +1,530 @@
+page.title=Android for Work Developer Guide
+page.tags="work", "android for work", "afw", "developer", "android"
+page.metaDescription=Android for Work provides organizations with a secure, flexible, and unified Android mobility platform combining devices, applications, and management.
+page.image=images/work/cards/android-studio_600px.png
+
+@jd:body
+
+<div id="qv-wrapper">
+  <div id="qv">
+    <h2>In this document</h2>
+    <ul>
+      <li><a href="#managed-profiles">Managed Profiles</a></li>
+      <li><a href="#app-restrictions">Implementing App Restrictions</a></li>
+      <li><a href="#cosu">COSU Devices</a></li>
+      <li><a href="#sso">Set up Single Sign-on with Chrome Custom Tabs</a></li>
+      <li><a href="#testing">Test Your App</a></li>
+    </ul>
+  </div>
+</div>
+
+<p>
+  Android for Work provides organizations with a secure, flexible, and
+  unified Android mobility platform—combining devices, applications,
+  and management. By default, Android apps are compatible with Android
+  for Work. However, there are additional features you can use to make
+  your Android app work best on a managed device:
+</p>
+
+<ul>
+  <li>
+    <a href="#managed-profiles">Managed profile compatibility</a>—Modify your Android
+    app so it functions best on an Android device with a work profile.
+  </li>
+  <li>
+    <a href="#app-restrictions">Managed configuration using app restrictions</a>—Modify
+    your app to allow IT administrators the option to specify custom
+    settings for your apps.
+  </li>
+  <li>
+    <a href="#cosu">Corporate-owned, single-use (COSU)</a>—Optimize your
+    app so that it can be deployed on an Android device as a kiosk.
+  </li>
+  <li>
+    <a href="#sso">Single Sign-On (SSO)</a>—Simplify the sign-on process
+    for users signing in to different apps on their Android device
+    running Android for Work.
+  </li>
+</ul>
+
+<h3>Prerequisites</h3>
+
+<ol>
+  <li>You’ve created an Android app.</li>
+  <li>You’re ready to modify your app so that it works best with
+    Android for Work.</li>
+  <li>Minimum version: Android 5.0 Lollipop recommended version:
+    Android 6.0 Marshmallow and later.</li>
+</ol>
+
+<p>
+  <strong>Note:</strong> Android for Work functions natively on most
+  Android 5.0 devices; however, Android 6.0 and later offers
+  additional features for Android for Work, especially with regard to
+  COSU.
+</p>
+
+<h2 id="managed-profiles">Manage Profiles</h2>
+
+<p>
+  You can manage a user’s business data and applications through a
+  work profile. A work profile is a managed corporate profile
+  associated with the primary user account on an Android device. A
+  work profile securely isolates work apps and data from personal apps
+  and data. This work profile is in a separate container from the
+  personal profile, which your user controls. These separate profiles
+  allow organizations to manage the business data they care about, but
+  leave everything else on a user’s device under the user’s control.
+  For a deep dive into best practices, see the
+  <a href="{@docRoot}work/managed-profiles.html">Set up Managed Profiles</a>
+  guide. For an overview of those best practices, see below.
+</p>
+
+<h3>Key features of a managed profile</h3>
+
+<ul>
+  <li>Separate and secure profile</li>
+  <li>Google Play for Work for application distribution</li>
+  <li>Separate badged work applications</li>
+  <li>Profile-only management capabilities controlled by an administrator</li>
+</ul>
+
+<h3>Managed profile benefits on Android 5.0+</h3>
+
+<ul>
+  <li>Full device encryption</li>
+  <li>One Android application package (APK) for both profiles when
+    there’s a personal profile and a work profile present on the device</li>
+  <li><a href="https://support.google.com/work/android/answer/6192678"
+      >Device policy controller</a> (DPC) is limited to the managed profile</li>
+  <li>Device administration via the
+    <a href="{@docRoot}reference/android/app/admin/DevicePolicyManager.html"
+    >DevicePolicyManager</a> class</li>
+</ul>
+
+<h3>Considerations for managed profiles</h3>
+<ul>
+  <li>The Android system prevents intents
+    <a href="{@docRoot}reference/android/app/admin/DevicePolicyManager.html#clearCrossProfileIntentFilters(android.content.ComponentName)"
+    >from crossing profiles</a> and IT administrators can
+    <a href="{@docRoot}reference/android/app/admin/DevicePolicyManager.html#enableSystemApp(android.content.ComponentName,%20java.lang.String)"
+    >enable or disable system apps</a>.</li>
+  <li>A file path (Uniform Resource Identifier [URI]) that’s valid on
+    one profile may not be valid on the other.</li>
+</ul>
+
+<h3>Prevent intents from failing between profiles</h3>
+<p>
+  It’s difficult to know which intents can cross between profiles, and
+  which ones are blocked. The only way to know for sure is by testing.
+  Before your app starts an activity, you should verify that the
+  request is resolved by calling
+  <a href="{@docRoot}reference/android/content/Intent.html#resolveActivity(android.content.pm.PackageManager)"
+  ><code>Intent.resolveActivity()</code></a>.
+  <ul>
+    <li>If it returns <code>null</code>, the request doesn’t resolve.</li>
+    <li>If it returns something, it shows that the intent resolves,
+      and it’s safe to send the intent.</li>
+  </ul>
+</p>
+<p>
+  <strong>Note</strong>: For detailed testing instructions, see
+  <a href="{@docRoot}work/managed-profiles.html#prevent_failed_intents"
+  >Prevent Failed Intents</a>.
+</p>
+
+<h3>Share files across profiles</h3>
+<p>
+  Some developers use URIs to mark file paths in Android. However,
+  with Android for Work, because there are separate profiles, we
+  recommend:
+</p>
+
+<table>
+  <tr>
+    <td style="white-space:nowrap;">
+      <strong>Use:</strong><br/>
+      Content URIs
+    </td>
+    <td>
+      <ul>
+        <li>
+          The <a href="{@docRoot}reference/android/content/ContentUris.html"
+          >content URIs</a> contain the authority, path, and ID for a
+          specific file. You can generate this using
+          <a href="{@docRoot}reference/android/support/v4/content/FileProvider.html"
+          >FileProvider</a> subclass.
+          <a href="{@docRoot}training/secure-file-sharing/index.html">Learn more</a>
+        </li>
+        <li>
+          Share and grant permissions to access the content URI using
+          an Intent. Permissions can only be passed across the profile
+          boundary using Intents. If you grant another app access rights
+          to your file using
+          <a href="{@docRoot}reference/android/content/Context.html#grantUriPermission(java.lang.String,%20android.net.Uri,%20int)"
+          ><code>Context.grantUriPermission()</code></a>, it only is granted for
+          that app in the same profile.</li>
+      </ul>
+    </td>
+  </tr>
+  <tr>
+    <td style="white-space:nowrap;">
+      <strong>Don't use:</strong><br/>
+      File URI
+    </td>
+    <td>
+      <ul>
+        <li>Contains the absolute path of the file on the device’s
+          storage.</li>
+        <li>A file path URI that’s valid on one profile isn’t valid on
+          the other.</li>
+        <li>If you attach a file URI to an intent, a handler is unable
+          to access the file in another profile.</li>
+      </ul>
+    </td>
+  </tr>
+</table>
+
+<p>
+  <strong>Next steps</strong>: Once your app supports managed
+  profiles, test it in a work profile. See
+  <a href="#testing">Test your app with Android for Work</a>.
+</p>
+
+<h2 id="app-restrictions">Implementing App Restrictions</h2>
+
+<p>
+  App restrictions are a set of instructions that IT administrators
+  can use to manage their users’ mobile devices in a specific way.
+  These instructions are universal and work across any EMM, allowing
+  administrators to remotely configure applications on their users’
+  phones.
+</p>
+
+<p>
+  If you’re developing apps for business or government, you may need
+  to satisfy your industry’s specific set of requirements. Using
+  application restrictions, the IT administrator can remotely specify
+  settings and enforce policies for their users’ Android apps; for
+  example:
+</p>
+
+<ul>
+  <li>Configure if an app can sync data via cellular/3G, or only Wi-Fi</li>
+  <li>Whitelist or blacklist URLs on a web browser</li>
+  <li>Configure an app's email settings</li>
+  <li>Enable or disable printing</li>
+  <li>Manage bookmarks</li>
+</ul>
+
+<h3>Best practices for implementing app restrictions</h3>
+
+<p>
+  The <a href="{@docRoot}work/app-restrictions.html">Set up App Restrictions</a>
+  guide is the key source for information on how to build and deploy
+  app restrictions. After you’ve reviewed this documentation, see
+  recommendations below for additional guidance.
+</p>
+
+<h4>When first launching the app</h4>
+<p>
+  As soon as you launch an application, you can see if app
+  restrictions are already set for this app in <code>onStart()</code> or
+  <code>onResume()</code>. Additionally, you can find out if your
+  application is managed or unmanaged. For example, if
+  <a href="{@docRoot}reference/android/content/RestrictionsManager.html#getApplicationRestrictions()"
+  ><code>getApplicationRestrictions()</code></a> returns:
+  <ul>
+    <li><strong>A set of application-specific restrictions</strong>—You
+      can configure the app restrictions silently (without requiring
+      user input).</li>
+    <li><strong>An empty bundle</strong>—Your application acts like
+      it’s unmanaged (for example, how the app behaves in a personal
+      profile).</li>
+    <li><strong>A bundle with a single key value pair with
+      <a href="{@docRoot}reference/android/os/UserManager.html#KEY_RESTRICTIONS_PENDING"
+      ><code>KEY_RESTRICTIONS_PENDING</code></a> set to true</strong>—your
+      application is being managed, but the DPC isn’t configured
+      correctly. You should block this user from your app, and direct
+      them to their IT administrator.</li>
+  </ul>
+</p>
+
+<h4>Listen for changes to app restrictions</h4>
+<p>
+  IT administrators can change app restrictions and what policies they
+  want to enforce on their users at any time. Because of this, we
+  recommend you ensure that your app can accept new restrictions as
+  follows:
+</p>
+
+<ul>
+  <li><strong>Fetch restrictions on launch</strong>—Your app should
+    call <code>getApplicationRestrictions()</code> in <code>onStart()</code>
+    and <code>onResume()</code>, and compare against old restrictions
+    to see if changes are required.</li>
+  <li><strong>Listen while running</strong>—Dynamically register
+    <a href="{@docRoot}reference/android/content/Intent.html#ACTION_APPLICATION_RESTRICTIONS_CHANGED"
+    ><code>ACTION_APPLICATION_RESTRICTIONS_CHANGED</code></a> in your
+    running activities or services, after you’ve checked for new
+    restrictions. This intent is sent only to listeners that are
+    dynamically registered, and not to listeners declared in the app
+    manifest.</li>
+  <li><strong>Unregister while not running</strong>—In <code>onPause()</code>,
+    you should unregister for the broadcast of
+    <code>ACTION_APPLICATION_RESTRICTIONS_CHANGED</code>.</li>
+</ul>
+
+<h2 id="cosu">COSU Devices</h2>
+
+<p>
+  Corporate-owned, single-use devices (COSU) are kiosk devices used
+  for a single purpose, such as digital signage displays, ticket
+  printing kiosks, or checkout registers.
+</p>
+<p>
+  When an Android device is configured as a COSU device, the user sees
+  an application locked to the screen with no Home or Recent Apps
+  buttons to escape the app. COSU can also be configured to show a set
+  of applications, such as a library kiosk with an app for the library
+  catalog and a web browser.
+</p>
+<p>
+  For instructions, see
+  <a href="{@docRoot}work/cosu.html">Set up Single-Purpose Devices</a>.
+</p>
+
+<h2 id="sso">Set up Single Sign-on with Chrome Custom Tabs</h2>
+
+<p>
+  Enterprise users often have multiple apps on their device, and they
+  prefer to sign in once to access all of their work applications.
+  Typically, users sign in through a
+  <a href="https://developer.chrome.com/multidevice/webview/overview">WebView</a>;
+  however, there are a couple reasons why this isn’t ideal:
+</p>
+<ol>
+  <li>
+    Users often need to sign in multiple times with the same
+    credentials. The WebView solution often isn’t a true Single
+    Sign-On (SSO) experience.
+  </li>
+  <li>
+    There can be security risks, including malicious applications
+    inspecting cookies or injecting JavaScript® to access a user’s
+    credentials. Even trusted developers are at risk if they rely on
+    potentially malicious third-party SDKs.
+  </li>
+</ol>
+
+<p>
+  A solution to both problems is to authenticate users using Chrome
+  Custom Tabs, instead of WebView. This ensures that authentication:
+</p>
+<ul>
+  <li>
+    Occurs in a secure context (the system browser) where the host app
+    cannot inspect contents.
+  </li>
+  <li>
+    Has a shared cookie state, ensuring the user has to sign in only
+    once.
+  </li>
+</ul>
+
+<h3>Requirements</h3>
+
+<p>
+  Chrome Custom Tabs are supported using Platform APIs from API level
+  23 (Android 6.0), and support libraries back to API level 4 (Android
+  1.6). To implement Chrome Custom Tabs, you need to use a supported
+  browser, such as Chrome 45 or later.
+</p>
+
+<h3>How do I implement Chrome Custom Tabs?</h3>
+
+<p>
+  Google, in conjunction with the OpenID Foundation, has published an
+  open source library on GitHub. To set up Chrome Custom Tabs for SSO,
+  see the <a href="https://github.com/openid/AppAuth-Android"
+  >documentation and sample code on GitHub</a>.
+</p>
+
+<h2 id="testing">Test your App with Android for Work</h2>
+
+<p>
+  Once you’ve developed your app, you’ll want to test it in a work
+  profile—both as a profile owner and device owner. See the
+  instructions below.
+</p>
+
+<h3>Use TestDPC to test your Android app</h3>
+
+<p>
+  TestDPC is a tool you can use to test your Android app in a variety
+  of Android for Work environments. You can configure it as a profile
+  owner or a device owner to launch management APIs on your device,
+  using one of these methods:
+</p>
+<ul>
+  <li>Download the source code for TestDPC from
+    <a href="https://github.com/googlesamples/android-testdpc">GitHub</a>.</li>
+  <li>Install TestDPC directly from
+    <a href="https://play.google.com/store/apps/details?id=com.afwsamples.testdpc"
+    >Google Play</a>.</li>
+</ul>
+<p>
+  For more information on how to configure TestDPC, see the
+  instructions below and the
+  <a href="https://github.com/googlesamples/android-testdpc">TestDPC User Guide</a>.
+</p>
+
+<p>
+  <strong>REQUIRED</strong>: Your test Android device needs to run
+  Android 5.0 or later and be able to natively support Android for Work.
+</p>
+
+<h3>Provision a profile owner</h3>
+
+<p>
+  To test your app in a work profile, you need to first provision a
+  profile owner on the TestDPC app:
+</p>
+
+<ol>
+  <li>Launch the TestDPC app and click <strong>Set up profile</strong>.</li>
+  <li>When prompted, click <strong>Set up</strong>, ensuring the
+    TestDPC’s logo is highlighted on the screen.</li>
+  <li>If your device isn’t encrypted, you need to encrypt your device.
+    Follow the briefcase notification after reboot to continue
+    provisioning.<br/>
+    Once you’ve provisioned the profile owner correctly, badged
+    applications appear at the end of your app tray. Install your app
+    on the device and test to see how it runs in the work profile.
+  </li>
+  <li>
+    Install your app on the device and test to see how it runs in the
+    work profile.
+  </li>
+</ol>
+
+<h3>Provision a device owner</h3>
+
+<p>
+  Testing your app as a device owner requires more steps than testing
+  as a profile owner. You first need to provision the device owner on
+  your test device using the
+  <a href="{@docRoot}samples/NfcProvisioning/index.html"
+  >NfcProvisioning sample app</a>. For complete instructions to
+  provision TestDPC in device owner mode using the NfcProvisioning
+  app, see the <a href="https://github.com/googlesamples/android-testdpc"
+  >TestDPC User Guide</a>.
+</p>
+
+<ol>
+  <li>Download the <a href="{@docRoot}samples/NfcProvisioning/index.html"
+    >NfcProvisioning</a> app sample files to your development environment.</li>
+  <li>Unpack the project, open your shell, and <code>cd</code> to the project directory.</li>
+  <li>Add a file to the directory with the <code>local.properties</code> name
+    and the following content:
+    <pre>sdk.dir=/path/to/your/android/sdk</pre>
+  </li>
+  <li>While in the project directory, enter these commands to build the NfcProvisioning APK:
+    <pre>./gradlew init
+./gradlew build</pre>
+    The NfcProvisioning APK you need is now located in <code>./Application/build/outputs/apk</code>.
+  </li>
+  <li>Install the APK on your programmer device, which you can use to provision other devices.</li>
+  <li>Create a text file called <code>nfcprovisioning.txt</code> and
+    include the following information:
+    <pre>android.app.extra.PROVISIONING_DEVICE_ADMIN_PACKAGE_NAME=com.afwsamples.testdpc
+android.app.extra.PROVISIONING_DEVICE_ADMIN_PACKAGE_DOWNLOAD_LOCATION=https://testdpc-latest-apk.appspot.com
+android.app.extra.PROVISIONING_DEVICE_ADMIN_SIGNATURE_CHECKSUM=gJD2YwtOiWJHkSMkkIfLRlj-quNqG1fb6v100QmzM9w=
+# note: checksum must be URL-safe
+android.app.extra.PROVISIONING_LOCALE=en_US
+android.app.extra.PROVISIONING_TIME_ZONE=America/New_York</pre>
+    <p>
+      <strong>Note:</strong> If you’re developing for Android 5.0
+      Lollipop, see the instructions in the
+      <a href="https://github.com/googlesamples/android-testdpc"
+      >TestDPC User Guide</a>.
+    </p>
+  </li>
+  <li>Push that text file to your programmer device by entering:
+    <pre>adb push &lt;path-to-nfcprovisioning.txt&gt; /sdcard/</pre>
+  </li>
+  <li>
+    Ensure that the programmer device is connected to Wi-Fi on either
+    an unsecured or WPA2 secured network.
+    <p>
+      The NFC Provisioning app will automatically pass those Wi-Fi
+      credentials onto the target device.
+    </p>
+  </li>
+  <li>Open the NFC Provisioning app and ensure <code>com.google.android.testdpc</code>
+    is auto-populated.</li>
+  <li>Bump the devices to transfer the data.</li>
+  <li>Follow the onscreen instructions to set up your target device.</li>
+  <li>Once you’ve completed provisioning the device owner, you can test your app on that device. You
+    should specifically test how
+    <a href="{@docRoot}work/app-restrictions.html">app restrictions</a>,
+    <a href="{@docRoot}work/managed-profiles.html#sharing_files">URIs</a>, and
+    <a href="{@docRoot}work/managed-profiles.html#prevent_failed_intents">intents</a>
+    work on that device.</li>
+</ol>
+
+<h3>End-to-end testing</h3>
+
+<p>
+  After you’ve finished testing your app in the environments above,
+  you’ll likely want to test your app in an end-to-end production
+  environment. This process includes the steps a customer needs to
+  take to deploy your app in their organization, including:
+</p>
+
+<ul>
+  <li>App distribution through Play</li>
+  <li>Server-side app restriction configuration</li>
+  <li>Server-side profile policy control</li>
+</ul>
+
+<p>
+  You need to access an EMM console to complete the end-to-end
+  testing. The easiest way to get one is to request a testing console
+  from your EMM. Once you have access, complete these tasks:
+</p>
+
+<ol>
+  <li>Create a test version of your application with a
+    <a href="http://tools.android.com/tech-docs/new-build-system/applicationid-vs-packagename"
+    >new ApplicationId</a>.</li>
+  <li>Claim a <a href="https://support.google.com/work/android/answer/6174056"
+    >managed Google domain</a> and bind it to your EMM. If you
+    already have a testing domain that’s bound to an EMM, you may need
+    to unbind it to test it with your preferred EMM. Please consult your
+    EMM for the specific unbinding steps.</li>
+  <li><a href="https://support.google.com/a/answer/2494992"
+    >Publish your application to the private channel</a> for their
+    managed Google domain.</li>
+  <li>Use the EMM console and EMM application to:
+    <ol>
+      <li>Set up work devices.</li>
+      <li>Distribute your application.</li>
+      <li>Set application restrictions.</li>
+      <li>Set device policies.</li>
+    </ol>
+</ol>
+
+<p>
+  This process will differ based on your EMM. Please consult your
+  EMM’s documentation for further details. Congrats! You’ve completed
+  these steps and verified that your app works well with Android for
+  Work.
+</p>
+
+<p>
+  <a href="https://www.google.com/work/android/developers/applyDevHub/">
+    <span class="dac-sprite dac-auto-chevron"></span>
+    Learn about the Android for Work DevHub.
+  </a>
+</p>
diff --git a/docs/html/work/index.jd b/docs/html/work/index.jd
new file mode 100644
index 0000000..a71fedb
--- /dev/null
+++ b/docs/html/work/index.jd
@@ -0,0 +1,55 @@
+page.title=Android for Work
+page.tags="android for work, work",
+meta.tags="android for work, work",
+fullpage=true
+section.landing=true
+header.hide=1
+footer.hide=1
+@jd:body
+
+<section class="dac-expand dac-hero dac-light" >
+  <div class="wrap">
+    <div class="cols dac-hero-content">
+      <div class="col-9of16 col-push-7of16 dac-hero-figure">
+        <img class="dac-hero-image" src="{@docRoot}images/work/hero_650px_2x.png"
+             srcset="{@docRoot}images/work/hero_650px.png 1x,
+             {@docRoot}images/work/hero_650px_2x.png 2x">
+      </div>
+      <div class="col-7of16 col-pull-9of16">
+        <h1 class="dac-hero-title">Android for Work</h1>
+        <p class="dac-hero-description">
+          Develop apps for Android for Work to take advantage of
+          security and management features built into Android.
+        </p>
+
+        <a class="dac-hero-cta" href="{@docRoot}work/overview.html">
+          <span class="dac-sprite dac-auto-chevron"></span>
+          Get Started
+        </a>
+      </div>
+    </div>
+    <div class="dac-section dac-small">
+      <div class="resource-widget resource-flow-layout col-16"
+           data-query="collection:work/landing/primary"
+           data-cardSizes="6x2"
+           data-maxResults="6"></div>
+    </div>
+  </div>
+</section>
+
+<div class="wrap dac-offset-parent">
+  <a class="dac-fab dac-scroll-button" data-scroll-button href="#resources">
+    <i class="dac-sprite dac-arrow-down-gray"></i>
+  </a>
+</div>
+
+<section class="dac-section dac-gray dac-small" id="resources">
+  <div class="wrap">
+    <h2 class="norule">Resources</h1>
+
+    <div class="resource-widget resource-flow-layout col-16"
+         data-query="collection:work/landing/resources"
+         data-cardSizes="6x6"
+         data-maxResults="16"></div>
+  </div>
+</section>
diff --git a/docs/html/training/enterprise/app-compatibility.jd b/docs/html/work/managed-profiles.jd
similarity index 94%
rename from docs/html/training/enterprise/app-compatibility.jd
rename to docs/html/work/managed-profiles.jd
index 419ba89..3287f55 100644
--- a/docs/html/training/enterprise/app-compatibility.jd
+++ b/docs/html/work/managed-profiles.jd
@@ -1,26 +1,19 @@
-page.title=Ensuring Compatibility with Managed Profiles
+page.title=Set up Managed Profiles
 page.metaDescription=Learn how to make sure your apps operate smoothly in a corporate environment by following some best practices.
+page.image=images/work/cards/briefcase_600px.png
 
 @jd:body
 
-<div id="tb-wrapper">
-<div id="tb">
-
-<h2>This lesson teaches you to</h2>
-<ol>
- <li><a href="#prevent_failed_intents">Prevent Failed Intents</a></li>
- <li><a href="#sharing_files">Share Files Across Profiles</a></li>
- <li><a href="#testing_apps">Test your App for Compatibility with Managed
-    Profiles</a></li>
-</ol>
-
-<!-- related docs (NOT javadocs) -->
-<h2>Resources</h2>
-<ul>
-  <li><a href="{@docRoot}samples/BasicManagedProfile/index.html">BasicManagedProfile</a></li>
-</ul>
-
-</div>
+<div id="qv-wrapper">
+  <div id="qv">
+    <h2>In this document</h2>
+    <ol>
+      <li><a href="#prevent_failed_intents">Prevent Failed Intents</a></li>
+      <li><a href="#sharing_files">Share Files Across Profiles</a></li>
+      <li><a href="#testing_apps">
+        Test your App for Compatibility with Managed Profiles</a></li>
+    </ol>
+  </div>
 </div>
 
 <p>The Android platform allows devices to have
diff --git a/docs/html/work/overview.jd b/docs/html/work/overview.jd
new file mode 100644
index 0000000..56d8c20
--- /dev/null
+++ b/docs/html/work/overview.jd
@@ -0,0 +1,142 @@
+page.title=Android for Work Developer Overview
+meta.tags="android for work, work, enterprise, corporate"
+page.tags="android for work, work, enterprise, corporate"
+page.metaDescription=Learn how to build Android apps for the enterprise and take advantage of Google's Android for Work program.
+page.image=images/work/cards/briefcase_600px.png
+
+@jd:body
+
+<div id="qv-wrapper">
+  <div id="qv">
+    <h2>In this document</h2>
+    <ul>
+      <li><a href="#developer-guide">Create Apps Using the Developer Guide</a></li>
+      <li><a href="#community-overview">What Does the Android for Work DevHub Offer?</a></li>
+      <li><a href="#develop-apps">Develop Apps for Enterprises</a></li>
+      <li><a href="#manage-devices">Manage Devices and Apps</a></li>
+    </ul>
+  </div>
+</div>
+
+<p>
+  As an Android for Work developer, you can deploy devices and apps to
+  employees and keep your corporate data secure. With Android for
+  Work, organizations can choose what devices, APIs, and framework
+  they want to use to develop apps.
+</p>
+
+<p>
+  With Android for Work, you can:
+  <ul>
+    <li>Build apps to help employees be more productive in scenarios
+    such as bring your own device (BYOD), and corporate-owned,
+    single-use devices (COSU).</li>
+    <li>Connect with leading enterprise mobility management (EMM)
+    <a href="https://www.google.com/work/android/partners/"
+    >partners</a> to help integrate Android in your business.</li>
+  </ul>
+</p>
+
+<p>
+  Additionally, Android for Work offers a partner program for
+  developers through the
+  <a href="https://www.google.com/work/android/developers/applyDevHub/"
+  >Android for Work DevHub</a>, which provides exclusive access to beta
+  features and developer events, along with access to a community of
+  Android developers making enterprise apps.
+</p>
+
+<h2 id="developer-guide">Create Apps Using the Developer Guide</h2>
+
+<p>
+  The <a href="{@docRoot}work/guide.html"
+  >Android for Work Developer Guide</a> is for developers who want to
+  create Android apps that best utilize and complement the features in
+  Android for Work. The guide defines the best practices to develop
+  and test enterprise-focused apps for Android devices running Android
+  for Work.
+</p>
+
+<h3>If you’re new to creating Android apps ...</h3>
+
+<p>
+  The Developer Guide assumes that you’re working as an independent
+  software vendor (ISV) or in a similar role, and have already built
+  an Android app. If you haven’t yet created an Android app, see
+  <a href="{@docRoot}training/basics/firstapp/index.html"
+  >Building Your First App</a>. If you’re looking for an accelerated
+  course, see the <a href="https://www.udacity.com/course/ud853"
+  >Developing Android Apps</a> course taught by Google employees.
+</p>
+
+<h2 id="community-overview">What Does the Android for Work DevHub Offer?</h2>
+
+<p>
+  The <a href="https://www.google.com/work/android/developers/applyDevHub/"
+  >Android for Work DevHub</a> offers these incentives:
+</p>
+
+<h3>Get exclusives</h3>
+
+<p>
+  Access to beta features and Android for Work developer training and
+  events, including invite-only hackathons.
+</p>
+
+<h3>Learn from experts</h3>
+
+<p>
+  Special content from Android for Work experts, including how to
+  optimize your app for the Play for Work store so that businesses can
+  see your app.
+</p>
+
+<h3>Talk to others</h3>
+
+<p>
+  Access to a moderated space dedicated to enterprise developers. Talk
+  with peers about issues specific to developing Android apps for
+  businesses.
+</p>
+
+<h3>How do I join?</h3>
+
+<p>
+  Apply to join the
+  <a href="https://www.google.com/work/android/developers/applyDevHub/"
+  >Android for Work DevHub</a>.
+</p>
+
+<h2 id="develop-apps">Develop Apps for Enterprises</h2>
+
+<p>
+  Learn how to make your app function smoothly in corporate
+  environments that restrict device features and data access. Go
+  further to support business use of your app by enabling restrictions
+  that administrators can use to remotely configure your app:
+</p>
+
+<div class="dynamic-grid">
+  <div class="resource-widget resource-flow-layout landing col-12"
+       data-query="collection:work/apps"
+       data-cardSizes="6x6"
+       data-maxResults="6">
+  </div>
+</div>
+
+
+<h2 id="manage-devices">Manage Devices and Apps</h2>
+
+<p>
+  Learn how to build policy controller apps that enable enterprise
+  administrators to manage devices, manage corporate apps, and provide
+  access to company resources:
+</p>
+
+<div class="dynamic-grid">
+  <div class="resource-widget resource-flow-layout landing col-12"
+       data-query="collection:work/admin"
+       data-cardSizes="6x6"
+       data-maxResults="4">
+  </div>
+</div>
diff --git a/docs/html/work/work_toc.cs b/docs/html/work/work_toc.cs
new file mode 100644
index 0000000..10658c2
--- /dev/null
+++ b/docs/html/work/work_toc.cs
@@ -0,0 +1,44 @@
+<ul id="nav">
+
+  <li class="nav-section">
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>work/index.html">
+        Android for Work Home</a>
+    </div>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>work/overview.html">
+        Overview</a>
+    </div>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>work/guide.html">
+        Developer Guide</a>
+    </div>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>work/managed-profiles.html">
+        Set up Managed Profiles</a></div>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>work/app-restrictions.html">
+        Set up App Restrictions</a>
+    </div>
+  </li>
+
+  <li class="nav-section">
+    <div class="nav-section-header empty">
+      <a href="<?cs var:toroot ?>work/cosu.html">
+        Set up Single-Purpose Devices</a>
+    </div>
+  </li>
+
+</ul>
diff --git a/docs/image_sources/topic/instant-apps/Play-Services.png b/docs/image_sources/topic/instant-apps/Play-Services.png
new file mode 100644
index 0000000..4b65c991
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/Play-Services.png
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/image03.png b/docs/image_sources/topic/instant-apps/image03.png
new file mode 100644
index 0000000..becc7ff
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/image03.png
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/instant-apps-section-2 b/docs/image_sources/topic/instant-apps/instant-apps-section-2
new file mode 100644
index 0000000..6857e1f
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/instant-apps-section-2
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/instant-apps-section-4 b/docs/image_sources/topic/instant-apps/instant-apps-section-4
new file mode 100644
index 0000000..c9436f1
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/instant-apps-section-4
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/instant-apps-section-5 b/docs/image_sources/topic/instant-apps/instant-apps-section-5
new file mode 100644
index 0000000..b33544c
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/instant-apps-section-5
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/play-services-features-2x.png b/docs/image_sources/topic/instant-apps/play-services-features-2x.png
new file mode 100644
index 0000000..098f91c
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/play-services-features-2x.png
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/s3-BandH-animated.gif b/docs/image_sources/topic/instant-apps/s3-BandH-animated.gif
new file mode 100644
index 0000000..4e44f74
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/s3-BandH-animated.gif
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/s3-BandH-static.png b/docs/image_sources/topic/instant-apps/s3-BandH-static.png
new file mode 100644
index 0000000..004afb7
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/s3-BandH-static.png
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/s3-BuzzFeed-animated.gif b/docs/image_sources/topic/instant-apps/s3-BuzzFeed-animated.gif
new file mode 100644
index 0000000..7ed534e
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/s3-BuzzFeed-animated.gif
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/s3-BuzzFeed-static.png b/docs/image_sources/topic/instant-apps/s3-BuzzFeed-static.png
new file mode 100644
index 0000000..cdd0dc8
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/s3-BuzzFeed-static.png
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/s3-ParkandPay-animated.gif b/docs/image_sources/topic/instant-apps/s3-ParkandPay-animated.gif
new file mode 100644
index 0000000..4a14dc2
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/s3-ParkandPay-animated.gif
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/s3-ParkandPay-static.png b/docs/image_sources/topic/instant-apps/s3-ParkandPay-static.png
new file mode 100644
index 0000000..fa9c2bf
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/s3-ParkandPay-static.png
Binary files differ
diff --git a/docs/image_sources/topic/instant-apps/upgrade-your-app-2x.png b/docs/image_sources/topic/instant-apps/upgrade-your-app-2x.png
new file mode 100644
index 0000000..fbf6a01
--- /dev/null
+++ b/docs/image_sources/topic/instant-apps/upgrade-your-app-2x.png
Binary files differ
diff --git "a/docs/image_sources/topic/instant-apps/works-on-all-2x \0501\051.png" "b/docs/image_sources/topic/instant-apps/works-on-all-2x \0501\051.png"
new file mode 100644
index 0000000..5a44032
--- /dev/null
+++ "b/docs/image_sources/topic/instant-apps/works-on-all-2x \0501\051.png"
Binary files differ
diff --git a/media/java/android/service/media/MediaBrowserService.java b/media/java/android/service/media/MediaBrowserService.java
index 1bb99ff..cfb3ee1 100644
--- a/media/java/android/service/media/MediaBrowserService.java
+++ b/media/java/android/service/media/MediaBrowserService.java
@@ -549,7 +549,7 @@
         }
 
         /**
-         * Gets any extras about the brwoser service.
+         * Gets any extras about the browser service.
          */
         public Bundle getExtras() {
             return mExtras;
