diff --git a/background/JobScheduler/Application/src/main/AndroidManifest.xml b/background/JobScheduler/Application/src/main/AndroidManifest.xml
index 9478609..06a927b 100644
--- a/background/JobScheduler/Application/src/main/AndroidManifest.xml
+++ b/background/JobScheduler/Application/src/main/AndroidManifest.xml
@@ -18,9 +18,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.example.android.jobscheduler" >
 
-    <uses-sdk
-        android:minSdkVersion="18"
-        android:targetSdkVersion="21" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
diff --git a/background/JobScheduler/Application/tests/AndroidManifest.xml b/background/JobScheduler/Application/tests/AndroidManifest.xml
index 2a9d92d..bb06508 100644
--- a/background/JobScheduler/Application/tests/AndroidManifest.xml
+++ b/background/JobScheduler/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="L" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/connectivity/bluetooth/BluetoothChat/Application/src/main/AndroidManifest.xml b/connectivity/bluetooth/BluetoothChat/Application/src/main/AndroidManifest.xml
index 99b9b12..53dc5ab 100644
--- a/connectivity/bluetooth/BluetoothChat/Application/src/main/AndroidManifest.xml
+++ b/connectivity/bluetooth/BluetoothChat/Application/src/main/AndroidManifest.xml
@@ -21,9 +21,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="11"
-        android:targetSdkVersion="17"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
     <uses-permission android:name="android.permission.BLUETOOTH"/>
diff --git a/connectivity/network/BasicNetworking/Application/tests/AndroidManifest.xml b/connectivity/network/BasicNetworking/Application/tests/AndroidManifest.xml
index 293c16b..327ae46 100644
--- a/connectivity/network/BasicNetworking/Application/tests/AndroidManifest.xml
+++ b/connectivity/network/BasicNetworking/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/connectivity/network/NetworkConnect/Application/tests/AndroidManifest.xml b/connectivity/network/NetworkConnect/Application/tests/AndroidManifest.xml
index 80fec80..2aaee3f 100644
--- a/connectivity/network/NetworkConnect/Application/tests/AndroidManifest.xml
+++ b/connectivity/network/NetworkConnect/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/connectivity/nfc/BeamLargeFiles/Application/tests/AndroidManifest.xml b/connectivity/nfc/BeamLargeFiles/Application/tests/AndroidManifest.xml
index 87b785f..a046afc 100644
--- a/connectivity/nfc/BeamLargeFiles/Application/tests/AndroidManifest.xml
+++ b/connectivity/nfc/BeamLargeFiles/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/connectivity/nfc/CardEmulation/Application/tests/AndroidManifest.xml b/connectivity/nfc/CardEmulation/Application/tests/AndroidManifest.xml
index 447d041..d1ec341 100644
--- a/connectivity/nfc/CardEmulation/Application/tests/AndroidManifest.xml
+++ b/connectivity/nfc/CardEmulation/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="19"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/connectivity/nfc/CardReader/Application/tests/AndroidManifest.xml b/connectivity/nfc/CardReader/Application/tests/AndroidManifest.xml
index 1098859..fd702fc 100644
--- a/connectivity/nfc/CardReader/Application/tests/AndroidManifest.xml
+++ b/connectivity/nfc/CardReader/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="19"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/connectivity/sync/BasicSyncAdapter/Application/src/main/AndroidManifest.xml b/connectivity/sync/BasicSyncAdapter/Application/src/main/AndroidManifest.xml
index dd59b06..4222b47 100644
--- a/connectivity/sync/BasicSyncAdapter/Application/src/main/AndroidManifest.xml
+++ b/connectivity/sync/BasicSyncAdapter/Application/src/main/AndroidManifest.xml
@@ -23,9 +23,7 @@
     android:versionName="1.0">
 
     <!-- SyncAdapters are available in API 5 and above. We use API 7 as a baseline for samples. -->
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- Required for fetching feed data. -->
     <uses-permission android:name="android.permission.INTERNET"/>
