diff --git a/docs/html/sdk/1.5_r1/index.jd b/docs/html/sdk/1.5_r1/index.jd
index 345489a..412887a 100644
--- a/docs/html/sdk/1.5_r1/index.jd
+++ b/docs/html/sdk/1.5_r1/index.jd
@@ -1,21 +1,20 @@
-page.title=Android 1.5 SDK, Release 1
-
-sdk.version=1.5_r1
+sdk.version=1.5
+sdk.rel.id=1
 sdk.date=April 2009
 
-sdk.win_download=android-sdk-windows-1.5_r1.zip
+sdk.win_download=
 sdk.win_bytes=
 sdk.win_checksum=
 
-sdk.mac_download=android-sdk-mac_x86-1.5_r1.zip
+sdk.mac_download=
 sdk.mac_bytes=
 sdk.mac_checksum=
 
-sdk.linux_download=android-sdk-linux_x86-1.5_r1.zip
+sdk.linux_download=
 sdk.linux_bytes=
 sdk.linux_checksum=
 
-
+page.title=Download Android SDK
 @jd:body
 
 <h2>SDK Contents</h2>
@@ -25,7 +24,7 @@
 <p>The SDK includes a variety of tools for developing and debugging application code and designing an application UI. You can read about the tools in the  
 <a href="{@docRoot}guide/developing/tools/index.html">Dev Guide</a> and access them in the <code>&lt;sdk&gt;/tools/</code> directory. 
 
-<p>The tools package included in this SDK is the same as that included in the Android 1.0, Release 2 SDK. </p>
+<p>The tools package included in this SDK includes many updates from that provided in the previous SDK and requires you to migrate your applications to the new development environment. For details, see the <a href="upgrading">Upgrading the SDK</a> document.</p>
 
 <h4 id="system_images">System Images</h4>
 
@@ -40,17 +39,23 @@
 <td width="5%"><nobr>Android 1.5</nobr></td>
 <td  width="5%">3</td>
 <td  width="5%"><nobr><a href="{@docRoot}sdk/android-1.5.html">Version Notes</a></nobr></td>
-<td>Includes com.google.android.maps external library and a set of standard development applications. </td>
+<td>Includes a set of standard development applications. </td>
+</tr>
+<tr>
+<td width="5%"><nobr>Android 1.1</nobr></td>
+<td  width="5%">2</td>
+<td  width="5%"><nobr><a href="{@docRoot}sdk/android-1.1.html">Version Notes</a></nobr></td>
+<td>Includes a set of standard development applications. </td>
 
 </tr>
-
 </table>
 
 <h4>Sample Code and Applications</h4>
 
 <p>You can look at a variety of tutorials and samples in the <a href="{@docRoot}guide/samples/index.html">Dev Guide</a> and access the sample code itself
-in the <code>&lt;sdk&gt;/samples/</code> directory of the SDK package.</p>
+in the <code>&lt;sdk&gt;/platforms/android-1.5/samples/</code> directory of the SDK package. Note the new location &mdash; the SDK now includes multiple platform versions that you can develop against and each has its own sample code directory. </p>
 
+<!-- 
 <h4>Documentation</h4>
 
 <p>The SDK package includes a full set of local documentation. To view it, open the <code>&lt;sdk&gt;/documentation.html</code> file in a web browser. If you are developing in an IDE such as Eclipse, you can also view the reference documentation directly in the IDE. </p>
@@ -58,5 +63,5 @@
 <p>The most current documentation is always available on the Android Developers site:</p>
 
 <p style="margin-left:2em;"><a href="http://developer.android.com/index.html">http://developer.android.com/</a></p>
-
+-->
 
diff --git a/docs/html/sdk/1.5_r1/installing.jd b/docs/html/sdk/1.5_r1/installing.jd
index df9ec3a..a1f7cff 100644
--- a/docs/html/sdk/1.5_r1/installing.jd
+++ b/docs/html/sdk/1.5_r1/installing.jd
@@ -1,312 +1,10 @@
-page.title=Installing the Android SDK
-sdk.version=1.5_r1
+sdk.version=1.5
+sdk.rel.id=1
+sdk.date=April 2009
 
+page.title=Installing the Android SDK
 @jd:body
 
