diff --git a/docs/html/sdk/eclipse-adt.jd b/docs/html/sdk/eclipse-adt.jd
index 9f3c8b0..ef7d8658 100644
--- a/docs/html/sdk/eclipse-adt.jd
+++ b/docs/html/sdk/eclipse-adt.jd
@@ -28,7 +28,7 @@
 </div>
 </div>
 
-<p>Android Development Tools (ADT) is a plugin for the Eclipse IDE 
+<p>Android Development Tools (ADT) is a plugin for the Eclipse IDE
 that is designed to give you a powerful, integrated environment in which
 to build Android applications. </p>
 
@@ -48,7 +48,7 @@
 Eclipse IDE and the Android SDK installed. For details, make sure to read <a
 href="#installing">Installing the ADT Plugin</a>, below. </p>
 
-<p>If you are already using ADT, this document also provides instructions on 
+<p>If you are already using ADT, this document also provides instructions on
 how to update ADT to the latest version or how to uninstall it, if necessary.
 </p>
 
@@ -156,7 +156,7 @@
 called <code>src/</code>. There is now support for any number of source folders,
 with no name restriction. They can even be in subfolder such as
 <code>src/java</code>. If you are already working with library projects created
-in ADT 0.9.7, see <a 
+in ADT 0.9.7, see <a
 href="{@docRoot}guide/developing/eclipse-adt.html#libraryMigrating">Migrating
 library projects to ADT 0.9.8</a> for important information about moving
 to the new ADT environment.</li>
@@ -166,7 +166,7 @@
 <code>car</code>/<code>desk</code>, <code>night</code>/<code>notnight</code> and
 <code>navexposed</code>/<code>navhidden</code>.</li>
 <li>Adds more device screen types in the layout editor. All screen
-resolution/density combinations listed in the <a 
+resolution/density combinations listed in the <a
 href="{@docRoot}guide/practices/screens_support.html#range">Supporting
 Multiple Screens</a> are now available.</li>
 <li>Fixes problems with handling of library project names that
@@ -195,10 +195,10 @@
 library project from other Android projects and, at build time, the tools
 compile the shared code and resources as part of the dependent applications.
 More information about this feature is available in the <a
-href="{@docRoot}guide/developing/eclipse-adt.html#libraryProject">Developing 
+href="{@docRoot}guide/developing/eclipse-adt.html#libraryProject">Developing
 in Eclipse with ADT</a> document. </p>
-<p>If you are not developing in Eclipse, <a 
-href="tools-notes.html">SDK Tools r6</a> provides the equivalent library 
+<p>If you are not developing in Eclipse, <a
+href="tools-notes.html">SDK Tools r6</a> provides the equivalent library
 project support through the Ant build system.</p>
 </dd>
 </dl>
@@ -215,7 +215,7 @@
 <dl>
 <dt>Dependencies:</dt>
 
-<dd><p>ADT 0.9.6 is designed for use with SDK Tools r5 and later. Before 
+<dd><p>ADT 0.9.6 is designed for use with SDK Tools r5 and later. Before
 updating to ADT 0.9.6, we highly recommend that you use the Android SDK and
 AVD Manager to install SDK Tools r5 into your SDK.</p></dd>
 
@@ -339,7 +339,7 @@
 <ul>
 <li>Includes the improvements from the standlone DDMS, revision 3.</li>
 <li>Adds an option to open HPROF files into eclipse instead of writing them on