diff --git a/connectivity/sync/BasicSyncAdapter/Application/tests/AndroidManifest.xml b/connectivity/sync/BasicSyncAdapter/Application/tests/AndroidManifest.xml
index 44c910a..4422a8e 100644
--- a/connectivity/sync/BasicSyncAdapter/Application/tests/AndroidManifest.xml
+++ b/connectivity/sync/BasicSyncAdapter/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/content/LoaderCursor/AndroidManifest.xml b/content/LoaderCursor/AndroidManifest.xml
index 2305045..9dbf260 100644
--- a/content/LoaderCursor/AndroidManifest.xml
+++ b/content/LoaderCursor/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="14"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
     <uses-permission android:name="android.permission.READ_CONTACTS"/>
 
     <application
diff --git a/content/contacts/BasicContactables/Application/src/main/AndroidManifest.xml b/content/contacts/BasicContactables/Application/src/main/AndroidManifest.xml
index 62b9812..079db23 100644
--- a/content/contacts/BasicContactables/Application/src/main/AndroidManifest.xml
+++ b/content/contacts/BasicContactables/Application/src/main/AndroidManifest.xml
@@ -23,9 +23,7 @@
     <!-- BEGIN_INCLUDE(contacts_permission) -->
     <uses-permission android:name="android.permission.READ_CONTACTS"/>
     <!-- END_INCLUDE(contacts_permission) -->
-    <uses-sdk
-        android:minSdkVersion="18"
-        android:targetSdkVersion="18" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
     <permission android:name="android"></permission>
 
     <application