-
-<p>This page describes how to install the Android SDK and set up your
-development environment. If you haven't downloaded the SDK, you can
-do so from the 
-<a href="{@docRoot}sdk/1.5_r1/index.html">Download</a> page.</p>
-
-<p>If you encounter any problems during installation, see the 
-<a href="#installnotes">Installation Notes</a> at the bottom of
-this page.</p>
-
-<h4 style="margin-top">Upgrading?</h4>
-<p>If you have already developed applications using an earlier version
-of the SDK, please skip this page and read the 
-<a href="{@docRoot}sdk/1.5_r1/upgrading.html"><strong>Upgrading the
-SDK</strong></a></b> document instead.
-</p>
-
-
-<h2 id="setup">Preparing for Installation</h2>
-
-<p>Before you get started with the Android SDK, take a moment to confirm
-that your development machine meets the <a
-href="{@docRoot}sdk/1.5_r1/requirements.html">system requirements</a>.
-</p>
-
-<p>If you will be developing on Eclipse with the Android Development
-Tools (ADT) Plugin &mdash; the recommended path if you are new to
-Android &mdash; make sure that you have a suitable version of Eclipse
-installed on your computer. If you need to install Eclipse, you can
-download it from this location: </p>
-
-<p style="margin-left:2em;"><a href=
-"http://www.eclipse.org/downloads/">http://www.eclipse.org/downloads/</a
-></p>
-
-<p>A Java or RCP version of Eclipse is recommended. </p>
-
-<h2 id="installingsdk">Installing the SDK</h2>
-
-	<p>After downloading the SDK, unpack the .zip archive to a suitable location on your machine. By default, the SDK files are unpacked into a directory named  <code>android_sdk_<em>&lt;platform</em>&gt;_<em>&lt;release&gt;</em>_<em>&lt;build&gt;</em></code>. The directory contains a link to a local copy of the documentation and the subdirectories <code>tools/</code>, <code>samples/</code>, and others. </p>
-	
-	<p>Make a note of the name and location of the unpacked SDK directory on your system &mdash; you will need to refer to the SDK directory later, when setting up the Android plugin or using SDK tools. </p>
-
-        <p>Optionally, you can add the path to the SDK <code>tools</code> directory to your path. As mentioned above, the <code>tools/</code> directory is located in the SDK directory. </p>
-     <ul>
-          <li>On Linux, edit your ~/.bash_profile or ~/.bashrc file. Look
-          for a line that sets the PATH environment variable and add the
-          full path to the <code>tools/</code> directory to it. If you don't 
-          see a line setting the path, you can add one:</li>
-
-          <ul><code>export PATH=${PATH}:<em>&lt;your_sdk_dir&gt;</em>/tools</code></ul>
-
-          <li>On a Mac, look in your home directory for .bash_profile and
-          proceed as for Linux. You can create the .bash_profile, if 
-          you haven't already set one up on your machine. </li>
-
-          <li>On Windows, right click on My Computer, and select Properties.  
-        Under the Advanced tab, hit the Environment Variables button, and in the
-        dialog that comes up, double-click on Path under System Variables. Add  the full path to the <code>tools/</code> directory to the path. </li>
-        </ul>
-
-        <p>Adding <code>tools</code> to your path lets you run Android Debug Bridge (adb) and the other command line <a href="{@docRoot}guide/developing/tools/index.html">tools</a> without needing to supply the full path to the tools directory. Note that, if you update your SDK, you should remember to update your PATH settings to point to the new location, if different.</p>
-
-
-<p>If you will be using the Eclipse IDE as your environment for developing Android applications, continue reading the next
-section in order to install the Android Development Tools plugin and set up Eclipse. If you choose not to use Eclipse, you can 
-develop Android applications using other tools &mdash; read the guide to developing 
-<a href="{@docRoot}guide/developing/other-ide.html">in other IDEs</a>.</p>
-
-
-<h2 id="installingplugin">Installing the ADT Plugin for Eclipse</h2>
-
-<p>Android offers a custom plugin for the Eclipse IDE, called Android
-Development Tools (ADT), that is designed to give you a powerful,
-integrated environment in which to build Android applications. It
-extends the capabilites of Eclipse to let you quickly set up new Android
-projects, create an application UI, add components based on the Android
-Framework API, and debug using the Android SDK tools.</p>
-
-<p>If you are new to Android or want to develop using the Eclipse IDE,
-the ADT plugin will be an essential part of your development
-environment. In general, using Eclipse with ADT is a highly recommended
-approach and is the fastest way to get started. This section describes
-how to install ADT into your Eclipse environment. 
-
-<p>If you prefer to work in a development environment other than Eclipse,
-you do not need to install Eclipse or the ADT Plugin. Instead, you can 
-access the SDK tools directly to build and debug your application. </p>
-
-<p>Once you have Eclipse installed, as described in <a href="#setup">
-Preparing for Installation</a>, follow the steps below to
-download the ADT plugin and install it in your respective Eclipse
-environment. </p>
-
-<table style="font-size:100%">
-<tr><th>Eclipse 3.3 (Europa)</th><th>Eclipse 3.4 (Ganymede)</th></tr>
-<tr>
-<td width="45%">
-<ol>
-    <li>Start Eclipse, then select <strong>Help</strong> &gt; <strong>Software Updates</strong> &gt; <strong>Find
-            and Install...</strong>. </li>
-
-    <li>In the dialog that appears, select <strong>Search for new features to install</strong> and click <strong>Next</strong>. </li>
-    <li>Click <strong>New Remote Site</strong>. </li>
-    <li>In the resulting dialog box, enter a name for the remote site (e.g. Android Plugin) and enter this as its URL:
-        <pre>https://dl-ssl.google.com/android/eclipse/</pre>
-        <p>Alternatively, you can use http in the Location URL, if you are having 
-         trouble with https (https is preferred for security reasons).</p>
-        <pre>http://dl-ssl.google.com/android/eclipse/</pre>
-        <p>Click <strong>OK</strong>.</p> </li>
-    <li>You should now see the new site added to the search list (and checked).
-        Click <strong>Finish</strong>. </li>
-    <li>In the subsequent Search Results dialog box, select the checkbox for
-    <strong>Android Plugin</strong> &gt; <strong>Developer Tools</strong>.
-    This will check both features:  "Android Developer Tools", and "Android
-    Editors". The Android Editors feature is optional, but recommended.  If
-    you choose to install it, you need the WST plugin mentioned earlier in this
-    page. Click <strong>Next</strong>. </li>
-    <li>Read the license agreement and then select <strong>Accept terms of the license agreement</strong>. 
-     Click <strong>Next</strong>. </li>
-    <li>Click <strong>Finish</strong>. </li>
-
-    <li>The ADT plugin is not signed; you can accept the installation anyway
-        by clicking <strong>Install All</strong>. </li>
-    <li>Restart Eclipse. </li>
-</ol>
-
-</td>
-<td>
-
-<ol>
-    <li>Start Eclipse, then select <strong>Help</strong> &gt; <strong>Software Updates...</strong>.
-    </li>
-    <li>In the dialog that appears, click the <strong>Available Software</strong> tab.
-    </li>
-    <li>Click <strong>Add Site...</strong>
-    </li>
-    <li>Enter this as the Location:
-      <pre>https://dl-ssl.google.com/android/eclipse/</pre>
-      <p>Alternatively, you can use http in the Location URL, if you are having 
-         trouble with https (https is preferred for security reasons).</p>
-      <pre>http://dl-ssl.google.com/android/eclipse/</pre>
-      <p>Click <strong>OK</strong>.</p></li>
-    <li>Back in the Available Software view, you should see the plugin. Select the checkbox next to 
-      <em>Developer Tools</em>  and click <strong>Install...</strong>
-    </li>
-    <li>On the subsequent Install window, "Android Developer Tools", and "Android Editors" should both be checked. 
-    The Android Editors feature is optional, but recommended.  If
-    you choose to install it, you need the WST plugin mentioned earlier in this
-    page. Click <strong>Next</strong>.
-     </li>
-    <li>Accept the license agreement and click <strong>Finish</strong>.</li>
-    <li>Restart Eclipse. </li>
-</ol>
-
-</td>
-</tr>
-</table>
-
-<p>Now, you just need to modify your Eclipse preferences to point to the Android SDK directory:</p>
-<ol>
-    <li>Select <strong>Window</strong> &gt; <strong>Preferences...</strong> to open the Preferences
-        panel. (Mac OS X: <strong>Eclipse</strong> &gt; <strong>Preferences</strong>) </li>
-    <li>Select <strong>Android</strong> from the left panel. </li>
-    <li>For the SDK Location in the main panel, click <strong>Browse...</strong> and locate the SDK directory. </li>
-    <li>Click <strong>Apply</strong>, then <strong>OK</strong>.</li>
-</ol>
-
-<p>Done! If you haven't encountered any problems, then you're ready to
-begin developing Android applications. See the <a href="#next">After 
-Installation: Next Steps</a> section for suggestions on how to start. </p>
-
-
-<h3 id="troubleshooting">Troubleshooting ADT Installation</h3>
-<p> 
-If you are having trouble downloading the ADT plugin after following the steps above, here are some suggestions: </p>
-
-<ul>
-	<li>If Eclipse can not find the remote update site containing the ADT plugin, try changing the remote site URL to use http, rather than https. That is, set the Location for the remote site to:
-        <pre>http://dl-ssl.google.com/android/eclipse/</pre></li>
-	<li>If you are behind a firewall (such as a corporate firewall), make
-        sure that you have properly configured your proxy settings in Eclipse.
-        In Eclipse 3.3/3.4, you can configure proxy information from the main
-        Eclipse menu in <strong>Window</strong> (on Mac, <strong>Eclipse</strong>) &gt; <strong>Preferences</strong> &gt; <strong>General</strong> &gt; <strong>Network Connections</strong>.</li>
-</ul>
-<p> 
-If you are still unable to use Eclipse to download the ADT plugin as a remote update site, you can download the ADT files to your local machine using a browser and the install the files in Eclipse from there:
-</p>
-<ol>
-<li><a href="{@docRoot}sdk/adt_download.html">Download the ADT zip file</a> (do not unpack it).
-<li>Follow steps 1 and 2 in the default install instructions (above).
-<li>In Eclipse 3.3, click <strong>New Archive Site...</strong>. <br/>
-    In Eclipse 3.4, click <strong>Add Site...</strong>, then <strong>Archive...</strong>
-<li>Browse and select the downloaded the zip file.
-<li>Follow the remaining procedures, above, starting from steps 5.
-</ol>
-<p> 
-Note that to update your plugin, you will have to follow these steps again instead of the default update instructions.</p>
-
-<p>Note that the "Android Editors" feature of ADT requires several optional 
-Eclipse components (for example, WST). If you encounter an error when 
-installing ADT, your Eclipse installion might not include those components. 
-For information about how to quickly add the necessary components to your 
-Eclipse installation, see the troubleshooting topic 
-<a href="{@docRoot}guide/appendix/faq/troubleshooting.html#installeclipsecomponents">ADT Installation Error: "requires plug-in org.eclipse.wst.sse.ui"</a>.</p>
-
-<h4>For Linux users</h4>
-<p>If you encounter this error when installing the ADT Plugin for Eclipse: 
-<pre>
-An error occurred during provisioning.
-Cannot connect to keystore.
-JKS</pre>
-<p>
-...then your development machine lacks a suitable Java VM. Installing Sun
-Java 6 will resolve this issue and you can then reinstall the ADT
-Plugin.</p>
-
-
-<h2 id="next">After Installation: Next Steps</h2>
-<p>Once you have installed the SDK and the ADT Plugin, you are ready to
-begin developing applications. Here are a few ways you can get started: </p>
-
-<p><strong>Learn about Android</strong></p>
-<ul>
-<li>Take a look at the <a href="{@docRoot}guide/index.html">Dev
-Guide</a> and the types of information it provides</li>
-<li>Read an introduction to Android as a platform in <a
-href="{@docRoot}guide/basics/what-is-android.html">What is
-Android?</a></li>
-<li>Learn about the Android framework and how applications run on it in
-<a href="{@docRoot}guide/topics/fundamentals.html">Application
-Fundamentals</a></li>
-<li>Take a look at the Android framework API specification in the <a
-href="{@docRoot}reference/index.html">Reference</a> tab</li>
-</ul>
-
-<p><strong>Explore the SDK</strong></p>
-<ul>
-<li>Get an overview of the <a
-href="{@docRoot}guide/development/tools/index.html">development
-tools</a> that are available to you</li>
-<li>Read the overviews of how to develop <a
-href="{@docRoot}guide/developing/eclipse-adt.html">in Eclipse/ADT</a> or
-<a href="{@docRoot}guide/developing/other-ide.html">in other IDEs</a>
-</li>
-</ul>
-
-<p><strong>Explore some code</strong></p>
-<ul>
-<li>Set up a <a href="{@docRoot}guide/tutorials/hello-world.html">Hello
-World application</a></li>
-<li>Follow the <a href="{@docRoot}guide/tutorials/notepad/index.html">
-Notepad Tutorial</a> to build a full Android application </li>
-<li>Create a new project for one of the other sample applications
-included in <code>&lt;sdk&gt;/samples</code>, then compile and run it in
-your development environment</li>
-</ul>
-
-<p><strong>Visit the Android developer groups</strong></p>
-<ul>
-<li>Take a look at the <a
-href="{@docRoot}community/index.html">Community</a> tab to see a list of
-Android developers groups. In particular, you might want to look at the
-<a href="http://groups.google.com/group/android-developers">Android
-Developers</a> group to get a sense for what the Android developer
-community is like.</li>
-</ul>
-
-
-<h2 id="installnotes">Installation Notes</h2>
-<h4>Ubuntu Linux Notes</h4>
-<ul>
-    <li>If you need help installing and configuring Java on your
-development machine, you might find these resources helpful: 
-        <ul>
-           <li><a href="https://help.ubuntu.com/community/Java">https://help.ubuntu.com/community/Java </a></li>
-           <li><a href="https://help.ubuntu.com/community/Java">https://help.ubuntu.com/community/JavaInstallation </a></li>
-       </ul>
-   </li>
-<li>Here are the steps to install Java and Eclipse, prior to installing
-the Android SDK and ADT Plugin.
-<ol>
-    <li>If you are running a 64-bit distribution on your development
-machine, you need to install the <code>ia32-libs</code> package using
-<code>apt-get:</code>:
-        <pre>apt-get install ia32-libs</pre></li>
-    <li>Next, install Java:
-        <pre>apt-get install sun-java6-bin</pre></li>
-    <li>The Ubuntu package manager does not currently offer an Eclipse 3.3
-    version for download, so we recommend that you download Eclipse from
-eclipse.org (<a
-href="http://www.eclipse.org/downloads/">http://www.eclipse.org/
-downloads/</a>). A Java or RCP version of Eclipse is recommended.</li>
-<li>Follow the steps given in previous sections to install the SDK 
-and the ADT plugin. </li>
-</ol>
-</ul>
-<h4>Other Linux Notes</h4>
-<ul>
-    <li>If JDK is already installed on your development computer, please
-take a moment to make sure that it meets the version requirements listed
-in the <a href="{@docRoot}sdk/1.5_r1/requirements.html">System Requirements</a>.
-In particular, note that some Linux distributions may include JDK 1.4 or Gnu
-Compiler for Java, both of which are not supported for Android development.</li>
-</ul>
+<p>See the <a href="{@docRoot}sdk/preview/index.html">Download page</a> for more information.</p>
 
 
diff --git a/docs/html/sdk/1.5_r1/requirements.jd b/docs/html/sdk/1.5_r1/requirements.jd
index 3f0deca..c3ee8f7 100644
--- a/docs/html/sdk/1.5_r1/requirements.jd
+++ b/docs/html/sdk/1.5_r1/requirements.jd
@@ -1,11 +1,7 @@
 page.title=System Requirements