-disk. If a profiler such as MAT (<a href="http://eclipse.org/mat">Memory Analyzer 
+disk. If a profiler such as MAT (<a href="http://eclipse.org/mat">Memory Analyzer
 Tool</a>) is installed, it'll open the file.</li>
 </ul>
 </dd>
@@ -347,7 +347,7 @@
 <dt>Android SDK and AVD Manager integration:</dt>
 <dd>
 <ul>
-<li>Includes the improvements from the standalone Android SDK and AVD Manager, 
+<li>Includes the improvements from the standalone Android SDK and AVD Manager,
 revision 3.</li>
 </ul>
 </dd>
@@ -408,16 +408,16 @@
 <td width="45%">
 <!-- 3.4 steps -->
 <ol>
-    <li>Start Eclipse, then select <strong>Help</strong> &gt; <strong>Software Updates...</strong>. 
+    <li>Start Eclipse, then select <strong>Help</strong> &gt; <strong>Software Updates...</strong>.
         In the dialog that appears, click the <strong>Available Software</strong> tab. </li>
     <li>Click <strong>Add Site...</strong> </li>
     <li>In the Add Site dialog that appears, enter this URL in the "Location" field:
       <pre style="margin-left:0">https://dl-ssl.google.com/android/eclipse/</pre>
         <p>Note: If you have trouble acquiring the plugin, try using "http" in the Location URL,
-        instead of "https" (https is preferred for security reasons).</p>   
+        instead of "https" (https is preferred for security reasons).</p>
       <p>Click <strong>OK</strong>.</p></li>
     <li>Back in the Available Software view, you should see the plugin listed by the URL,
-    with "Developer Tools" nested within it. Select the checkbox next to 
+    with "Developer Tools" nested within it. Select the checkbox next to
       Developer Tools and click <strong>Install...</strong></li>
     <li>On the subsequent Install window, "Android DDMS" and "Android Development Tools"
     should both be checked. Click <strong>Next</strong>. </li>
@@ -433,25 +433,25 @@
         New Software</strong>. </li>
     <li>In the Available Software dialog, click <strong>Add...</strong>.</li>
     <li>In the Add Site dialog that appears, enter a name for the remote site
-        (for example, "Android Plugin") in the "Name" field. 
+        (for example, "Android Plugin") in the "Name" field.
         <p>In the "Location" field, enter this URL:</p>
         <pre>https://dl-ssl.google.com/android/eclipse/</pre>
         <p>Note: If you have trouble acquiring the plugin, you can try
-           using "http" in the URL, instead of "https" (https is preferred for 
+           using "http" in the URL, instead of "https" (https is preferred for
            security reasons).</p>
         <p>Click <strong>OK</strong>.</p>
     </li>
     <li>Back in the Available Software view, you should now see "Developer
-        Tools" added to the list. Select the checkbox next to Developer Tools, 
-        which will automatically select the nested tools Android DDMS and Android 
-        Development Tools. 
+        Tools" added to the list. Select the checkbox next to Developer Tools,
+        which will automatically select the nested tools Android DDMS and Android
+        Development Tools.
         Click <strong>Next</strong>. </li>
-    <li>In the resulting Install Details dialog, the Android DDMS and Android 
-        Development Tools features are listed. Click <strong>Next</strong> to 
-        read and accept the license agreement and install any dependencies, 
+    <li>In the resulting Install Details dialog, the Android DDMS and Android
+        Development Tools features are listed. Click <strong>Next</strong> to
+        read and accept the license agreement and install any dependencies,
         then click <strong>Finish</strong>. </li>
     <li>Restart Eclipse. </li>
-	
+
 </ol>
 </td>
 </tr>
@@ -466,15 +466,15 @@
     <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 <em>SDK Location</em> in the main panel, click <strong>Browse...</strong> and 
+    <li>For the <em>SDK Location</em> in the main panel, click <strong>Browse...</strong> and
         locate your downloaded SDK directory. </li>
     <li>Click <strong>Apply</strong>, then <strong>OK</strong>.</li>
 </ol>
 
 <p>Done! If you haven't encountered any problems, then the installation is
-complete. Now read <a href="installing.html#components">Adding Platforms and
-Other Components</a> for instructions on how to complete the setup of your 
-SDK environment. </p>
+complete. If you're installing the Android SDK for the first time, return to <a
+href="{@docRoot}sdk/installing.html#InstallingADT">Installing the SDK</a> to complete your setup.
+</p>
 
 
 <h3 id="troubleshooting">Troubleshooting ADT Installation</h3>
@@ -486,7 +486,7 @@
   <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> 
+<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
@@ -521,14 +521,14 @@
 </li>
 
 </li>
-  <li>Follow steps 1 and 2 in the <a href="#installing">default install 
+  <li>Follow steps 1 and 2 in the <a href="#installing">default install
       instructions</a> (above).</li>
   <li>In the Add Site dialog, click <strong>Archive</strong>.</li>
   <li>Browse and select the downloaded zip file.</li>
   <li>In Eclipse 3.5 only, enter a name for the local update site (e.g.,
       "Android Plugin") in the "Name" field.</li>
   <li>Click <strong>OK</strong>.
-  <li>Follow the remaining procedures as listed for 
+  <li>Follow the remaining procedures as listed for
       <a href="#installing">default installation</a> above,
       starting from step 4.</li>
 </ol>
@@ -538,16 +538,16 @@
 
 <h4>Other install errors</h4>
 
-<p>Note that there are features of ADT that require some optional 
-Eclipse components (for example, WST). If you encounter an error when 
-installing ADT, your Eclipse installion might not include these components. 
-For information about how to quickly add the necessary components to your 
-Eclipse installation, see the troubleshooting topic 
-<a href="{@docRoot}resources/faq/troubleshooting.html#installeclipsecomponents">ADT 
+<p>Note that there are features of ADT that require some optional
+Eclipse components (for example, WST). If you encounter an error when
+installing ADT, your Eclipse installion might not include these components.
+For information about how to quickly add the necessary components to your
+Eclipse installation, see the troubleshooting topic
+<a href="{@docRoot}resources/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: 
+<p>If you encounter this error when installing the ADT Plugin for Eclipse:
 <pre>
 An error occurred during provisioning.
 Cannot connect to keystore.
@@ -572,12 +572,12 @@
 
 <p>To learn about new features of each ADT revision and also any dependencies on
 the SDK Tools, see the listings in the <a href="#notes">Revisions</a>
-section. To determine the version currently installed, open the 
+section. To determine the version currently installed, open the
 Eclipse Installed Software window using <strong>Help</strong>
-&gt; <strong>Software Updates</strong> and refer to the version listed for 
+&gt; <strong>Software Updates</strong> and refer to the version listed for
 "Android Development Tools".</p>
 
-<p>Follow the steps below to check whether an update is available and, if so, 
+<p>Follow the steps below to check whether an update is available and, if so,
 to install it. </p>
 
 <table style="font-size:100%">
@@ -588,13 +588,13 @@
 <ol>
     <li>Select <strong>Help</strong> &gt; <strong>Software Updates</strong>.</li>
     <li>Select the <strong>Available Software</strong> tab.</li>
-    <li>Select the checkboxes next to Android DDMS and Android Developer Tools, 
+    <li>Select the checkboxes next to Android DDMS and Android Developer Tools,
       then click  <strong>Update</strong>.</li>
-    <li>In the resulting Available Updates dialog, ensure that both Android DDMS 
-      and Android Development Tools are selected, then click 
+    <li>In the resulting Available Updates dialog, ensure that both Android DDMS
+      and Android Development Tools are selected, then click
       <strong>Next</strong>.</li>
     <li>Read and accept the license agreement and then click <strong>Finish</strong>.
-      This will download and install the latest version of Android DDMS and 
+      This will download and install the latest version of Android DDMS and
       Android Development Tools.</li>
     <li>Restart Eclipse.</li>
 </ol>
@@ -603,17 +603,17 @@
 <!-- 3.5 steps -->
 <ol>
     <li>Select <strong>Help</strong> &gt; <strong>Check for Updates</strong>. </li>
-    <li>In the resulting Available Updates dialog, locate the Android DDMS and 
+    <li>In the resulting Available Updates dialog, locate the Android DDMS and
         Android Development Tools features in the list and ensure that the checkboxes
-        next to them are selected. Click <strong>Next</strong>. 
-        <p>If the Available Updates dialog does not list Android DDMS and Android 
-           Development tools, make sure that you have set up a remote update site 
-           for them, as described in 
-           <a href="#installing">Installing the ADT Plugin</a>. 
+        next to them are selected. Click <strong>Next</strong>.
+        <p>If the Available Updates dialog does not list Android DDMS and Android
+           Development tools, make sure that you have set up a remote update site
+           for them, as described in
+           <a href="#installing">Installing the ADT Plugin</a>.
         </p></li>
     <li>In the Update Details dialog, click <strong>Next</strong>.</li>
     <li>Read and accept the license agreement and then click <strong>Finish</strong>.
-      This will download and install the latest version of Android DDMS and 
+      This will download and install the latest version of Android DDMS and
       Android Development Tools.</li>
     <li>Restart Eclipse.</li>
 </ol>
@@ -622,17 +622,17 @@
 </table>
 
 
-<p>If you encounter problems during the update of ADT, you 
+<p>If you encounter problems during the update of ADT, you
 can try removing the existing ADT plugin and then performing a fresh
 installation. To remove the plugin, follow the instructions in <a
-href="#uninstalling">Uninstalling the ADT Plugin</a>, below. To reinstall 
+href="#uninstalling">Uninstalling the ADT Plugin</a>, below. To reinstall
 the plugin, follow the instructions in <a
 href="#installing">Installing the ADT Plugin</a>, above.</p>
 
 
 <h2 id="uninstalling">Uninstalling the ADT plugin</h2>
 
-<p><p>If you encounter problems when installing or updating ADT, you 
+<p><p>If you encounter problems when installing or updating ADT, you
 can try removing the existing ADT plugin and then performing a fresh
 installation. To remove ADT, follow these steps: </p>
 
@@ -642,12 +642,12 @@
 <td width="50%">
 <!-- 3.4 steps -->
 <ol>
-    <li>Select <strong>Help</strong> &gt; <strong>Software Updates</strong> &gt; 
+    <li>Select <strong>Help</strong> &gt; <strong>Software Updates</strong> &gt;
       <strong>Manage Configuration</strong>. </li>
     <li>Expand the list in the left panel to reveal the installed tools.</li>
-    <li>Right-click "Android Editors" and click <strong>Uninstall</strong>. Click <strong>OK</strong> 
+    <li>Right-click "Android Editors" and click <strong>Uninstall</strong>. Click <strong>OK</strong>
     to confirm.</li>
-    <li>Restart Eclipse. 
+    <li>Restart Eclipse.
       <p>(Do not uninstall "Android Development Tools".)</p></li>
 </ol>
 </td>
diff --git a/docs/html/sdk/installing.jd b/docs/html/sdk/installing.jd
index 8484bea..c3b103f 100644
--- a/docs/html/sdk/installing.jd
+++ b/docs/html/sdk/installing.jd
@@ -8,10 +8,10 @@
 
   <h2>In this document</h2>
   <ol>
-    <li><a href="#Preparing">Preparing Your Development Computer</a></li>
-    <li><a href="#Installing">Downloading the SDK Starter Package</a></li>
-    <li><a href="#InstallingADT">Installing the ADT Plugin for Eclipse</a></li>
-    <li><a href="#components">Adding Platforms and Other Components</a>
+    <li><a href="#Preparing">1. Preparing Your Development Computer</a></li>
+    <li><a href="#Installing">2. Downloading the SDK Starter Package</a></li>
+    <li><a href="#InstallingADT">3. Installing the ADT Plugin for Eclipse</a></li>
+    <li><a href="#components">4. Adding Platforms and Other Components</a>
     <ol>
     <li><a href="#which">Which components do I need?</a></li>
     </ol></li>
@@ -38,65 +38,58 @@
 
 <h4>Updating?</h4>
 
-<p>If you are currently using the Android 1.6 SDK or later and want to update
-to the latest tools or platforms, you do not need to install a new SDK. Instead,
-you can simply update the individual components in your SDK using the
-Android SDK and AVD Manager tool. For information about how to do that, see <a
-href="{@docRoot}sdk/adding-components.html#UpdatingComponents">Updating SDK
-Components</a></p>
-
-<p>If you are using Android 1.5 SDK or earlier, you should install a new SDK as
-described in this document and move your application projects to the new
-SDK environment. </p>
+<p>If you already have an Android SDK, use the <em>Android SDK and AVD Manager</em> tool to install
+updated tools and new Android platforms into your existing environment. For information about how to
+do that, see <a href="{@docRoot}sdk/adding-components.html">Adding SDK Components</a></p>
 
 
 <h2 id="Preparing">Step 1. Preparing Your Development Computer</h2>
 
 <p>Before getting started with the Android SDK, take a moment to confirm that
 your development computer meets the <a href="requirements.html">System
-Requirements</a>. In particular, you may need to install the <a
-href="http://java.sun.com/javase/downloads/index.jsp">JDK</a> before
-continuing, if it's not already installed on your computer. </p>
+Requirements</a>. In particular, you might need to install the <a
+href="http://java.sun.com/javase/downloads/index.jsp">JDK</a>, if you don't have it already. </p>
 
 <p>If you will be developing in 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
+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 (3.4 or newer is recommended). 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. For Eclipse 3.5, the
-"Eclipse Classic" version is recommended.</p>
+<p>For Eclipse 3.5 or newer, the "Eclipse Classic" version is recommended. Otherwise, a Java or
+RCP version of Eclipse is recommended.</p>
 
 
 <h2 id="Installing">Step 2. Downloading the SDK Starter Package</h2>
 
 <p>The first step in setting up your environment for developing Android applications
-is downloading the Android SDK starter package. The starter package is not a full
-development environment &mdash; it includes only the core SDK Tools, which you can
-use to download the rest of the SDK components (such as the platform system images). </p>
+is downloading the Android SDK starter package.</p>
 
-<p>You can get the latest version of the SDK starter package from the <a
-href="{@docRoot}sdk/index.html">SDK download page</a>. Make sure to download the
-package that is appropriate for your development computer.</p>
+<p>The starter package is not a full
+development environment&mdash;it includes only the core SDK Tools, which you can
+use to download the rest of the SDK components (such as the platform system images). </p>
 
 <p class="note"><strong>Note:</strong> If you're using Windows, we recommend that you download
 the SDK installer (the {@code .exe} file from the download table). It will guide you through the
 installation process and check your computer for the required software.</p>
 
-<p>If you downloaded a {@code .zip} of {@code .tgz} (instead of using the SDK installer), unpack the
-Android SDK archive to a safe location on your machine. By default, the SDK files are unpacked into
-a directory named <code>android-sdk-&lt;machine-platform&gt;</code>.</p>
+<p>You can get the latest version of the SDK starter package from the <a
+href="{@docRoot}sdk/index.html">SDK download page</a>.</p>
+
+<p>If you downloaded a {@code .zip} or {@code .tgz} package (instead of the SDK installer), unpack
+it to a safe location on your machine. By default, the SDK files are unpacked
+into a directory named <code>android-sdk-&lt;machine-platform&gt;</code>.</p>
 
 <p>Make a note of the name and
-location of the unpacked SDK directory on your system &mdash; you will need to
+location of the unpacked SDK directory on your system&mdash;you will need to
 refer to the SDK directory later, when setting up the ADT plugin and when using
 the SDK tools from command line.</p>
 
-<p>Optionally, you might want to add the location of the SDK's primary
-<code>tools</code> directory and the additional {@code platform-tools/} directory  to your system
+<p>Optionally, you might want to add the location of the SDK's
+<code>tools/</code> directory and {@code platform-tools/} directory  to your system
 <code>PATH</code>. Both tool directories are located at the root of the SDK folder. Adding
 <code>tools/</code> and {@code platform-tools/} to your path lets you run Android Debug Bridge (adb)
 and the other command line <a
@@ -121,7 +114,7 @@
   <code>tools/</code> and {@code platform-tools/} directories to the path. </li>
   </ul>
 
-<p>If you will be using the Eclipse IDE as your development environment, the
+<p>If you will be using the Eclipse IDE, the
 next section describes how to install the Android Development Tools (ADT) plugin
 and set up Eclipse. If you choose not to use Eclipse, you can develop Android
 applications in an IDE of your choice and then compile, debug and deploy using
@@ -135,17 +128,16 @@
 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, debug your applications
+UI, debug your applications
 using the Android SDK tools, and even export signed (or unsigned) APKs in order
 to distribute your application. In general, developing in Eclipse with ADT is a
 highly recommended approach and is the fastest way to get started with Android.
 </p>
 
 <p>If you'd like to use ADT for developing Android applications, install it now.
-Read <a href="{@docRoot}sdk/eclipse-adt.html">ADT Plugin for Eclipse</a> for
-step-by-step installation instructions, then return here to continue with the
-last step in setting up your SDK: adding platforms and other
-components.</p>
+Read <a href="{@docRoot}sdk/eclipse-adt.html#installing">Installing the ADT Plugin</a> for
+step-by-step installation instructions, then return here to continue the
+last step in setting up your Android SDK.</p>
 
 <p>If you prefer to work in an IDE other than Eclipse, you do not need to
 install Eclipse or ADT, instead, you can directly use the SDK tools to build and
@@ -157,28 +149,24 @@
 <div class="sidebox-wrapper" style="margin-right:2.5em;">
 <div class="sidebox"> <h2>Using the Android SDK and AVD Manager</h2>
 
-<p>The <em>Android SDK and AVD Manager</em> is a tool that you will use often,
-to add components to your SDK environment and manage Android Virtual Devices.
+<p>The <em>Android SDK and AVD Manager</em> is a tool that you will use often
+to add components to your SDK environment and manage <a
+href="{@docRoot}guide/developing/tools/avd.html">Android Virtual Devices</a>.
 </p>
 
-<p style="margin-top:.5em;">The tool is pre-installed in your SDK. See <a
+<p>See <a
 href="adding-components.html">Adding SDK Components</a> for details on how to
 launch and use the tool.</p>
 </div>
 </div>
 
-<p>The last step in setting up your SDK is using a tool included the SDK starter
-package &mdash; the <em>Android SDK and AVD Manager</em> &mdash; to download
-essential components into your development environment. Read the information
-below to understand what components you'll need, then see <a
-href="adding-components.html">Adding SDK Components</a> for step-by-step
-instructions on how to launch the Android SDK and AVD Manager and download the
-components into your environment.</p>
+<p>The last step in setting up your SDK is using the <em>Android SDK and AVD Manager</em> (a
+tool included in the SDK starter package) to download
+essential SDK components into your development environment.</p>
 
-<p>The SDK uses a modular structure that separates the major parts of the SDK
-&mdash; Android platform versions, add-ons, tools, samples, and the API
-documentation &mdash; into a set of separately installable components. The SDK
-starter package, which you've already downloaded, includes only a single
+<p>The SDK uses a modular structure that separates the major parts of the SDK&mdash;Android platform
+versions, add-ons, tools, samples, and documentation&mdash;into a set of separately installable
+components. The SDK starter package, which you've already downloaded, includes only a single
 component: the latest version of the SDK Tools. To develop any Android
 application, you also need to download at least one Android platform into your
 environment, although downloading additional components is highly recommended.
@@ -353,7 +341,7 @@
 <td>Contains add-ons to the Android SDK development
 environment, which let you develop against external libraries that are available on some
 devices. </td>
-</tr>
+</tr>repo
 <tr>
 <td colspan="3"><code>docs/</code></td>
 <td>A full set of documentation in HTML format, including the Developer's Guide,
