diff --git a/docs/html/sdk/android-4.0.jd b/docs/html/sdk/android-4.0.jd
index 8f7ac55..619c907 100644
--- a/docs/html/sdk/android-4.0.jd
+++ b/docs/html/sdk/android-4.0.jd
@@ -71,7 +71,12 @@
   <div class="toggle-content-toggleme" style="padding-left:2em;">
 
 <dl>
-<dt>Initial release. SDK Tools r14 or higher is recommended.</dt>
+<dt>Initial release. SDK Tools r14 or higher is required.
+<p class="note"><strong>Important:</strong> To download the new Android
+4.0 system components from the Android SDK Manager, you must first update the
+SDK tools to revision 14 and restart the Android SDK Manager. If you do not,
+the Android 4.0 system components will not be available for download.</p>
+</dt>
 </dl>
 
   </div>
@@ -165,7 +170,7 @@
 
 <p>The {@link android.provider.ContactsContract.Intents#INVITE_CONTACT} intent action allows you to
 invoke an action that indicates the user wants to add a contact to a social network that understand
-this intent and use it to invite the contact specified in the contact to that social network.</p> 
+this intent and use it to invite the contact specified in the contact to that social network.</p>
 
 <p>Apps that use a sync adapter to provide information about contacts can register with the system
 to
@@ -290,7 +295,7 @@
 located</li>
 </ul>
 
-  
+
 <h4>Focus and Metering Areas</h4>
 
 <p>Camera apps can now control the areas that the camera uses for focus and when metering white
@@ -334,7 +339,7 @@
 <h4>Camera Broadcast Intents</h4>
 
 <ul>
-<li>{@link android.hardware.Camera#ACTION_NEW_PICTURE Camera.ACTION_NEW_PICTURE} 
+<li>{@link android.hardware.Camera#ACTION_NEW_PICTURE Camera.ACTION_NEW_PICTURE}
 This indicates that the user has captured a new photo. The built-in camera app invokes this
 broadcast after a photo is captured and third-party camera apps should also broadcast this intent
 after capturing a photo.</li>
@@ -344,10 +349,10 @@
 after capturing a video.</li>
 </ul>
 
-  
-  
 
-  
+
+
+
 <h3 id="Multimedia">Multimedia</h3>
 
 <p>Android 4.0 adds several new APIs for applications that interact with media such as photos,
@@ -476,7 +481,7 @@
 function). You may provide multiple mipmap levels. If the output texture has not been bound to a
 texture image, it will be automatically bound by the effect as a {@link
 android.opengl.GLES20#GL_TEXTURE_2D}. It will contain one mipmap level (0), which will have the same
-size as the input.</p> 
+size as the input.</p>
 
 
 
@@ -844,9 +849,9 @@
   onInitializeAccessibilityEvent()} - This method collects information about the view. If your
   application has specific requirements for accessibility, you should extend this method to add that
   information to the {@link android.view.accessibility.AccessibilityEvent}.</li>
-  
+
   <li>{@link
- 
+
 android.view.View#dispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent)
   dispatchPopulateAccessibilityEvent()} is called by the framework to request text information for
   this view and its children. This method calls {@link
@@ -890,7 +895,7 @@
 the {@link android.view.accessibility.AccessibilityEvent#getRecord(int)
 AccessibilityEvent.getRecord()} to retrieve new accessibility information about the state of the
 view.</li>
-<li>From the {@link android.view.accessibility.AccessibilityRecord}, call {@link 
+<li>From the {@link android.view.accessibility.AccessibilityRecord}, call {@link
 android.view.accessibility.AccessibilityRecord#getSource() getSource()} to retrieve a {@link
 android.view.accessibility.AccessibilityNodeInfo} object.</li>
 <li>With the {@link android.view.accessibility.AccessibilityNodeInfo}, call {@link
diff --git a/docs/html/sdk/eclipse-adt.jd b/docs/html/sdk/eclipse-adt.jd
index 333efa2..dab5b29 100644
--- a/docs/html/sdk/eclipse-adt.jd
+++ b/docs/html/sdk/eclipse-adt.jd
@@ -1,8 +1,8 @@
 page.title=ADT Plugin for Eclipse
 adt.zip.version=14.0.0
 adt.zip.download=ADT-14.0.0.zip
-adt.zip.bytes=6745584
-adt.zip.checksum=a645330d90fd9dae6187662bb1c3c644
+adt.zip.bytes=6745047
+adt.zip.checksum=014312e1553e3b8da55cb6a24e33e432
 
 @jd:body
 
diff --git a/docs/html/sdk/index.jd b/docs/html/sdk/index.jd
index 065f41b..67be5c9 100644
--- a/docs/html/sdk/index.jd
+++ b/docs/html/sdk/index.jd
@@ -2,20 +2,20 @@
 sdk.redirect=0
 
 sdk.win_installer=installer_r14-windows.exe
-sdk.win_installer_bytes=33860145
-sdk.win_installer_checksum=7a563491bf4671d09b9da0dcde85f212
+sdk.win_installer_bytes=33860326
+sdk.win_installer_checksum=6d4f76385daaee766ad901699cdae6cc
 
 sdk.win_download=android-sdk_r14-windows.zip
-sdk.win_bytes=33852972
-sdk.win_checksum=d1381a0cc8e6f9358174aa6d051ba379
+sdk.win_bytes=33853090
+sdk.win_checksum=0c39628e296d6176ed928cc64498ba04
 
 sdk.mac_download=android-sdk_r14-macosx.zip
-sdk.mac_bytes=30426052
-sdk.mac_checksum=df0a5c5b5327ffcaf256ce735998e12a
+sdk.mac_bytes=30426431
+sdk.mac_checksum=189ce3e26dfb46298a7def21d3bdf271
 
 sdk.linux_download=android-sdk_r14-linux.tgz
-sdk.linux_bytes=26083315
-sdk.linux_checksum=2049d5c1a164fcae47a5e93c52200752
+sdk.linux_bytes=26082867
+sdk.linux_checksum=500483f8acd0d3cae94c68c3dcefbb98
 
 @jd:body
 
diff --git a/docs/html/sdk/tools-notes.jd b/docs/html/sdk/tools-notes.jd
index 2d044ed..6cb246c 100644
--- a/docs/html/sdk/tools-notes.jd
+++ b/docs/html/sdk/tools-notes.jd
@@ -66,7 +66,12 @@
   <a href="#" onclick="return toggleDiv(this)">
     <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px"
     width="9px" />SDK Tools, Revision 14</a> <em>(October 2011)</em>
+
   <div class="toggleme">
+    <p class="note"><strong>Important:</strong> To download the new Android
+    4.0 system components from the Android SDK Manager, you must first update the
+    SDK tools to revision 14 and restart the Android SDK Manager. If you do not,
+    the Android 4.0 system components will not be available for download.</p>
   <dl>
 <dt>Dependencies:</dt>
 <dd>
@@ -81,6 +86,9 @@
 <dt>General notes:</dt>
 <dd>
   <ul>
+    <li>Added webcam support to Android 4.0 or later platforms to emulate rear-facing cameras when one webcam is present,
+    and to emulate both rear-facing and front-facing cameras when two webcams are present. Webcam suport is for Windows and Linux only.
+    Mac support will come in a later release.</li>
      <li>Changed <code>default.properties</code> to <code>project.properties</code> and
     <code>build.properties</code> to <code>ant.properties</code>. Any existing
     projects that you build with Ant must be updated with the <code>android update project</code>
@@ -90,7 +98,6 @@
 commands, see the
 <a href="{@docRoot}guide/developing/building/building-cmdline.html#AntReference">Ant Command
 Reference</a>.</li>
-
     <li>Changed how library projects are built.</a></li>
     <li>Improved incremental builds, so that resource compilation runs less frequently. Builds no
     longer run when you edit strings or layouts (unless you add a new <code>id</code>) and no longer