-
-sdk.version=1.5_r1
-sdk.date=April 2009
-
 @jd:body
 
-<p>The sections below describe the system and software requirements for developing Android applications using the Android SDK tools included in Android 1.5 SDK, Release 1. </p>
+<p>The sections below describe the system and software requirements for developing Android applications using the Android SDK tools included in Android <?cs var:sdk.version ?> SDK, Release <?cs var:sdk.rel.id ?>. </p>
 
 <h3>Supported Operating Systems</h3>
 <ul>
diff --git a/docs/html/sdk/1.5_r1/upgrading.jd b/docs/html/sdk/1.5_r1/upgrading.jd
index 63b7a3c..5323131 100644
--- a/docs/html/sdk/1.5_r1/upgrading.jd
+++ b/docs/html/sdk/1.5_r1/upgrading.jd
@@ -30,17 +30,42 @@
 </div>
 -->
 
-<p>This document describes how to move your development environment and existing
-Android applications from an Android 1.0 SDK to the Android 1.5, Release 1 SDK.
+
+    <div id="qv-wrapper">
+    <div id="qv">
+
+<h2>Upgrading quickview</h2>
+<ul>
+<li>The Android 1.5 SDK uses a new project structure and a new ADT plugin (ADT 0.9). </li>
+<li>To move existing projects into the SDK, you must make some minor changes in your development environment.</li>
+<li>The new ADT plugin (ADT 0.9) <em>is not compatible</em> with projects created in previous SDKs.</li>
+<li>You need to uninstall your existing ADT plugin, before installing ADT 0.9.</li>
+
+</ul>
+
+<!--<h2>Related Information</h2>
+<ol>
+<li><a href="{@docRoot}sdk/api_diff/3/changes.html">Android 1.5 API Differences</a></li>
+</ol>
+-->
+</div>
+</div>
+
+<p>See the <a href="{@docRoot}sdk/preview/index.html">Download page</a> for more information.</p>
+
+<!-- <p>This document describes how to move your development environment and existing
+Android applications from an Android 1.1 or 1.0 SDK to the Android 1.5 SDK.
 If you are migrating applications from an earlier SDK, please read the upgrading
 document available in the Android 1.0 SDK package.
 </p>
 