diff --git a/content/contacts/BasicContactables/Application/tests/AndroidManifest.xml b/content/contacts/BasicContactables/Application/tests/AndroidManifest.xml
index 8c4af25..f8326f0 100644
--- a/content/contacts/BasicContactables/Application/tests/AndroidManifest.xml
+++ b/content/contacts/BasicContactables/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/content/documentsUi/StorageClient/Application/tests/AndroidManifest.xml b/content/documentsUi/StorageClient/Application/tests/AndroidManifest.xml
index 3f0a38f..ffcac1d 100644
--- a/content/documentsUi/StorageClient/Application/tests/AndroidManifest.xml
+++ b/content/documentsUi/StorageClient/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="19"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/content/documentsUi/StorageProvider/Application/src/main/AndroidManifest.xml b/content/documentsUi/StorageProvider/Application/src/main/AndroidManifest.xml
index e4704dc..53e7819 100644
--- a/content/documentsUi/StorageProvider/Application/src/main/AndroidManifest.xml
+++ b/content/documentsUi/StorageProvider/Application/src/main/AndroidManifest.xml
@@ -21,9 +21,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="19"
-        android:targetSdkVersion="19"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
diff --git a/input/gestures/BasicGestureDetect/Application/tests/AndroidManifest.xml b/input/gestures/BasicGestureDetect/Application/tests/AndroidManifest.xml
index 3c5487c..7014df0 100644
--- a/input/gestures/BasicGestureDetect/Application/tests/AndroidManifest.xml
+++ b/input/gestures/BasicGestureDetect/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/input/multitouch/BasicMultitouch/Application/src/main/AndroidManifest.xml b/input/multitouch/BasicMultitouch/Application/src/main/AndroidManifest.xml
index 043345c..fc11177 100644
--- a/input/multitouch/BasicMultitouch/Application/src/main/AndroidManifest.xml
+++ b/input/multitouch/BasicMultitouch/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/media/BasicMediaRouter/Application/src/main/AndroidManifest.xml b/media/BasicMediaRouter/Application/src/main/AndroidManifest.xml
index 33c20d5..f84b7df 100644
--- a/media/BasicMediaRouter/Application/src/main/AndroidManifest.xml
+++ b/media/BasicMediaRouter/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="17"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/media/BasicMediaRouter/Application/tests/AndroidManifest.xml b/media/BasicMediaRouter/Application/tests/AndroidManifest.xml
index 8800232..927504e 100644
--- a/media/BasicMediaRouter/Application/tests/AndroidManifest.xml
+++ b/media/BasicMediaRouter/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/media/Camera2Basic/Application/tests/AndroidManifest.xml b/media/Camera2Basic/Application/tests/AndroidManifest.xml
index 7196a85..8b29c81 100644
--- a/media/Camera2Basic/Application/tests/AndroidManifest.xml
+++ b/media/Camera2Basic/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/media/MediaEffects/MediaEffectsSample/src/main/AndroidManifest.xml b/media/MediaEffects/MediaEffectsSample/src/main/AndroidManifest.xml
index 6688b4c..556f3c1 100644
--- a/media/MediaEffects/MediaEffectsSample/src/main/AndroidManifest.xml
+++ b/media/MediaEffects/MediaEffectsSample/src/main/AndroidManifest.xml
@@ -21,9 +21,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="14"
-        android:targetSdkVersion="19"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/media/MediaRecorder/Application/src/main/AndroidManifest.xml b/media/MediaRecorder/Application/src/main/AndroidManifest.xml
index 32f88f6..539dc2c 100644
--- a/media/MediaRecorder/Application/src/main/AndroidManifest.xml
+++ b/media/MediaRecorder/Application/src/main/AndroidManifest.xml
@@ -22,9 +22,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="14"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- This app records A/V content from camera and stores it to disk -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
diff --git a/media/MediaRouter/Application/tests/AndroidManifest.xml b/media/MediaRouter/Application/tests/AndroidManifest.xml
index f60a1d7..0f9258a 100644
--- a/media/MediaRouter/Application/tests/AndroidManifest.xml
+++ b/media/MediaRouter/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/renderScript/BasicRenderScript/Application/AndroidManifest.xml b/renderScript/BasicRenderScript/Application/AndroidManifest.xml
index 1e35dc3..21c3a62 100644
--- a/renderScript/BasicRenderScript/Application/AndroidManifest.xml
+++ b/renderScript/BasicRenderScript/Application/AndroidManifest.xml
@@ -4,9 +4,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml b/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml
index e1e2dfc..3bc65ff 100644
--- a/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml
+++ b/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml b/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml
index 02a8db3..34eca02 100644
--- a/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml
+++ b/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="8"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/renderScript/RenderScriptIntrinsic/Application/src/main/AndroidManifest.xml b/renderScript/RenderScriptIntrinsic/Application/src/main/AndroidManifest.xml
index 566ef8a..e108aff 100644
--- a/renderScript/RenderScriptIntrinsic/Application/src/main/AndroidManifest.xml
+++ b/renderScript/RenderScriptIntrinsic/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/renderScript/RenderScriptIntrinsic/Application/tests/AndroidManifest.xml b/renderScript/RenderScriptIntrinsic/Application/tests/AndroidManifest.xml
index 96fa207..72f0969 100644
--- a/renderScript/RenderScriptIntrinsic/Application/tests/AndroidManifest.xml
+++ b/renderScript/RenderScriptIntrinsic/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="8"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/security/keystore/BasicAndroidKeyStore/Application/tests/AndroidManifest.xml b/security/keystore/BasicAndroidKeyStore/Application/tests/AndroidManifest.xml
index eb8b7b8..3ebff98 100644
--- a/security/keystore/BasicAndroidKeyStore/Application/tests/AndroidManifest.xml
+++ b/security/keystore/BasicAndroidKeyStore/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/testing/ActivityInstrumentation/Application/tests/AndroidManifest.xml b/testing/ActivityInstrumentation/Application/tests/AndroidManifest.xml
index ad20a2a..4c24a6f 100644
--- a/testing/ActivityInstrumentation/Application/tests/AndroidManifest.xml
+++ b/testing/ActivityInstrumentation/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/Interpolator/Application/tests/AndroidManifest.xml b/ui/Interpolator/Application/tests/AndroidManifest.xml
index 702e29a..5e43ab9 100644
--- a/ui/Interpolator/Application/tests/AndroidManifest.xml
+++ b/ui/Interpolator/Application/tests/AndroidManifest.xml
@@ -21,9 +21,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="android-L"
-            android:targetSdkVersion="android-L" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/accessibility/BasicAccessibility/Application/src/main/AndroidManifest.xml b/ui/accessibility/BasicAccessibility/Application/src/main/AndroidManifest.xml
index d61d789..281114d 100644
--- a/ui/accessibility/BasicAccessibility/Application/src/main/AndroidManifest.xml
+++ b/ui/accessibility/BasicAccessibility/Application/src/main/AndroidManifest.xml
@@ -22,9 +22,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="11"
-        android:targetSdkVersion="16" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/accessibility/BasicAccessibility/Application/tests/AndroidManifest.xml b/ui/accessibility/BasicAccessibility/Application/tests/AndroidManifest.xml
index 8dc47be..e7c7840 100644
--- a/ui/accessibility/BasicAccessibility/Application/tests/AndroidManifest.xml
+++ b/ui/accessibility/BasicAccessibility/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/actionbar/DoneBar/Application/tests/AndroidManifest.xml b/ui/actionbar/DoneBar/Application/tests/AndroidManifest.xml
index 40eb5e1..6e910c7 100644
--- a/ui/actionbar/DoneBar/Application/tests/AndroidManifest.xml
+++ b/ui/actionbar/DoneBar/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/actionbarcompat/ActionBarCompat-Basic/Application/src/main/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-Basic/Application/src/main/AndroidManifest.xml
index 332c055..2e19220 100644
--- a/ui/actionbarcompat/ActionBarCompat-Basic/Application/src/main/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-Basic/Application/src/main/AndroidManifest.xml
@@ -21,9 +21,7 @@
     android:versionName="1.0">
 
     <!-- ActionBarCompat provides an Action Bar from API v7 onwards -->
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:icon="@drawable/ic_launcher"
diff --git a/ui/actionbarcompat/ActionBarCompat-Basic/Application/tests/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-Basic/Application/tests/AndroidManifest.xml
index a2f7cfc..b73eb7f 100644
--- a/ui/actionbarcompat/ActionBarCompat-Basic/Application/tests/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-Basic/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/src/main/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/src/main/AndroidManifest.xml
index 114053e..695d4e0 100644
--- a/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/src/main/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/src/main/AndroidManifest.xml
@@ -21,9 +21,7 @@
     android:versionName="1.0">
 
     <!-- ActionBarCompat provides an implementation of Popup Menu from API v7 onwards -->
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:icon="@drawable/ic_launcher"
diff --git a/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/tests/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/tests/AndroidManifest.xml
index d23ab10..955a51a 100644
--- a/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/tests/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-ListPopupMenu/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/src/main/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/src/main/AndroidManifest.xml
index 800118c..5ee7466 100644
--- a/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/src/main/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/src/main/AndroidManifest.xml
@@ -25,9 +25,7 @@
     <!--
         ActionBarCompat provides an Action Bar from API v7 onwards
     -->
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:icon="@drawable/ic_launcher"
diff --git a/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/tests/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/tests/AndroidManifest.xml
index d4a31c9..979b955 100644
--- a/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/tests/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-ListViewModalSelect/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/actionbarcompat/ActionBarCompat-SearchView/src/main/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-SearchView/src/main/AndroidManifest.xml
index b2554d6..30e4e97 100644
--- a/ui/actionbarcompat/ActionBarCompat-SearchView/src/main/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-SearchView/src/main/AndroidManifest.xml
@@ -23,9 +23,7 @@
         ActionBarCompat provides an Action Bar with compatible SearchView
         from API v7 onwards
     -->
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:icon="@drawable/ic_launcher"
diff --git a/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/src/main/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/src/main/AndroidManifest.xml
index be1ed49..18dfc27 100644
--- a/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/src/main/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/src/main/AndroidManifest.xml
@@ -23,9 +23,7 @@
     <!--
         ActionBarCompat provides an Action Bar from API v7 onwards
     -->
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:icon="@drawable/ic_launcher"
diff --git a/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/tests/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/tests/AndroidManifest.xml
index c52949c..e750ac3 100644
--- a/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/tests/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-ShareActionProvider/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/actionbarcompat/ActionBarCompat-Styled/Application/src/main/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-Styled/Application/src/main/AndroidManifest.xml
index 06394c7..b9d266c 100644
--- a/ui/actionbarcompat/ActionBarCompat-Styled/Application/src/main/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-Styled/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="7"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!--
         Theme is set on the application so that our custom theme is used by