-<p>To ensure that your applications are compliant with the Android 1.5 system available 
+<p>To ensure that your existing applications run properly with the Android 1.5 system available 
 on mobile devices, you need to install the Android 1.5 SDK and port your existing Android 
 applications to it. The sections below will guide you through the process.</p>
 
-<h2 id="install-new">Installing the Latest SDK</h2>
+</ul>
+
+<h2 id="install-new">Installing the SDK</h2>
 
 <p><a href="{@docRoot}sdk/1.5_r1/index.html">Download the SDK</a> and unpack it into a safe location.</p>
 
@@ -133,9 +158,9 @@
 <p>One way to start is to open your project in Eclipse and see where the ADT
 identifies errors in your application. You can also look up
 specific changes in the Android APIs in the 
-<!-- <a href="{@docRoot}sdk/android-1.5.html#api-changes"> -->
+android-1.5.html#api-changes 
 Android 1.5 Version Notes
-<!-- </a> -->
+
 document.</p>
 
 <p>If you have additional trouble updating your code, visit the 
@@ -148,4 +173,4 @@
 error when running or installing ApiDemos, see the troubleshooting topic 
 <a href="{@docRoot}guide/appendix/faq/troubleshooting.html#apidemosreinstall">I can't install ApiDemos 
 apps in my IDE because of a signing error</a> for information about how to solve the problem.</p>
-
+-->
\ No newline at end of file
diff --git a/docs/html/sdk/android-1.5.jd b/docs/html/sdk/android-1.5.jd
index 55fc4ba..fff911e 100644
--- a/docs/html/sdk/android-1.5.jd
+++ b/docs/html/sdk/android-1.5.jd
@@ -8,238 +8,7 @@
 <em>API Level:</em>&nbsp;<strong>3</strong></p>
 
 
-<p>This document provides version notes for the Android 1.5 system image included in the SDK. </p>
-
-<ul>
-<li><a href="#overview">Overview</a>
-<li><a href="#overview">External Libraries</a>
-<li><a href="#comp">Device Compatibility</a>
-<li><a href="#apps">Built-in Applications</a>
-<li><a href="#locs">UI Localizations</a>
-<li><a href="#resolved-issues">Resolved Issues</a>
-<li><a href="#features">New Features</a>
-<li><a href="#api-changes">API Changes</a>
-</ul>
-
-<h2 id="overview">Overview</h2>
-
-<p>The Android 1.5 system image delivered in the SDK is the development
-counterpart to the Android 1.5 production system image, deployable to
-Android-powered handsets starting in February 2009. </p>
-
-<p>The Android 1.5 system image delivers an updated version of the framework
-API. As with previous versions, the Android 1.5 API 
-is assigned an integer identifier &mdash; <strong>3</strong> &mdash; that is
-stored in the system itself. This identifier, called the "API Level", allows the
-system to correctly determine whether an application is compatible with
-the system, prior to installing the application.</p>
-
-<p>Applications can reference a specific API Level value in their
-manifest files, to indicate the minimum version of the Android system
-required to run the application. To reference a minimum API Level, applications 
-can add a <code>minSdkVersion</code> attribute in their manifest files.
-The value of the attribute is an integer corresponding to an API Level 
-identifier. Prior to installing an application, the system then checks the value of 
-<code>minSdkVersion</code> and allows the install only
-if the referenced integer is less than or equal to the API Level integer stored
-in the system itself. </p>
-
-<p>If you use the Android 1.5 system image to build an application
-compatible with Android-powered devices running the Android 1.5
-platform, please note that you <strong><span
-style="color:red;">must</span></strong> set the the
-<code>android:minSdkVersion</code> attribute in the application's
-manifest to "3", which is the API strictly associated with Android 1.5.
-</p>
-
-<p>Specifically, you define the <code>android:minSdkVersion</code>
-attribute in a <code>&lt;uses-sdk&gt;</code> element as a child of
-<code>&lt;manifest&gt;</code> in the manifest file. When set, the
-attribute looks like this: </p>
-
-<pre>&lt;manifest&gt;
-  ...
-  &lt;uses-sdk minSdkVersion="3" /&gt;
-  ...
-&lt;/manifest&gt;</pre>
-
-<p>By setting <code>android:minSdkVersion</code> in this way, you ensure
-that users will only be able to install your application if their
-devices are running the Android 1.5 platform. In turn, this ensures that
-your application will function properly on their devices, especially if
-it uses <a href="#apichange">APIs introduced in Android 1.5</a>. </p>
-
-<p>If your application uses APIs introduced in Android 1.5 but does not
-declare <code>&lt;uses-sdk minSdkVersion="3" /&gt;</code>, then it will
-run properly on Android 1.5 devices but <em>not</em> on Android 1.0
-devices. In the latter case, the application will crash at runtime when
-it tries to use the Android 1.5 APIs.</p>
-
-<p>If your application does not use any new APIs introduced in Android
-1.5, you can indicate general Android 1.0 compatibility by removing
-<code>minSdkVersion</code> or setting the attribute to "1". However,
-before publishing your application, you must make sure to compile your
-application against the Android 1.0 system image (available in the
-Android SDK), to ensure that it builds and functions properly for
-Android 1.0 devices. You should test the application against system
-images corresponding to the API Levels that the application is designed
-to be compatible with.</p>
-
-<p>If you are sure your application is not using Android 1.5 APIs and
-has no need to use them, you might find it easier to keep working in the
-Android 1.1 SDK, rather than migrating to the Android 1.5 SDK and having
-to do additional testing. </p>
-
-
-<h2 id="extlibs">External Libraries</h2>
-
-<p>The system image includes these external libraries, which you can
-access from your application by adding a <a
-href="{@docRoot}guide/topics/manifest/uses-library-element.html">
-&lt;uses-library&gt;</a>.</p>
-	<ul>
-	<li>com.google.android.maps &mdash; gives your
-application access to Google Maps data. Note that, to use Google Maps
-data, a Maps API Key is required.</li>
-	</ul>
-
-<h2 id="comp">Device Compatibility</h2>
-
-<p>The Android 1.5 system image was tested for compatability with the
-Android-powered devices listed below:</p>
-	<ul>
-	<li><a href="http://www.t-mobileg1.com">T-Mobile G1</a></li>
-	</ul>
-
-<h2 id="apps">Built-in Applications</h2>
-
-<p>The system image includes these built-in applications:</p>
-	<ul>
-	<li>Alarm Clock</li>
-	<li>API Demos</li>
-	<li>Browser</li>
-	<li>Calculator</li>
-	<li>Camera</li>
-	<li>Contacts</li>
-	<li>Dev Tools</li>
-	<li>Dialer</li>
-	<li>Email</li>
-	<li>Maps (and StreetView)</li>
-	<li>Messaging</li>
-	<li>Music</li>
-	<li>Pictures</li>
-	<li>Settings</li>
-	</ul>
-
-<h2 id="locs">UI Localizations</h2>
-
-<p>The system image provides localized UI strings for the languages
-listed below.</p>
-	<ul>
-	<li>English, US (en_US)</li>
-	<li>German (de) </li>
-	</ul>
-
-<p>Localized UI strings match the locales that are displayable in 
-the emulator, accessible through the device Settings application.</p>
-
-<h2 id="resolved-issues">Resolved Issues</h2>
-<ul>
-<li>AlarmClock alert now plays audio/vibe directly, rather than through
-AlarmManager. AlarmClock alert starts playing audio/vibe in its
-IntentReceiver, rather than on activity start. These changes should
-prevent alarms from being blocked by modal dialogs.</li>
-<li>Fixes to device sleep. </li>
-<li>Single tap no longer opens the in-call dialpad; users now need to
-touch and drag it. </li>
-<li>Fixes a bug causing approximately 1 in 25 outbound messages to
-freeze up the IMAP connection (to a Gmail based server) when transferred
-to the Sent folder.</li>
-<li>Removes automatic account setup entries that were broken or not
-testable. Adds minor fixes to a few of the remaining entries. Makes
-improvements to warning dialogs used for a few special cases.	</li>
-<li>Changes default mail checking interval to every 15 minutes (instead
-of defaulting to "never").</li>
-<li>Fixes password-quoting bugs in IMAP, so that users can include
-special characters in passwords (e.g. spaces).</li>
-<li>Fixes various errors in auto and manual account setup	</li>
-<li>Improves reporting for various connection errors, making it easier
-for the user to diagnose failed account setups.</li>
-<li>Fixes new-mail notifications for POP3 accounts.</li>
-<li>Ensures proper auto-checking of accounts marked as "never
-check".</li>
-<li>Now displays date and time using user preference (e.g. 24 hr vs.
-AM/PM).</li>
-<li>Now shows cc: in message view.</li>
-<li>Improves recovery from POP3 connection failures.</li>
-<li>POP3 parser rules loosened, so the application can work with
-non-compliant email servers.</li>
-</ul>
-
-<h2 id="features">New Features</h2>
-
-<ul>
-<li>Maps: Adds details and reviews when a user does a search on Maps and
-clicks on a business to view its details.</li>
-<li>Dialer: In-call screen timeout default is now longer when using the
-speakerphone.</li>
-<li>Dialer: Adds a "Show dialpad" / "Hide dialpad" item to the in-call
-menu, to make it easier to discover the DTMF dialpad. </li>
-<li>Adds support for saving attachments from MMS</li>
-<li>Adds support for marquee in layouts.</li>
-</ul>
-
-<h2 id="api-changes">API Changes</h2>
-
-<h3>Overview</strong></h3>
-
-<ul>
-<li>Adds annotations for test systems, no actual (non-test) API
-changes.</li>
-<li>Adds a method to allow a process to easily determine its UID.
-<li>Adds support for marquee in layouts.</li>
-<li>Adds new methods for determining padding in views. Useful if you are
-writing your own
-subclasses of {@link android.view.View View}.</li>
-<li>Adds new permissions that allow an application to broadcast an SMS
-or WAP Push message. </li>
-<li>API cleanup: removes protected constructor from
-SDK-bound system images. </li>
-</ul>
-
-<h3>API Change Details</h3>
-
-<table>
-<tr>
-<th>Module or Feature</th><th>Change Description</th>
-</tr>
-<tr><td rowspan="4">Annotations for test systems</td></tr>
-    <tr><td>Added {@link android.test.suitebuilder.annotation.LargeTest LargeTest} annotation.</td></tr>
-    <tr><td>Added {@link android.test.suitebuilder.annotation.MediumTest MediumTest} annotation.</td></tr>
-    <tr><td>Added {@link android.test.suitebuilder.annotation.SmallTest SmallTest} annotation.</td></tr>
-
-<tr><td rowspan="2">Allow a process to easily know its UID.</td></tr>
-    <tr><td>Added public method {@link android.os.Process#myUid} to class {@link android.os.Process android.os.Process}</td></tr>
-
-<tr><td rowspan="6">Padding in views</td></tr>
-    <tr><td>Added public method {@link android.view.View#getBottomPaddingOffset} to class {@link android.view.View android.view.View}.</td></tr>
-    <tr><td>Added public method {@link android.view.View#getLeftPaddingOffset} to class {@link android.view.View android.view.View}.</td></tr>
-    <tr><td>Added public method {@link android.view.View#getRightPaddingOffset} to class {@link android.view.View android.view.View}.</td></tr>
-    <tr><td>Added public method {@link android.view.View#getTopPaddingOffset} to class {@link android.view.View android.view.View}.</td></tr>
-    <tr><td>Added public method {@link android.view.View#isPaddingOffsetRequired} to class {@link android.view.View android.view.View}.</td></tr>
-
-<tr><td rowspan="3">Marquee support</td></tr>
-    <tr><td>Added public method {@link android.widget.TextView#setMarqueeRepeatLimit} to class {@link android.widget.TextView}</td></tr>
-    <tr><td>Added public field {@link android.R.attr#marqueeRepeatLimit android.R.attr.marqueeRepeatLimit}</td></tr>
-
-<tr><td rowspan="3">New permissions</td></tr>
-    <tr><td>Added public field {@link android.Manifest.permission#BROADCAST_SMS android.Manifest.permission.BROADCAST_SMS}</td></tr>
-    <tr><td>Added public field {@link android.Manifest.permission#BROADCAST_WAP_PUSH android.Manifest.permission.BROADCAST_WAP_PUSH}</td></tr>
-
-<tr><td rowspan="2">API cleanup</td></tr>
-    <tr><td>Removed protected constructor java.net.ServerSocket.ServerSocket(java.net.SocketImpl).</td></tr>
-
-</table>
+<p>Please see <a href="{@docRoot}sdk/preview/index.html">Download the Android 1.5 Early Look SDK</a> for more information. </p>
 
 
 
diff --git a/docs/html/sdk/terms.jd b/docs/html/sdk/terms.jd
index 46388504..b3c5ea2 100644
--- a/docs/html/sdk/terms.jd
+++ b/docs/html/sdk/terms.jd
@@ -8,7 +8,8 @@
 	1. Introduction
 </h2>
 <p>
-	1.1 The Android Software Development Kit (referred to in this License Agreement as the "SDK" and specifically including the Android system files and packaged APIs) is licensed to you subject to the terms of this License Agreement. This License Agreement forms a legally binding contract between you and Google in relation to your use of the SDK.
+	1.1 The Android Software Development Kit (referred to in this License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google Services add-ons) is licensed to you subject to the terms of this License Agreement. This License Agreement forms a legally binding contract between you and Google in relation to your use of the SDK.
+
 </p>
 <p>
 	1.2 "Google" means Google Inc., a Delaware corporation with principal place of business at 1600 Amphitheatre Parkway, Mountain View, CA 94043, United States.
@@ -41,10 +42,11 @@
 	3.1 Subject to the terms of this License Agreement, Google grants you a limited, worldwide, royalty-free, non- assignable and non-exclusive license to use the SDK solely to develop applications to run on the Android platform.
 </p>
 <p>
-	3.2 You agree that Google or third parties own all legal right, title and interest in and to the SDK, including any Intellectual Property Rights that subsist in the SDK. "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. The Android Open Source Project
+	3.2 You agree that Google or third parties own all legal right, title and interest in and to the SDK, including any Intellectual Property Rights that subsist in the SDK. "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. 
+
 </p>
 <p>
-	3.3 Except to the extent required by applicable third party licenses, you may not copy (except for backup purposes), modify, adapt, redistribute, decompile, reverse engineer, disassemble, or create derivative works of the SDK or any part of the SDK. Except to the extent required by applicable third party licenses, you may not load any part of the SDK onto a mobile handset or any other hardware device except a personal computer, combine any part of the SDK with other software, or distribute any software or device incorporating a part of the SDK.
+	3.3. Except to the extent required by applicable third party licenses, you may not copy (except for backup purposes), modify, adapt, redistribute, decompile, reverse engineer, disassemble, or create derivative works of the SDK or any part of the SDK. Except to the extent required by applicable third party licenses, you may not load any part of the SDK onto a mobile handset or any other hardware device except a personal computer, combine any part of the SDK with other software, or distribute any software or device incorporating a part of the SDK. 
 </p>
 <p>
 	3.4 Use, reproduction and distribution of components of the SDK licensed under an open source software license are governed solely by the terms of that open source software license and not this License Agreement.
@@ -62,7 +64,7 @@
 	4. Use of the SDK by You
 </h2>
 <p>
-	4.1 Google agrees that it obtains no right, title or interest from you (or your licensors) under this License Agreement in or to any software applications that you develop using the SDK, including any intellectual property rights which subsist in those applications.
+	4.1 Google agrees that it obtains no right, title or interest from you (or your licensors) under this License Agreement in or to any software applications that you develop using the SDK, including any intellectual property rights that subsist in those applications. 
 </p>
 <p>
 	4.2 You agree to use the SDK and write applications only for purposes that are permitted by (a) this 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).
@@ -110,25 +112,14 @@
 	8. Using Android APIs
 </h2>
 <p>
-	8.1 Android Maps API
+	8.1 Google Data APIs
 </p>
 <p>
-	8.1.1 If you use the Android Maps API (described in the SDK by the Package names "com.google.android.maps" and "com.android.location.Geocoder"), the terms of your binding legal agreement with Google include this License Agreement, the <a href="http://www.google.com/apis/maps/terms.html">Google Maps API Terms of Service</a> and the <a href="http://www.google.com/intl/en_ALL/help/terms_local.html">Google Maps Terms of Service</a>. You must read and agree to those Terms of Service before you use the Android Maps API.
+	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.
 </p>
 <p>
-	8.1.2 If you use the Android Maps API to retrieve map or satellite image data from Google, you must include the following copyright notice in your application or service in a manner that is reasonably available to users:
-</p>
-<p>
-	"Copyright Notice: Data: (c)2007 TeleAtlas, AND, Europa Technologies, Kingway, Map Data Sciences Pty Ltd, PSMA, ZENRIN, Geocentre, MapLink/TeleAtlas; Imagery: (c)2007 DigitalGlobe, EarthSat, Sanborn, NYGIS, Scankort, TerraMetrics, MassGIS Commonwealth of Massachusetts, Digital Earth Technology."
-</p>
-<p>
-	8.2 Google Data APIs
-</p>
-<p>
-	8.2.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 those who provide that data (or by other persons or companies on their behalf). You may not modify, rent, lease, loan, sell, distribute or create derivative works based on this data (either in whole or in part) unless you have been specifically given permission to do so by the owners of that data.
-</p>
-<p>
-	8.2.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.
+	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. 
+
 </p>
 <h2>
 	9. Terminating this License Agreement
@@ -185,10 +176,7 @@
 	13. Changes to the License Agreement
 </h2>
 <p>
-	13.1 Google may make changes to the License Agreement as it distributes new versions of the SDK. When these changes are made, Google will make a new version of the License Agreement available on the website where the SDK is made available and with the SDK downloadable.
-</p>
-<p>
-	13.2 You agree that your use of a specific version of the SDK is governed by the License Agreement included with that version of the SDK.
+	13.1 Google may make changes to the License Agreement as it distributes new versions of the SDK. When these changes are made, Google will make a new version of the License Agreement available on the website where the SDK is made available.
 </p>
 <h2>
 	14. General Legal Terms
@@ -215,5 +203,5 @@
 	14.7 This License Agreement, and your relationship with Google under this 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 this 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.
 </p>
 <p>
-	<em>August 18, 2008</em>
+	<em>April 10, 2009</em>
 </p>
diff --git a/docs/html/sdk/terms_body.html b/docs/html/sdk/terms_body.html
index e8fdc3c..a73801f 100644
--- a/docs/html/sdk/terms_body.html
+++ b/docs/html/sdk/terms_body.html
@@ -5,7 +5,8 @@
 	1. Introduction
 </h2>
 <p>
-	1.1 The Android Software Development Kit (referred to in this License Agreement as the "SDK" and specifically including the Android system files and packaged APIs) is licensed to you subject to the terms of this License Agreement. This License Agreement forms a legally binding contract between you and Google in relation to your use of the SDK.
+	1.1 The Android Software Development Kit (referred to in this License Agreement as the "SDK" and specifically including the Android system files, packaged APIs, and Google Services add-ons) is licensed to you subject to the terms of this License Agreement. This License Agreement forms a legally binding contract between you and Google in relation to your use of the SDK.
+
 </p>
 <p>
 	1.2 "Google" means Google Inc., a Delaware corporation with principal place of business at 1600 Amphitheatre Parkway, Mountain View, CA 94043, United States.
@@ -38,10 +39,11 @@
 	3.1 Subject to the terms of this License Agreement, Google grants you a limited, worldwide, royalty-free, non- assignable and non-exclusive license to use the SDK solely to develop applications to run on the Android platform.
 </p>
 <p>
-	3.2 You agree that Google or third parties own all legal right, title and interest in and to the SDK, including any Intellectual Property Rights that subsist in the SDK. "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. The Android Open Source Project
+	3.2 You agree that Google or third parties own all legal right, title and interest in and to the SDK, including any Intellectual Property Rights that subsist in the SDK. "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. 
+
 </p>
 <p>
-	3.3 Except to the extent required by applicable third party licenses, you may not copy (except for backup purposes), modify, adapt, redistribute, decompile, reverse engineer, disassemble, or create derivative works of the SDK or any part of the SDK. Except to the extent required by applicable third party licenses, you may not load any part of the SDK onto a mobile handset or any other hardware device except a personal computer, combine any part of the SDK with other software, or distribute any software or device incorporating a part of the SDK.
+	3.3. Except to the extent required by applicable third party licenses, you may not copy (except for backup purposes), modify, adapt, redistribute, decompile, reverse engineer, disassemble, or create derivative works of the SDK or any part of the SDK. Except to the extent required by applicable third party licenses, you may not load any part of the SDK onto a mobile handset or any other hardware device except a personal computer, combine any part of the SDK with other software, or distribute any software or device incorporating a part of the SDK. 
 </p>
 <p>
 	3.4 Use, reproduction and distribution of components of the SDK licensed under an open source software license are governed solely by the terms of that open source software license and not this License Agreement.
@@ -59,7 +61,7 @@
 	4. Use of the SDK by You
 </h2>
 <p>
-	4.1 Google agrees that it obtains no right, title or interest from you (or your licensors) under this License Agreement in or to any software applications that you develop using the SDK, including any intellectual property rights which subsist in those applications.
+	4.1 Google agrees that it obtains no right, title or interest from you (or your licensors) under this License Agreement in or to any software applications that you develop using the SDK, including any intellectual property rights that subsist in those applications. 
 </p>
 <p>
 	4.2 You agree to use the SDK and write applications only for purposes that are permitted by (a) this 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).
@@ -107,25 +109,14 @@
 	8. Using Android APIs
 </h2>
 <p>
-	8.1 Android Maps API
+	8.1 Google Data APIs
 </p>
 <p>
-	8.1.1 If you use the Android Maps API (described in the SDK by the Package names "com.google.android.maps" and "com.android.location.Geocoder"), the terms of your binding legal agreement with Google include this License Agreement, the <a href="http://www.google.com/apis/maps/terms.html">Google Maps API Terms of Service</a> and the <a href="http://www.google.com/intl/en_ALL/help/terms_local.html">Google Maps Terms of Service</a>. You must read and agree to those Terms of Service before you use the Android Maps API.
+	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.
 </p>
 <p>
-	8.1.2 If you use the Android Maps API to retrieve map or satellite image data from Google, you must include the following copyright notice in your application or service in a manner that is reasonably available to users:
-</p>
-<p>
-	"Copyright Notice: Data: (c)2007 TeleAtlas, AND, Europa Technologies, Kingway, Map Data Sciences Pty Ltd, PSMA, ZENRIN, Geocentre, MapLink/TeleAtlas; Imagery: (c)2007 DigitalGlobe, EarthSat, Sanborn, NYGIS, Scankort, TerraMetrics, MassGIS Commonwealth of Massachusetts, Digital Earth Technology."
-</p>
-<p>
-	8.2 Google Data APIs
-</p>
-<p>
-	8.2.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 those who provide that data (or by other persons or companies on their behalf). You may not modify, rent, lease, loan, sell, distribute or create derivative works based on this data (either in whole or in part) unless you have been specifically given permission to do so by the owners of that data.
-</p>
-<p>
-	8.2.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.
+	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. 
+
 </p>
 <h2>
 	9. Terminating this License Agreement
@@ -182,10 +173,7 @@
 	13. Changes to the License Agreement
 </h2>
 <p>
-	13.1 Google may make changes to the License Agreement as it distributes new versions of the SDK. When these changes are made, Google will make a new version of the License Agreement available on the website where the SDK is made available and with the SDK downloadable.
-</p>
-<p>
-	13.2 You agree that your use of a specific version of the SDK is governed by the License Agreement included with that version of the SDK.
+	13.1 Google may make changes to the License Agreement as it distributes new versions of the SDK. When these changes are made, Google will make a new version of the License Agreement available on the website where the SDK is made available.
 </p>
 <h2>
 	14. General Legal Terms
@@ -212,5 +200,5 @@
 	14.7 This License Agreement, and your relationship with Google under this 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 this 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.
 </p>
 <p>
-	<em>August 18, 2008</em>
-</p>
+	<em>April 10, 2009</em>
+</p>
\ No newline at end of file