diff --git a/ui/actionbarcompat/ActionBarCompat-Styled/Application/tests/AndroidManifest.xml b/ui/actionbarcompat/ActionBarCompat-Styled/Application/tests/AndroidManifest.xml
index a990607..bf2fab4 100644
--- a/ui/actionbarcompat/ActionBarCompat-Styled/Application/tests/AndroidManifest.xml
+++ b/ui/actionbarcompat/ActionBarCompat-Styled/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/activityscenetransition/ActivitySceneTransitionBasic/Application/tests/AndroidManifest.xml b/ui/activityscenetransition/ActivitySceneTransitionBasic/Application/tests/AndroidManifest.xml
index 99605ee..65521e6 100644
--- a/ui/activityscenetransition/ActivitySceneTransitionBasic/Application/tests/AndroidManifest.xml
+++ b/ui/activityscenetransition/ActivitySceneTransitionBasic/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/activitytasks/DocumentCentricRelinquishIdentity/DocumentCentricRelinquishIdentitySample/src/main/AndroidManifest.xml b/ui/activitytasks/DocumentCentricRelinquishIdentity/DocumentCentricRelinquishIdentitySample/src/main/AndroidManifest.xml
index 9276d5c..00cfd13 100644
--- a/ui/activitytasks/DocumentCentricRelinquishIdentity/DocumentCentricRelinquishIdentitySample/src/main/AndroidManifest.xml
+++ b/ui/activitytasks/DocumentCentricRelinquishIdentity/DocumentCentricRelinquishIdentitySample/src/main/AndroidManifest.xml
@@ -21,9 +21,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="android-L"
-        android:targetSdkVersion="android-L" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/graphics/DisplayingBitmaps/Application/tests/AndroidManifest.xml b/ui/graphics/DisplayingBitmaps/Application/tests/AndroidManifest.xml
index 4ddcbbb..a93e21f 100644
--- a/ui/graphics/DisplayingBitmaps/Application/tests/AndroidManifest.xml
+++ b/ui/graphics/DisplayingBitmaps/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/graphics/PdfRendererBasic/Application/tests/AndroidManifest.xml b/ui/graphics/PdfRendererBasic/Application/tests/AndroidManifest.xml
index 35ff2a6..54829c7 100644
--- a/ui/graphics/PdfRendererBasic/Application/tests/AndroidManifest.xml
+++ b/ui/graphics/PdfRendererBasic/Application/tests/AndroidManifest.xml
@@ -21,9 +21,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="L"
-        android:targetSdkVersion="L"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/notifications/BasicNotifications/Application/src/main/AndroidManifest.xml b/ui/notifications/BasicNotifications/Application/src/main/AndroidManifest.xml
index 1e37d0b..01f8e3a 100644
--- a/ui/notifications/BasicNotifications/Application/src/main/AndroidManifest.xml
+++ b/ui/notifications/BasicNotifications/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="17"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/notifications/BasicNotifications/Application/tests/AndroidManifest.xml b/ui/notifications/BasicNotifications/Application/tests/AndroidManifest.xml
index 62c01e8..5b25bbe 100644
--- a/ui/notifications/BasicNotifications/Application/tests/AndroidManifest.xml
+++ b/ui/notifications/BasicNotifications/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/notifications/CustomNotifications/Application/src/main/AndroidManifest.xml b/ui/notifications/CustomNotifications/Application/src/main/AndroidManifest.xml
index b20a411..3054ad7 100644
--- a/ui/notifications/CustomNotifications/Application/src/main/AndroidManifest.xml
+++ b/ui/notifications/CustomNotifications/Application/src/main/AndroidManifest.xml
@@ -22,9 +22,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="4"
-        android:targetSdkVersion="18" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/notifications/LNotifications/Application/tests/AndroidManifest.xml b/ui/notifications/LNotifications/Application/tests/AndroidManifest.xml
index 84f916f..46a65af 100644
--- a/ui/notifications/LNotifications/Application/tests/AndroidManifest.xml
+++ b/ui/notifications/LNotifications/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/transition/AdapterTransition/Application/src/main/AndroidManifest.xml b/ui/transition/AdapterTransition/Application/src/main/AndroidManifest.xml
index 01b414d..a998a4c 100644
--- a/ui/transition/AdapterTransition/Application/src/main/AndroidManifest.xml
+++ b/ui/transition/AdapterTransition/Application/src/main/AndroidManifest.xml
@@ -19,9 +19,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="19"
-        android:targetSdkVersion="19"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/views/CardView/Application/tests/AndroidManifest.xml b/ui/views/CardView/Application/tests/AndroidManifest.xml
index 01338c3..92cfd40 100644
--- a/ui/views/CardView/Application/tests/AndroidManifest.xml
+++ b/ui/views/CardView/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19"/>
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/Clipping/ClippingBasic/Application/tests/AndroidManifest.xml b/ui/views/Clipping/ClippingBasic/Application/tests/AndroidManifest.xml
index ea04c40..28aa52a 100644
--- a/ui/views/Clipping/ClippingBasic/Application/tests/AndroidManifest.xml
+++ b/ui/views/Clipping/ClippingBasic/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/Elevation/ElevationBasic/Application/tests/AndroidManifest.xml b/ui/views/Elevation/ElevationBasic/Application/tests/AndroidManifest.xml
index 84b80b1..800c0ba 100644
--- a/ui/views/Elevation/ElevationBasic/Application/tests/AndroidManifest.xml
+++ b/ui/views/Elevation/ElevationBasic/Application/tests/AndroidManifest.xml
@@ -21,9 +21,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="19"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/Elevation/ElevationDrag/Application/tests/AndroidManifest.xml b/ui/views/Elevation/ElevationDrag/Application/tests/AndroidManifest.xml
index e69afec..60c9a19 100644
--- a/ui/views/Elevation/ElevationDrag/Application/tests/AndroidManifest.xml
+++ b/ui/views/Elevation/ElevationDrag/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/FloatingActionButton/FloatingActionButtonBasic/Application/tests/AndroidManifest.xml b/ui/views/FloatingActionButton/FloatingActionButtonBasic/Application/tests/AndroidManifest.xml
index fa93608..4cace0e 100644
--- a/ui/views/FloatingActionButton/FloatingActionButtonBasic/Application/tests/AndroidManifest.xml
+++ b/ui/views/FloatingActionButton/FloatingActionButtonBasic/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/HorizontalPaging/Application/src/main/AndroidManifest.xml b/ui/views/HorizontalPaging/Application/src/main/AndroidManifest.xml
index 33b9e15..1f6fdd2 100644
--- a/ui/views/HorizontalPaging/Application/src/main/AndroidManifest.xml
+++ b/ui/views/HorizontalPaging/Application/src/main/AndroidManifest.xml
@@ -22,9 +22,7 @@
 
     <!-- While ViewPager will work on API 4 or above, tabs require an ActionBar. ActionBar is only
          available in API 11 or above. -->
-    <uses-sdk
-        android:minSdkVersion="11"
-        android:targetSdkVersion="16" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/views/HorizontalPaging/Application/tests/AndroidManifest.xml b/ui/views/HorizontalPaging/Application/tests/AndroidManifest.xml
index 3f35ede..a8e7be5 100644
--- a/ui/views/HorizontalPaging/Application/tests/AndroidManifest.xml
+++ b/ui/views/HorizontalPaging/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/NavigationDrawer/Application/src/main/AndroidManifest.xml b/ui/views/NavigationDrawer/Application/src/main/AndroidManifest.xml
index 1a9931f..ab2e141 100644
--- a/ui/views/NavigationDrawer/Application/src/main/AndroidManifest.xml
+++ b/ui/views/NavigationDrawer/Application/src/main/AndroidManifest.xml
@@ -19,9 +19,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="14"
-        android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/views/NavigationDrawer/Application/tests/AndroidManifest.xml b/ui/views/NavigationDrawer/Application/tests/AndroidManifest.xml
index 62ab13a..6a651a5 100644
--- a/ui/views/NavigationDrawer/Application/tests/AndroidManifest.xml
+++ b/ui/views/NavigationDrawer/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/RevealEffect/RevealEffectBasic/Application/tests/AndroidManifest.xml b/ui/views/RevealEffect/RevealEffectBasic/Application/tests/AndroidManifest.xml
index 3a1bb88..a0d25c1 100644
--- a/ui/views/RevealEffect/RevealEffectBasic/Application/tests/AndroidManifest.xml
+++ b/ui/views/RevealEffect/RevealEffectBasic/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/SlidingTabs/SlidingTabsBasic/Application/tests/AndroidManifest.xml b/ui/views/SlidingTabs/SlidingTabsBasic/Application/tests/AndroidManifest.xml
index 8d8fa2b..3b7394c 100644
--- a/ui/views/SlidingTabs/SlidingTabsBasic/Application/tests/AndroidManifest.xml
+++ b/ui/views/SlidingTabs/SlidingTabsBasic/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="4"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/SlidingTabs/SlidingTabsColors/Application/tests/AndroidManifest.xml b/ui/views/SlidingTabs/SlidingTabsColors/Application/tests/AndroidManifest.xml
index f9fcf3e..b018f6c 100644
--- a/ui/views/SlidingTabs/SlidingTabsColors/Application/tests/AndroidManifest.xml
+++ b/ui/views/SlidingTabs/SlidingTabsColors/Application/tests/AndroidManifest.xml
@@ -21,9 +21,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="4"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/SwipeRefreshLayout/SwipeRefreshLayoutBasic/Application/tests/AndroidManifest.xml b/ui/views/SwipeRefreshLayout/SwipeRefreshLayoutBasic/Application/tests/AndroidManifest.xml
index 0da53b7..9455da6 100644
--- a/ui/views/SwipeRefreshLayout/SwipeRefreshLayoutBasic/Application/tests/AndroidManifest.xml
+++ b/ui/views/SwipeRefreshLayout/SwipeRefreshLayoutBasic/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/SwipeRefreshLayout/SwipeRefreshListFragment/Application/tests/AndroidManifest.xml b/ui/views/SwipeRefreshLayout/SwipeRefreshListFragment/Application/tests/AndroidManifest.xml
index a1f8f9b..8326b36 100644
--- a/ui/views/SwipeRefreshLayout/SwipeRefreshListFragment/Application/tests/AndroidManifest.xml
+++ b/ui/views/SwipeRefreshLayout/SwipeRefreshListFragment/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/SwipeRefreshLayout/SwipeRefreshMultipleViews/Application/tests/AndroidManifest.xml b/ui/views/SwipeRefreshLayout/SwipeRefreshMultipleViews/Application/tests/AndroidManifest.xml
index 8c9b277..dea1d96 100644
--- a/ui/views/SwipeRefreshLayout/SwipeRefreshMultipleViews/Application/tests/AndroidManifest.xml
+++ b/ui/views/SwipeRefreshLayout/SwipeRefreshMultipleViews/Application/tests/AndroidManifest.xml
@@ -39,9 +39,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/views/TextSwitcher/Application/src/main/AndroidManifest.xml b/ui/views/TextSwitcher/Application/src/main/AndroidManifest.xml
index 7f512a3..70884cd 100644
--- a/ui/views/TextSwitcher/Application/src/main/AndroidManifest.xml
+++ b/ui/views/TextSwitcher/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="4"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/ui/window/AdvancedImmersiveMode/Application/tests/AndroidManifest.xml b/ui/window/AdvancedImmersiveMode/Application/tests/AndroidManifest.xml
index 7117969..bb8c97e 100644
--- a/ui/window/AdvancedImmersiveMode/Application/tests/AndroidManifest.xml
+++ b/ui/window/AdvancedImmersiveMode/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="19"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/window/BasicImmersiveMode/Application/tests/AndroidManifest.xml b/ui/window/BasicImmersiveMode/Application/tests/AndroidManifest.xml
index 070368c..844c34d 100644
--- a/ui/window/BasicImmersiveMode/Application/tests/AndroidManifest.xml
+++ b/ui/window/BasicImmersiveMode/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="19"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/ui/window/ImmersiveMode/Application/tests/AndroidManifest.xml b/ui/window/ImmersiveMode/Application/tests/AndroidManifest.xml
index b090189..9125fed 100644
--- a/ui/window/ImmersiveMode/Application/tests/AndroidManifest.xml
+++ b/ui/window/ImmersiveMode/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/views/TextLinkify/Application/src/main/AndroidManifest.xml b/views/TextLinkify/Application/src/main/AndroidManifest.xml
index 49b4eae..eb55f20 100644
--- a/views/TextLinkify/Application/src/main/AndroidManifest.xml
+++ b/views/TextLinkify/Application/src/main/AndroidManifest.xml
@@ -22,9 +22,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="4"
-        android:targetSdkVersion="17" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/views/TextLinkify/Application/tests/AndroidManifest.xml b/views/TextLinkify/Application/tests/AndroidManifest.xml
index e368f05..9a4dd16 100644
--- a/views/TextLinkify/Application/tests/AndroidManifest.xml
+++ b/views/TextLinkify/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
diff --git a/wearable/wear/SynchronizedNotifications/Application/tests/AndroidManifest.xml b/wearable/wear/SynchronizedNotifications/Application/tests/AndroidManifest.xml
index 559ee23..5f8d223 100644
--- a/wearable/wear/SynchronizedNotifications/Application/tests/AndroidManifest.xml
+++ b/wearable/wear/SynchronizedNotifications/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="18"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
