diff --git a/apps/Development/Android.mk b/apps/Development/Android.mk
index 8c0f705..99133e8 100644
--- a/apps/Development/Android.mk
+++ b/apps/Development/Android.mk
@@ -3,7 +3,7 @@
 
 LOCAL_MODULE_TAGS := eng
 
-LOCAL_JAVA_LIBRARIES := android.test.runner telephony-common
+LOCAL_JAVA_LIBRARIES := android.test.runner telephony-common org.apache.http.legacy
 
 LOCAL_SRC_FILES := $(call all-subdir-java-files) \
                 src/com/android/development/IRemoteService.aidl \
diff --git a/apps/Development/AndroidManifest.xml b/apps/Development/AndroidManifest.xml
index 5847201..3ac8190 100644
--- a/apps/Development/AndroidManifest.xml
+++ b/apps/Development/AndroidManifest.xml
@@ -47,6 +47,7 @@
 
     <application android:label="Dev Tools"
             android:icon="@mipmap/ic_launcher_devtools">
+        <uses-library android:name="org.apache.http.legacy" android:required="false" />
 
         <uses-library android:name="android.test.runner" />
 
diff --git a/apps/Development/res/layout/connectivity.xml b/apps/Development/res/layout/connectivity.xml
index d23a6b1..00ba508 100644
--- a/apps/Development/res/layout/connectivity.xml
+++ b/apps/Development/res/layout/connectivity.xml
@@ -350,6 +350,33 @@
           android:layout_height="wrap_content"
           android:text="@string/routed_socket_request" />
     </LinearLayout>
+
+    <!-- divider line -->
+    <View android:background="#FFFFFFFF"
+        android:layout_width="match_parent"
+        android:layout_height="3dip" />
+    <LinearLayout
+        android:orientation="horizontal"
+        android:paddingTop="4dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+        <Button android:id="@+id/link_stats"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/link_stats" />
+    </LinearLayout>
+
+    <LinearLayout
+        android:orientation="horizontal"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+        <TextView
+            android:id="@+id/stats"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/stats_results" />
+    </LinearLayout>
+
   </LinearLayout>
 </ScrollView>
 
diff --git a/apps/Development/res/values/strings.xml b/apps/Development/res/values/strings.xml
index d670cf4..3ef8845 100644
--- a/apps/Development/res/values/strings.xml
+++ b/apps/Development/res/values/strings.xml
@@ -33,6 +33,8 @@
     <string name="start_scan">Start Scan</string>
     <string name="scan_cycles">Scan Cycles: </string>
     <string name="disconnect">Disconnect</string>
+    <string name="link_stats">Link Stats</string>
+    <string name="stats_results"> results </string>
 
     <string name="start_tdls">Start TDLS</string>
     <string name="stop_tdls">Stop TDLS</string>
diff --git a/apps/Development/src/com/android/development/Connectivity.java b/apps/Development/src/com/android/development/Connectivity.java
index a576eb3..5ff72ad 100644
--- a/apps/Development/src/com/android/development/Connectivity.java
+++ b/apps/Development/src/com/android/development/Connectivity.java
@@ -33,6 +33,7 @@
 import android.net.NetworkUtils;
 import android.net.RouteInfo;
 import android.net.wifi.ScanResult;
+import android.net.wifi.WifiActivityEnergyInfo;
 import android.net.wifi.WifiManager;
 import android.os.RemoteException;
 import android.os.Handler;
@@ -119,6 +120,8 @@
     private long mTotalScanTime = 0;
     private long mTotalScanCount = 0;
 
+    private TextView mLinkStatsResults;
+
     private String mTdlsAddr = null;
 
     private WifiManager mWm;
@@ -316,8 +319,12 @@
         findViewById(R.id.routed_socket_request).setOnClickListener(mClickListener);
         findViewById(R.id.default_request).setOnClickListener(mClickListener);
         findViewById(R.id.default_socket).setOnClickListener(mClickListener);
+        findViewById(R.id.link_stats).setOnClickListener(mClickListener);
 
         registerReceiver(mReceiver, new IntentFilter(CONNECTIVITY_TEST_ALARM));
+
+        mLinkStatsResults = (TextView)findViewById(R.id.stats);
+        mLinkStatsResults.setVisibility(View.VISIBLE);
     }
 
     @Override
@@ -408,6 +415,9 @@
                     mCm.stopUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE,
                             Phone.FEATURE_ENABLE_HIPRI);
                     break;
+                case R.id.link_stats:
+                    onLinkStats();
+                    break;
             }
         }
     };
@@ -544,6 +554,22 @@
         }
     }
 
+    private void onLinkStats() {
+        Log.e(TAG, "LINK STATS:  ");
+        try {
+            WifiActivityEnergyInfo info =
+                    mWm.getControllerActivityEnergyInfo(0);
+            if (info != null) {
+                mLinkStatsResults.setText(" power " + info.toString());
+            } else {
+                mLinkStatsResults.setText(" null! ");
+            }
+        } catch (Exception e) {
+            mLinkStatsResults.setText(" failed! " + e.toString());
+        }
+    }
+
+
     private void onAddDefaultRoute() {
         try {
             int netId = Integer.valueOf(((TextView) findViewById(R.id.netid)).getText().toString());
diff --git a/apps/Fallback/res/values-en-rAU/strings.xml b/apps/Fallback/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..a7c82cb
--- /dev/null
+++ b/apps/Fallback/res/values-en-rAU/strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2007 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+  
+          http://www.apache.org/licenses/LICENSE-2.0
+  
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="appTitle" msgid="161410001913116606">"Fallback"</string>
+    <string name="title" msgid="8156274565006125136">"Unsupported action"</string>
+    <string name="error" msgid="6539615832923362301">"That action is not currently supported."</string>
+</resources>
diff --git a/apps/Fallback/res/values-gu-rIN/strings.xml b/apps/Fallback/res/values-gu-rIN/strings.xml
new file mode 100644
index 0000000..486a94f
--- /dev/null
+++ b/apps/Fallback/res/values-gu-rIN/strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2007 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+  
+          http://www.apache.org/licenses/LICENSE-2.0
+  
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="appTitle" msgid="161410001913116606">"Fallback"</string>
+    <string name="title" msgid="8156274565006125136">"અસમર્થિત ક્રિયા"</string>
+    <string name="error" msgid="6539615832923362301">"તે ક્રિયા વર્તમાનમાં સમર્થિત નથી."</string>
+</resources>
diff --git a/apps/Fallback/res/values-pa-rIN/strings.xml b/apps/Fallback/res/values-pa-rIN/strings.xml
new file mode 100644
index 0000000..d358b1e
--- /dev/null
+++ b/apps/Fallback/res/values-pa-rIN/strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2007 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+  
+          http://www.apache.org/licenses/LICENSE-2.0
+  
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="appTitle" msgid="161410001913116606">"ਪਿੱਛੇ ਜਾਓ"</string>
+    <string name="title" msgid="8156274565006125136">"ਅਸਮਰਥਿਤ ਕਿਰਿਆ"</string>
+    <string name="error" msgid="6539615832923362301">"ਉਹ ਕਿਰਿਆ ਇਸ ਵੇਲੇ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ।"</string>
+</resources>
diff --git a/apps/Fallback/res/values-sl/strings.xml b/apps/Fallback/res/values-sl/strings.xml
index 322f466..16f30ab 100644
--- a/apps/Fallback/res/values-sl/strings.xml
+++ b/apps/Fallback/res/values-sl/strings.xml
@@ -16,7 +16,7 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="appTitle" msgid="161410001913116606">"Nadomestni program"</string>
+    <string name="appTitle" msgid="161410001913116606">"Nadomestna aplikacija"</string>
     <string name="title" msgid="8156274565006125136">"Dejanje ni podprto."</string>
     <string name="error" msgid="6539615832923362301">"To dejanje trenutno še ni podprto."</string>
 </resources>
diff --git a/apps/Fallback/res/values-sq-rAL/strings.xml b/apps/Fallback/res/values-sq-rAL/strings.xml
new file mode 100644
index 0000000..88ad3da
--- /dev/null
+++ b/apps/Fallback/res/values-sq-rAL/strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2007 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+  
+          http://www.apache.org/licenses/LICENSE-2.0
+  
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="appTitle" msgid="161410001913116606">"Alternativa"</string>
+    <string name="title" msgid="8156274565006125136">"Veprimi nuk mbështetet"</string>
+    <string name="error" msgid="6539615832923362301">"Ai veprim nuk mbështetet."</string>
+</resources>
diff --git a/build/Android.mk b/build/Android.mk
index 5d36d14..fa0590d 100644
--- a/build/Android.mk
+++ b/build/Android.mk
@@ -86,6 +86,9 @@
 # The uiautomator stubs
 ALL_SDK_FILES += $(TARGET_OUT_COMMON_INTERMEDIATES)/JAVA_LIBRARIES/android_uiautomator_intermediates/javalib.jar
 
+# org.apache.http.legacy.jar stubs
+ALL_SDK_FILES += $(TARGET_OUT_COMMON_INTERMEDIATES)/JAVA_LIBRARIES/org.apache.http.legacy_intermediates/javalib.jar
+
 # $(1): the Java library name
 define _package_sdk_library
 $(eval _psm_build_module := $(TARGET_OUT_COMMON_INTERMEDIATES)/JAVA_LIBRARIES/$(1)_intermediates/javalib.jar)
diff --git a/build/build_android_stubs.mk b/build/build_android_stubs.mk
index a028900..f74d23c 100644
--- a/build/build_android_stubs.mk
+++ b/build/build_android_stubs.mk
@@ -19,6 +19,7 @@
 # resource files here.
 intermediates := $(TARGET_OUT_COMMON_INTERMEDIATES)/JAVA_LIBRARIES/$(sdk_stub_name)_intermediates
 full_target := $(intermediates)/classes.jar
+jack_lib := $(intermediates)/classes.jack
 src_dir := $(intermediates)/src
 classes_dir := $(intermediates)/classes
 framework_res_package := $(call intermediates-dir-for,APPS,framework-res,,COMMON)/package-export.apk
@@ -49,3 +50,6 @@
 	$(hide) mkdir -p $(dir $@)
 	$(hide) jar -cf $@ -C $(PRIVATE_CLASS_INTERMEDIATES_DIR) .
 	$(hide) jar -u0f $@ -C $(PRIVATE_CLASS_INTERMEDIATES_DIR) resources.arsc
+
+$(jack_lib) : $(full_target) $(JILL_JAR) $(JACK_JAR)
+	$(transform-jar-to-jack)
\ No newline at end of file
diff --git a/build/optional.json b/build/optional.json
new file mode 100644
index 0000000..27216d9
--- /dev/null
+++ b/build/optional.json
@@ -0,0 +1,8 @@
+[
+  {
+    "name": "org.apache.http.legacy",
+    "jar": "org.apache.http.legacy.jar",
+    "manifest": false
+  }
+]
+
diff --git a/build/sdk.atree b/build/sdk.atree
index 41094a8..a451b37 100644
--- a/build/sdk.atree
+++ b/build/sdk.atree
@@ -130,17 +130,21 @@
 ##############################################################################
 
 # version files for the SDK updater, from development.git
-${HOST_OUT}/development/sdk/platform_source.properties platforms/${PLATFORM_NAME}/source.properties
+${HOST_OUT}/development/sdk/platform_source.properties                                       platforms/${PLATFORM_NAME}/source.properties
 
 # copy build prop from out/.../sdk/
-sdk/sdk-build.prop                            platforms/${PLATFORM_NAME}/build.prop
+sdk/sdk-build.prop                                                                           platforms/${PLATFORM_NAME}/build.prop
 
-# the uper-jar file that apps link against. This is the public API
-${OUT_DIR}/target/common/obj/PACKAGING/android_jar_intermediates/android.jar              platforms/${PLATFORM_NAME}/android.jar
-${OUT_DIR}/target/common/obj/JAVA_LIBRARIES/android_uiautomator_intermediates/javalib.jar platforms/${PLATFORM_NAME}/uiautomator.jar
+# Main Public API jar
+${OUT_DIR}/target/common/obj/PACKAGING/android_jar_intermediates/android.jar                 platforms/${PLATFORM_NAME}/android.jar
+# optional API files.
+development/build/optional.json                                                              platforms/${PLATFORM_NAME}/optional/optional.json
+${OUT_DIR}/target/common/obj/JAVA_LIBRARIES/org.apache.http.legacy_intermediates/javalib.jar platforms/${PLATFORM_NAME}/optional/org.apache.http.legacy.jar
+# deprecated APIs
+${OUT_DIR}/target/common/obj/JAVA_LIBRARIES/android_uiautomator_intermediates/javalib.jar    platforms/${PLATFORM_NAME}/uiautomator.jar
 
 # the aidl precompiled include
-obj/framework.aidl platforms/${PLATFORM_NAME}/framework.aidl
+obj/framework.aidl                                                                           platforms/${PLATFORM_NAME}/framework.aidl
 
 # emulator skins from sdk.git
 development/tools/emulator/skins/QVGA          platforms/${PLATFORM_NAME}/skins/QVGA
@@ -250,11 +254,6 @@
 developers/build/prebuilts/gradle/MediaRecorder/                             samples/${PLATFORM_NAME}/media/MediaRecorder
 developers/build/prebuilts/gradle/BasicMediaRouter/                          samples/${PLATFORM_NAME}/media/BasicMediaRouter
 developers/build/prebuilts/gradle/BasicMediaDecoder/                         samples/${PLATFORM_NAME}/media/BasicMediaDecoder
-developers/build/prebuilts/gradle/MediaBrowserService/                       samples/${PLATFORM_NAME}/media/MediaBrowserService
-developers/build/prebuilts/gradle/BasicNotifications/                        samples/${PLATFORM_NAME}/notification/BasicNotifications
-developers/build/prebuilts/gradle/CustomNotifications/                       samples/${PLATFORM_NAME}/notification/CustomNotifications
-developers/build/prebuilts/gradle/LNotifications/                            samples/${PLATFORM_NAME}/notification/LNotifications
-developers/build/prebuilts/gradle/MessagingService/                          samples/${PLATFORM_NAME}/notification/MessagingService
 developers/build/prebuilts/gradle/BorderlessButtons/                         samples/${PLATFORM_NAME}/ui/BorderlessButtons
 developers/build/prebuilts/gradle/BasicAccessibility/                        samples/${PLATFORM_NAME}/ui/BasicAccessibility
 developers/build/prebuilts/gradle/CustomChoiceList/                          samples/${PLATFORM_NAME}/ui/CustomChoiceList
@@ -264,6 +263,8 @@
 developers/build/prebuilts/gradle/ActionBarCompat-ListPopupMenu/             samples/${PLATFORM_NAME}/ui/ActionBarCompat-ListPopupMenu
 developers/build/prebuilts/gradle/ActionBarCompat-ShareActionProvider/       samples/${PLATFORM_NAME}/ui/ActionBarCompat-ShareActionProvider
 developers/build/prebuilts/gradle/ActionBarCompat-Basic/                     samples/${PLATFORM_NAME}/ui/ActionBarCompat-Basic
+developers/build/prebuilts/gradle/BasicNotifications/                        samples/${PLATFORM_NAME}/ui/BasicNotifications
+developers/build/prebuilts/gradle/CustomNotifications/                       samples/${PLATFORM_NAME}/ui/CustomNotifications
 developers/build/prebuilts/gradle/DoneBar/                                   samples/${PLATFORM_NAME}/ui/DoneBar
 developers/build/prebuilts/gradle/BasicImmersiveMode/                        samples/${PLATFORM_NAME}/ui/BasicImmersiveMode
 developers/build/prebuilts/gradle/AdvancedImmersiveMode/                     samples/${PLATFORM_NAME}/ui/AdvancedImmersiveMode
@@ -302,6 +303,7 @@
 developers/build/prebuilts/gradle/AppRestrictionSchema                       samples/${PLATFORM_NAME}/admin/AppRestrictionSchema
 developers/build/prebuilts/gradle/RecyclerView                               samples/${PLATFORM_NAME}/ui/views/RecyclerView
 developers/build/prebuilts/gradle/CardView                                   samples/${PLATFORM_NAME}/ui/views/CardView
+developers/build/prebuilts/gradle/LNotifications                             samples/${PLATFORM_NAME}/ui/notifications/LNotifications
 developers/build/prebuilts/gradle/DrawableTinting                            samples/${PLATFORM_NAME}/ui/DrawableTinting
 developers/build/prebuilts/gradle/Interpolator                               samples/${PLATFORM_NAME}/ui/Interpolator
 developers/build/prebuilts/gradle/PdfRendererBasic                           samples/${PLATFORM_NAME}/ui/graphics/PdfRendererBasic
@@ -339,7 +341,6 @@
 
 # Old sample tree
 development/samples/AccelerometerPlay          samples/${PLATFORM_NAME}/legacy/AccelerometerPlay
-development/samples/ActionBarCompat            samples/${PLATFORM_NAME}/legacy/ActionBarCompat
 development/samples/AndroidBeamDemo            samples/${PLATFORM_NAME}/legacy/AndroidBeamDemo
 development/samples/ApiDemos                   samples/${PLATFORM_NAME}/legacy/ApiDemos
 development/samples/AppNavigation              samples/${PLATFORM_NAME}/legacy/AppNavigation
diff --git a/ide/eclipse/.classpath b/ide/eclipse/.classpath
index 0cc0a3c..f9a715c 100644
--- a/ide/eclipse/.classpath
+++ b/ide/eclipse/.classpath
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
+	<classpathentry kind="src" path="packages/apps/Bluetooth/lib/mapapi"/>
 	<classpathentry kind="src" path="packages/apps/Bluetooth/src"/>
 	<classpathentry kind="src" path="packages/apps/Browser/src"/>
 	<classpathentry kind="src" path="packages/apps/Calendar/src"/>
@@ -9,6 +10,7 @@
 	<classpathentry kind="src" path="packages/apps/Contacts/src"/>
 	<classpathentry kind="src" path="packages/apps/ContactsCommon/src"/>
 	<classpathentry kind="src" path="packages/apps/Dialer/src"/>
+	<classpathentry kind="src" path="packages/apps/Email/provider_src"/>
 	<classpathentry kind="src" path="packages/apps/Email/src"/>
 	<classpathentry kind="src" path="packages/apps/Email/emailcommon/src"/>
 	<classpathentry kind="src" path="packages/apps/HTMLViewer/src"/>
@@ -29,6 +31,7 @@
 	<classpathentry kind="src" path="packages/providers/TelephonyProvider/src"/>
 	<classpathentry kind="src" path="packages/services/Telecomm/src"/>
 	<classpathentry kind="src" path="packages/services/Telecomm/tests/src"/>
+	<classpathentry kind="src" path="packages/services/Telephony/sip/src"/>
 	<classpathentry kind="src" path="packages/services/Telephony/src"/>
 	<classpathentry kind="src" path="packages/services/Telephony/common/src"/>
 	<classpathentry kind="src" path="packages/services/Telephony/tests/src"/>
@@ -52,6 +55,7 @@
 	<classpathentry kind="src" path="frameworks/base/opengl/java"/>
 	<classpathentry kind="src" path="frameworks/base/packages/FusedLocation/src"/>
 	<classpathentry kind="src" path="frameworks/base/packages/Keyguard/src"/>
+	<classpathentry kind="src" path="frameworks/base/packages/SettingsLib/src"/>
 	<classpathentry kind="src" path="frameworks/base/packages/SettingsProvider/src"/>
 	<classpathentry kind="src" path="frameworks/base/packages/SystemUI/src"/>
 	<classpathentry kind="src" path="frameworks/base/phone/java"/>
@@ -71,6 +75,7 @@
 	<classpathentry kind="src" path="frameworks/ex/camera2/public/src"/>
 	<classpathentry kind="src" path="frameworks/ex/common/java"/>
 	<classpathentry kind="src" path="frameworks/ex/variablespeed/src"/>
+	<classpathentry kind="src" path="frameworks/opt/bitmap/src"/>
 	<classpathentry kind="src" path="frameworks/opt/calendar/src"/>
 	<classpathentry kind="src" path="frameworks/opt/chips/src"/>
 	<classpathentry kind="src" path="frameworks/opt/colorpicker/src"/>
@@ -85,10 +90,16 @@
 	<classpathentry kind="src" path="frameworks/opt/telephony/src/java"/>
 	<classpathentry kind="src" path="frameworks/opt/timezonepicker/src"/>
 	<classpathentry kind="src" path="frameworks/opt/vcard/java"/>
+	<classpathentry kind="src" path="frameworks/support/v7/appcompat/src"/>
+	<classpathentry kind="src" path="frameworks/support/v7/cardview/api21"/>
+	<classpathentry kind="src" path="frameworks/support/v7/cardview/base"/>
+	<classpathentry kind="src" path="frameworks/support/v7/cardview/eclair-mr1"/>
+	<classpathentry kind="src" path="frameworks/support/v7/cardview/jellybean-mr1"/>
+	<classpathentry kind="src" path="frameworks/support/v7/cardview/src"/>
+	<classpathentry kind="src" path="frameworks/support/v7/palette/src/main/java"/>
 	<classpathentry kind="src" path="frameworks/support/v13/java"/>
 	<classpathentry kind="src" path="frameworks/support/v13/ics"/>
 	<classpathentry kind="src" path="frameworks/support/v13/ics-mr1"/>
-	<classpathentry kind="src" path="frameworks/support/v7/palette/src"/>
 	<classpathentry kind="src" path="libcore/dalvik/src/main/java"/>
 	<classpathentry kind="src" path="libcore/dex/src/main/java"/>
 	<classpathentry kind="src" path="libcore/json/src/main/java"/>
@@ -103,6 +114,7 @@
 	<classpathentry kind="src" path="out/target/common/obj/APPS/PackageInstaller_intermediates/src/src"/>
 	<classpathentry kind="src" path="out/target/common/obj/APPS/QuickSearchBox_intermediates/src/src"/>
 	<classpathentry kind="src" path="out/target/common/obj/APPS/Settings_intermediates/src/src"/>
+	<classpathentry kind="src" path="out/target/common/obj/APPS/SettingsProvider_intermediates/src/src"/>
 	<classpathentry kind="src" path="out/target/common/obj/APPS/SystemUI_intermediates/src/src"/>
 	<classpathentry kind="src" path="out/target/common/obj/APPS/TeleService_intermediates/src/src"/>
 	<classpathentry kind="src" path="out/target/common/obj/JAVA_LIBRARIES/com.android.emailcommon_intermediates/src/src"/>
@@ -122,6 +134,7 @@
 	<classpathentry kind="src" path="out/target/common/obj/JAVA_LIBRARIES/telephony-common_intermediates/src/src/java"/>
 	<classpathentry kind="src" path="out/target/common/obj/JAVA_LIBRARIES/voip-common_intermediates/src/src/java"/>
 	<classpathentry kind="src" path="out/target/common/R"/>
+	<classpathentry kind="src" path="external/apache-http/android/src"/>
 	<classpathentry kind="src" path="external/apache-http/src"/>
 	<classpathentry kind="src" path="external/bouncycastle/bcprov/src/main/java"/>
 	<classpathentry kind="src" path="external/easymock/src"/>
@@ -131,7 +144,10 @@
 	<classpathentry kind="src" path="external/ksoap2/kobjects"/>
 	<classpathentry kind="src" path="external/ksoap2/ksoap2-base/src/main/java"/>
 	<classpathentry kind="src" path="external/ksoap2/ksoap2-j2se/src/main/java"/>
+	<classpathentry kind="src" path="external/libphonenumber/geocoder/src"/>
+	<classpathentry kind="src" path="external/libphonenumber/internal/prefixmapper/src"/>
 	<classpathentry kind="src" path="external/libphonenumber/java/src"/>
+	<classpathentry kind="src" path="external/libphonenumber/libphonenumber/src"/>
 	<classpathentry kind="src" path="external/mp4parser/isoparser/src/main/java"/>
 	<classpathentry kind="src" path="external/nist-sip/java"/>
 	<classpathentry kind="src" path="external/objenesis/main/src"/>
@@ -147,9 +163,8 @@
 	<classpathentry kind="lib" path="out/target/common/obj/JAVA_LIBRARIES/android-support-v13_intermediates/javalib.jar"/>
 	<classpathentry kind="lib" path="out/target/common/obj/JAVA_LIBRARIES/android-common_intermediates/javalib.jar"/>
 	<classpathentry kind="lib" path="out/target/common/obj/JAVA_LIBRARIES/guava_intermediates/javalib.jar"/>
-	<classpathentry kind="lib" path="packages/apps/ContactsCommon/libs/geocoder-2.9.jar"/>
-	<classpathentry kind="lib" path="packages/apps/ContactsCommon/libs/libphonenumber-5.8.jar"/>
 	<classpathentry kind="lib" path="packages/apps/Calculator/arity-2.1.2.jar"/>
 	<classpathentry kind="lib" path="out/target/common/obj/JAVA_LIBRARIES/junit-runner_intermediates/javalib.jar"/>
+	<classpathentry kind="lib" path="out/target/common/obj/JAVA_LIBRARIES/libphonenumber-platform_intermediates/javalib.jar"/>
 	<classpathentry kind="output" path="out/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediates/classes"/>
 </classpath>
diff --git a/samples/ActionBarCompat/AndroidManifest.xml b/samples/ActionBarCompat/AndroidManifest.xml
deleted file mode 100644
index a78339b..0000000
--- a/samples/ActionBarCompat/AndroidManifest.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.example.android.actionbarcompat"
-    android:versionCode="1"
-    android:versionName="1.0">
-
-    <uses-sdk android:minSdkVersion="3" android:targetSdkVersion="14" />
-    <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
-    <supports-screens android:largeScreens="true"/>
-
-    <application android:label="@string/app_name"
-        android:icon="@drawable/ic_launcher"
-        android:theme="@style/AppTheme">
-        <activity android:name=".MainActivity" android:label="@string/app_name">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
diff --git a/samples/ActionBarCompat/_index.jd b/samples/ActionBarCompat/_index.jd
deleted file mode 100644
index 61b5e5e..0000000
--- a/samples/ActionBarCompat/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-page.tags="ActionBar", "UI", "Compatibility", "Support Library"
-sample.group=Input
-@jd:body
-
-<p>This sample shows how to use the action bar design pattern on pre-API 11 devices and the built-in
-<a href="../../../reference/android/app/ActionBar.html">ActionBar</a> on devices supporting API
-11 or greater. The example 'compatible' action bar, instantiated on pre-Android 3.0 devices,
-uses the same <a href="../../../guide/topics/resources/menu-resource.html">menu resource</a>-based
-action item definition mechanism as the new framework API, even supporting the
-<code>android:showAsAction</code> attribute to a limited extent.</p>
-
-<img alt="" src="../images/ActionBarCompat1.png" height="320" />
-<img alt="" src="../images/ActionBarCompat2.png" height="320" />
\ No newline at end of file
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/actionbar_shadow.9.png b/samples/ActionBarCompat/res/drawable-hdpi/actionbar_shadow.9.png
deleted file mode 100644
index 3c80a3f..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/actionbar_shadow.9.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/ic_action_refresh.png b/samples/ActionBarCompat/res/drawable-hdpi/ic_action_refresh.png
deleted file mode 100644
index efe99e0..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/ic_action_refresh.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/ic_action_search.png b/samples/ActionBarCompat/res/drawable-hdpi/ic_action_search.png
deleted file mode 100644
index f6719d2..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/ic_action_search.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/ic_action_share.png b/samples/ActionBarCompat/res/drawable-hdpi/ic_action_share.png
deleted file mode 100644
index 7d0b872..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/ic_action_share.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/ic_home.png b/samples/ActionBarCompat/res/drawable-hdpi/ic_home.png
deleted file mode 100644
index 7e52ff5..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/ic_home.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/ic_launcher.png b/samples/ActionBarCompat/res/drawable-hdpi/ic_launcher.png
deleted file mode 100755
index e4b0492..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-hdpi/ic_menu_share.png b/samples/ActionBarCompat/res/drawable-hdpi/ic_menu_share.png
deleted file mode 100755
index a78bf7a..0000000
--- a/samples/ActionBarCompat/res/drawable-hdpi/ic_menu_share.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/actionbar_shadow.9.png b/samples/ActionBarCompat/res/drawable-mdpi/actionbar_shadow.9.png
deleted file mode 100644
index cae1778..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/actionbar_shadow.9.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/ic_action_refresh.png b/samples/ActionBarCompat/res/drawable-mdpi/ic_action_refresh.png
deleted file mode 100644
index a85eee3..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/ic_action_refresh.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/ic_action_search.png b/samples/ActionBarCompat/res/drawable-mdpi/ic_action_search.png
deleted file mode 100755
index 45d2398..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/ic_action_search.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/ic_action_share.png b/samples/ActionBarCompat/res/drawable-mdpi/ic_action_share.png
deleted file mode 100644
index 26a39bd..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/ic_action_share.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/ic_home.png b/samples/ActionBarCompat/res/drawable-mdpi/ic_home.png
deleted file mode 100644
index 949b4aa..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/ic_home.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/ic_launcher.png b/samples/ActionBarCompat/res/drawable-mdpi/ic_launcher.png
deleted file mode 100755
index 78d0e29..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-mdpi/ic_menu_share.png b/samples/ActionBarCompat/res/drawable-mdpi/ic_menu_share.png
deleted file mode 100755
index 3329b6b..0000000
--- a/samples/ActionBarCompat/res/drawable-mdpi/ic_menu_share.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-xhdpi/actionbar_shadow.9.png b/samples/ActionBarCompat/res/drawable-xhdpi/actionbar_shadow.9.png
deleted file mode 100644
index 30778e3..0000000
--- a/samples/ActionBarCompat/res/drawable-xhdpi/actionbar_shadow.9.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_refresh.png b/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_refresh.png
deleted file mode 100644
index 6ce9376..0000000
--- a/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_refresh.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_search.png b/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_search.png
deleted file mode 100644
index f89c4e9..0000000
--- a/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_search.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_share.png b/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_share.png
deleted file mode 100644
index 47b27d1..0000000
--- a/samples/ActionBarCompat/res/drawable-xhdpi/ic_action_share.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-xhdpi/ic_home.png b/samples/ActionBarCompat/res/drawable-xhdpi/ic_home.png
deleted file mode 100644
index 03eb53d..0000000
--- a/samples/ActionBarCompat/res/drawable-xhdpi/ic_home.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable-xhdpi/ic_launcher.png b/samples/ActionBarCompat/res/drawable-xhdpi/ic_launcher.png
deleted file mode 100755
index 485f7be..0000000
--- a/samples/ActionBarCompat/res/drawable-xhdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/samples/ActionBarCompat/res/drawable/actionbar_compat_item.xml b/samples/ActionBarCompat/res/drawable/actionbar_compat_item.xml
deleted file mode 100644
index 4b3960c..0000000
--- a/samples/ActionBarCompat/res/drawable/actionbar_compat_item.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-    <item android:drawable="@drawable/actionbar_compat_item_pressed"
-        android:state_pressed="true" />
-    <item android:drawable="@drawable/actionbar_compat_item_focused"
-        android:state_focused="true" />
-    <item android:drawable="@android:color/transparent" />
-</selector>
diff --git a/samples/ActionBarCompat/res/drawable/actionbar_compat_item_focused.xml b/samples/ActionBarCompat/res/drawable/actionbar_compat_item_focused.xml
deleted file mode 100644
index 04811d3..0000000
--- a/samples/ActionBarCompat/res/drawable/actionbar_compat_item_focused.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<shape xmlns:android="http://schemas.android.com/apk/res/android">
-    <solid android:color="#ef7000" />
-</shape>
diff --git a/samples/ActionBarCompat/res/drawable/actionbar_compat_item_pressed.xml b/samples/ActionBarCompat/res/drawable/actionbar_compat_item_pressed.xml
deleted file mode 100644
index 72ff4b4..0000000
--- a/samples/ActionBarCompat/res/drawable/actionbar_compat_item_pressed.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<shape xmlns:android="http://schemas.android.com/apk/res/android">
-    <solid android:color="#eda700" />
-</shape>
diff --git a/samples/ActionBarCompat/res/layout-v11/actionbar_indeterminate_progress.xml b/samples/ActionBarCompat/res/layout-v11/actionbar_indeterminate_progress.xml
deleted file mode 100644
index c05750e..0000000
--- a/samples/ActionBarCompat/res/layout-v11/actionbar_indeterminate_progress.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    android:gravity="center">
-    <ProgressBar android:layout_width="32dp"
-        android:layout_height="32dp"
-        android:layout_marginLeft="12dp"
-        android:layout_marginRight="12dp"
-        android:layout_gravity="center"
-        style="?android:attr/indeterminateProgressStyle" />
-</FrameLayout>
diff --git a/samples/ActionBarCompat/res/layout/actionbar_compat.xml b/samples/ActionBarCompat/res/layout/actionbar_compat.xml
deleted file mode 100644
index ae6c44b..0000000
--- a/samples/ActionBarCompat/res/layout/actionbar_compat.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@id/actionbar_compat"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent"
-    android:orientation="horizontal" />
diff --git a/samples/ActionBarCompat/res/layout/main.xml b/samples/ActionBarCompat/res/layout/main.xml
deleted file mode 100644
index a58a346..0000000
--- a/samples/ActionBarCompat/res/layout/main.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent">
-    <Button android:id="@+id/toggle_title"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_gravity="center"
-        android:text="@string/toggle_title" />
-</FrameLayout>
diff --git a/samples/ActionBarCompat/res/menu/main.xml b/samples/ActionBarCompat/res/menu/main.xml
deleted file mode 100644
index a306a3c..0000000
--- a/samples/ActionBarCompat/res/menu/main.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<menu xmlns:android="http://schemas.android.com/apk/res/android">
-    <item android:id="@+id/menu_refresh"
-        android:title="@string/menu_refresh"
-        android:icon="@drawable/ic_action_refresh"
-        android:orderInCategory="1"
-        android:showAsAction="always" />
-    <item android:id="@+id/menu_search"
-        android:title="@string/menu_search"
-        android:icon="@drawable/ic_action_search"
-        android:orderInCategory="0"
-        android:showAsAction="always" />
-
-    <item android:id="@+id/menu_share"
-        android:title="@string/menu_share"
-        android:icon="@drawable/ic_menu_share"
-        android:orderInCategory="1"
-        android:showAsAction="never" />
-</menu>
diff --git a/samples/ActionBarCompat/res/values-v11/styles.xml b/samples/ActionBarCompat/res/values-v11/styles.xml
deleted file mode 100644
index dc1aa7c..0000000
--- a/samples/ActionBarCompat/res/values-v11/styles.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-
-    <style name="AppTheme" parent="android:style/Theme.Holo.Light">
-        <item name="android:actionBarStyle">@style/ActionBar</item>
-        <item name="android:windowContentOverlay">@drawable/actionbar_shadow</item>
-    </style>
-
-    <style name="ActionBar" parent="android:style/Widget.Holo.Light.ActionBar">
-        <item name="android:background">#eee</item>
-        <item name="android:titleTextStyle">@style/ActionBarTitle</item>
-        <item name="android:icon">@drawable/ic_home</item>
-    </style>
-
-    <style name="ActionBarTitle">
-        <item name="android:textColor">@color/actionbar_title_color</item>
-    </style>
-
-</resources>
diff --git a/samples/ActionBarCompat/res/values-v13/styles.xml b/samples/ActionBarCompat/res/values-v13/styles.xml
deleted file mode 100644
index 8a042b4..0000000
--- a/samples/ActionBarCompat/res/values-v13/styles.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-
-    <style name="ActionBarTitle" parent="android:style/TextAppearance.Holo.Widget.ActionBar.Title">
-        <item name="android:textColor">@color/actionbar_title_color</item>
-    </style>
-
-</resources>
diff --git a/samples/ActionBarCompat/res/values/attrs.xml b/samples/ActionBarCompat/res/values/attrs.xml
deleted file mode 100644
index c59822c..0000000
--- a/samples/ActionBarCompat/res/values/attrs.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-
-    <declare-styleable name="AppTheme">
-        <attr name="actionbarCompatTitleStyle" format="reference" />
-        <attr name="actionbarCompatItemStyle" format="reference" />
-        <attr name="actionbarCompatItemHomeStyle" format="reference" />
-        <attr name="actionbarCompatProgressIndicatorStyle" format="reference" />
-    </declare-styleable>
-
-    <declare-styleable name="BezelImageView">
-        <attr name="maskDrawable" format="reference" />
-        <attr name="borderDrawable" format="reference" />
-    </declare-styleable>
-
-</resources>
diff --git a/samples/ActionBarCompat/res/values/colors.xml b/samples/ActionBarCompat/res/values/colors.xml
deleted file mode 100644
index 4edc6d6..0000000
--- a/samples/ActionBarCompat/res/values/colors.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-    <color name="actionbar_title_color">#224894</color>
-</resources>
diff --git a/samples/ActionBarCompat/res/values/dimens.xml b/samples/ActionBarCompat/res/values/dimens.xml
deleted file mode 100644
index 67c8436..0000000
--- a/samples/ActionBarCompat/res/values/dimens.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-    <dimen name="actionbar_compat_height">48dp</dimen>
-    <dimen name="actionbar_compat_button_width">48dp</dimen>
-    <dimen name="actionbar_compat_button_home_width">56dp</dimen>
-</resources>
diff --git a/samples/ActionBarCompat/res/values/ids.xml b/samples/ActionBarCompat/res/values/ids.xml
deleted file mode 100644
index e0a4745..0000000
--- a/samples/ActionBarCompat/res/values/ids.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-    <item type="id" name="actionbar_compat" />
-    <item type="id" name="actionbar_compat_title" />
-    <item type="id" name="actionbar_compat_item_refresh_progress" />
-    <item type="id" name="actionbar_compat_item_refresh" />
-    <item type="id" name="menu_refresh" />
-</resources>
diff --git a/samples/ActionBarCompat/res/values/strings.xml b/samples/ActionBarCompat/res/values/strings.xml
deleted file mode 100644
index 234aa78..0000000
--- a/samples/ActionBarCompat/res/values/strings.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-    <string name="app_name">Action Bar Demo</string>
-    <string name="alternate_title">An alternate title that is long</string>
-    <string name="toggle_title">Toggle title</string>
-
-    <string name="menu_refresh">Refresh</string>
-    <string name="menu_search">Search</string>
-    <string name="menu_share">Share</string>
-</resources>
diff --git a/samples/ActionBarCompat/res/values/styles.xml b/samples/ActionBarCompat/res/values/styles.xml
deleted file mode 100644
index 5d0c029..0000000
--- a/samples/ActionBarCompat/res/values/styles.xml
+++ /dev/null
@@ -1,66 +0,0 @@
-<!--
-  Copyright 2011 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<resources>
-
-    <style name="AppTheme" parent="android:style/Theme.Light">
-        <item name="android:windowTitleSize">@dimen/actionbar_compat_height</item>
-        <item name="android:windowTitleBackgroundStyle">@style/ActionBarCompat</item>
-        <item name="android:windowContentOverlay">@drawable/actionbar_shadow</item>
-
-        <!-- for programmatic instantiation -->
-        <item name="actionbarCompatTitleStyle">@style/ActionBarCompatTitle</item>
-        <item name="actionbarCompatItemStyle">@style/ActionBarCompatItem</item>
-        <item name="actionbarCompatItemHomeStyle">@style/ActionBarCompatHomeItem</item>
-        <item name="actionbarCompatProgressIndicatorStyle">@style/ActionBarCompatProgressIndicator</item>
-    </style>
-
-    <style name="ActionBarCompat">
-        <item name="android:background">#eee</item>
-    </style>
-
-    <style name="ActionBarCompatItemBase">
-        <!-- layout_width/height must be set in code -->
-        <item name="android:scaleType">center</item>
-        <item name="android:background">@drawable/actionbar_compat_item</item>
-    </style>
-
-    <style name="ActionBarCompatProgressIndicator" parent="android:style/Widget.ProgressBar.Large">
-        <item name="android:indeterminate">true</item>
-    </style>
-
-    <style name="ActionBarCompatTitleBase">
-        <item name="android:id">@id/actionbar_compat_title</item>
-        <!-- layout_width/height/weight must be set in code -->
-        <item name="android:gravity">center_vertical</item>
-        <item name="android:textSize">18sp</item>
-        <item name="android:paddingLeft">6dp</item>
-        <item name="android:paddingRight">6dp</item>
-        <item name="android:singleLine">true</item>
-        <item name="android:ellipsize">marquee</item>
-    </style>
-
-    <style name="ActionBarCompatTitle" parent="style/ActionBarCompatTitleBase">
-        <item name="android:textColor">@color/actionbar_title_color</item>
-    </style>
-
-    <style name="ActionBarCompatItem" parent="style/ActionBarCompatItemBase">
-    </style>
-
-    <style name="ActionBarCompatHomeItem" parent="style/ActionBarCompatItemBase">
-    </style>
-
-</resources>
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarActivity.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarActivity.java
deleted file mode 100644
index 251e411..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarActivity.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.view.Menu;
-import android.view.MenuInflater;
-
-/**
- * A base activity that defers common functionality across app activities to an {@link
- * ActionBarHelper}.
- *
- * NOTE: dynamically marking menu items as invisible/visible is not currently supported.
- *
- * NOTE: this may used with the Android Compatibility Package by extending
- * android.support.v4.app.FragmentActivity instead of {@link Activity}.
- */
-public abstract class ActionBarActivity extends Activity {
-    final ActionBarHelper mActionBarHelper = ActionBarHelper.createInstance(this);
-
-    /**
-     * Returns the {@link ActionBarHelper} for this activity.
-     */
-    protected ActionBarHelper getActionBarHelper() {
-        return mActionBarHelper;
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    public MenuInflater getMenuInflater() {
-        return mActionBarHelper.getMenuInflater(super.getMenuInflater());
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mActionBarHelper.onCreate(savedInstanceState);
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    protected void onPostCreate(Bundle savedInstanceState) {
-        super.onPostCreate(savedInstanceState);
-        mActionBarHelper.onPostCreate(savedInstanceState);
-    }
-
-    /**
-     * Base action bar-aware implementation for
-     * {@link Activity#onCreateOptionsMenu(android.view.Menu)}.
-     *
-     * Note: marking menu items as invisible/visible is not currently supported.
-     */
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        boolean retValue = false;
-        retValue |= mActionBarHelper.onCreateOptionsMenu(menu);
-        retValue |= super.onCreateOptionsMenu(menu);
-        return retValue;
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    protected void onTitleChanged(CharSequence title, int color) {
-        mActionBarHelper.onTitleChanged(title, color);
-        super.onTitleChanged(title, color);
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelper.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelper.java
deleted file mode 100644
index 075f993..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelper.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.app.Activity;
-import android.os.Build;
-import android.os.Bundle;
-import android.view.Menu;
-import android.view.MenuInflater;
-
-/**
- * An abstract class that handles some common action bar-related functionality in the app. This
- * class provides functionality useful for both phones and tablets, and does not require any Android
- * 3.0-specific features, although it uses them if available.
- *
- * Two implementations of this class are {@link ActionBarHelperBase} for a pre-Honeycomb version of
- * the action bar, and {@link ActionBarHelperHoneycomb}, which uses the built-in ActionBar features
- * in Android 3.0 and later.
- */
-public abstract class ActionBarHelper {
-    protected Activity mActivity;
-
-    /**
-     * Factory method for creating {@link ActionBarHelper} objects for a
-     * given activity. Depending on which device the app is running, either a basic helper or
-     * Honeycomb-specific helper will be returned.
-     */
-    public static ActionBarHelper createInstance(Activity activity) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
-            return new ActionBarHelperICS(activity);
-        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
-            return new ActionBarHelperHoneycomb(activity);
-        } else {
-            return new ActionBarHelperBase(activity);
-        }
-    }
-
-    protected ActionBarHelper(Activity activity) {
-        mActivity = activity;
-    }
-
-    /**
-     * Action bar helper code to be run in {@link Activity#onCreate(android.os.Bundle)}.
-     */
-    public void onCreate(Bundle savedInstanceState) {
-    }
-
-    /**
-     * Action bar helper code to be run in {@link Activity#onPostCreate(android.os.Bundle)}.
-     */
-    public void onPostCreate(Bundle savedInstanceState) {
-    }
-
-    /**
-     * Action bar helper code to be run in {@link Activity#onCreateOptionsMenu(android.view.Menu)}.
-     *
-     * NOTE: Setting the visibility of menu items in <em>menu</em> is not currently supported.
-     */
-    public boolean onCreateOptionsMenu(Menu menu) {
-        return true;
-    }
-
-    /**
-     * Action bar helper code to be run in {@link Activity#onTitleChanged(CharSequence, int)}.
-     */
-    protected void onTitleChanged(CharSequence title, int color) {
-    }
-
-    /**
-     * Sets the indeterminate loading state of the item with ID {@link R.id.menu_refresh}.
-     * (where the item ID was menu_refresh).
-     */
-    public abstract void setRefreshActionItemState(boolean refreshing);
-
-    /**
-     * Returns a {@link MenuInflater} for use when inflating menus. The implementation of this
-     * method in {@link ActionBarHelperBase} returns a wrapped menu inflater that can read
-     * action bar metadata from a menu resource pre-Honeycomb.
-     */
-    public MenuInflater getMenuInflater(MenuInflater superMenuInflater) {
-        return superMenuInflater;
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperBase.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperBase.java
deleted file mode 100644
index f70b54a..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperBase.java
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-
-import android.app.Activity;
-import android.content.Context;
-import android.content.res.XmlResourceParser;
-import android.os.Bundle;
-import android.view.InflateException;
-import android.view.Menu;
-import android.view.MenuInflater;
-import android.view.MenuItem;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.Window;
-import android.widget.ImageButton;
-import android.widget.ImageView;
-import android.widget.LinearLayout;
-import android.widget.ProgressBar;
-import android.widget.TextView;
-
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * A class that implements the action bar pattern for pre-Honeycomb devices.
- */
-public class ActionBarHelperBase extends ActionBarHelper {
-    private static final String MENU_RES_NAMESPACE = "http://schemas.android.com/apk/res/android";
-    private static final String MENU_ATTR_ID = "id";
-    private static final String MENU_ATTR_SHOW_AS_ACTION = "showAsAction";
-
-    protected Set<Integer> mActionItemIds = new HashSet<Integer>();
-
-    protected ActionBarHelperBase(Activity activity) {
-        super(activity);
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        mActivity.requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    public void onPostCreate(Bundle savedInstanceState) {
-        mActivity.getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE,
-                R.layout.actionbar_compat);
-        setupActionBar();
-
-        SimpleMenu menu = new SimpleMenu(mActivity);
-        mActivity.onCreatePanelMenu(Window.FEATURE_OPTIONS_PANEL, menu);
-        mActivity.onPrepareOptionsMenu(menu);
-        for (int i = 0; i < menu.size(); i++) {
-            MenuItem item = menu.getItem(i);
-            if (mActionItemIds.contains(item.getItemId())) {
-                addActionItemCompatFromMenuItem(item);
-            }
-        }
-    }
-
-    /**
-     * Sets up the compatibility action bar with the given title.
-     */
-    private void setupActionBar() {
-        final ViewGroup actionBarCompat = getActionBarCompat();
-        if (actionBarCompat == null) {
-            return;
-        }
-
-        LinearLayout.LayoutParams springLayoutParams = new LinearLayout.LayoutParams(
-                0, ViewGroup.LayoutParams.FILL_PARENT);
-        springLayoutParams.weight = 1;
-
-        // Add Home button
-        SimpleMenu tempMenu = new SimpleMenu(mActivity);
-        SimpleMenuItem homeItem = new SimpleMenuItem(
-                tempMenu, android.R.id.home, 0, mActivity.getString(R.string.app_name));
-        homeItem.setIcon(R.drawable.ic_home);
-        addActionItemCompatFromMenuItem(homeItem);
-
-        // Add title text
-        TextView titleText = new TextView(mActivity, null, R.attr.actionbarCompatTitleStyle);
-        titleText.setLayoutParams(springLayoutParams);
-        titleText.setText(mActivity.getTitle());
-        actionBarCompat.addView(titleText);
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    public void setRefreshActionItemState(boolean refreshing) {
-        View refreshButton = mActivity.findViewById(R.id.actionbar_compat_item_refresh);
-        View refreshIndicator = mActivity.findViewById(
-                R.id.actionbar_compat_item_refresh_progress);
-
-        if (refreshButton != null) {
-            refreshButton.setVisibility(refreshing ? View.GONE : View.VISIBLE);
-        }
-        if (refreshIndicator != null) {
-            refreshIndicator.setVisibility(refreshing ? View.VISIBLE : View.GONE);
-        }
-    }
-
-    /**
-     * Action bar helper code to be run in {@link Activity#onCreateOptionsMenu(android.view.Menu)}.
-     *
-     * NOTE: This code will mark on-screen menu items as invisible.
-     */
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        // Hides on-screen action items from the options menu.
-        for (Integer id : mActionItemIds) {
-            menu.findItem(id).setVisible(false);
-        }
-        return true;
-    }
-
-    /**{@inheritDoc}*/
-    @Override
-    protected void onTitleChanged(CharSequence title, int color) {
-        TextView titleView = (TextView) mActivity.findViewById(R.id.actionbar_compat_title);
-        if (titleView != null) {
-            titleView.setText(title);
-        }
-    }
-
-    /**
-     * Returns a {@link android.view.MenuInflater} that can read action bar metadata on
-     * pre-Honeycomb devices.
-     */
-    public MenuInflater getMenuInflater(MenuInflater superMenuInflater) {
-        return new WrappedMenuInflater(mActivity, superMenuInflater);
-    }
-
-    /**
-     * Returns the {@link android.view.ViewGroup} for the action bar on phones (compatibility action
-     * bar). Can return null, and will return null on Honeycomb.
-     */
-    private ViewGroup getActionBarCompat() {
-        return (ViewGroup) mActivity.findViewById(R.id.actionbar_compat);
-    }
-
-    /**
-     * Adds an action button to the compatibility action bar, using menu information from a {@link
-     * android.view.MenuItem}. If the menu item ID is <code>menu_refresh</code>, the menu item's
-     * state can be changed to show a loading spinner using
-     * {@link com.example.android.actionbarcompat.ActionBarHelperBase#setRefreshActionItemState(boolean)}.
-     */
-    private View addActionItemCompatFromMenuItem(final MenuItem item) {
-        final int itemId = item.getItemId();
-
-        final ViewGroup actionBar = getActionBarCompat();
-        if (actionBar == null) {
-            return null;
-        }
-
-        // Create the button
-        ImageButton actionButton = new ImageButton(mActivity, null,
-                itemId == android.R.id.home
-                        ? R.attr.actionbarCompatItemHomeStyle
-                        : R.attr.actionbarCompatItemStyle);
-        actionButton.setLayoutParams(new ViewGroup.LayoutParams(
-                (int) mActivity.getResources().getDimension(
-                        itemId == android.R.id.home
-                                ? R.dimen.actionbar_compat_button_home_width
-                                : R.dimen.actionbar_compat_button_width),
-                ViewGroup.LayoutParams.FILL_PARENT));
-        if (itemId == R.id.menu_refresh) {
-            actionButton.setId(R.id.actionbar_compat_item_refresh);
-        }
-        actionButton.setImageDrawable(item.getIcon());
-        actionButton.setScaleType(ImageView.ScaleType.CENTER);
-        actionButton.setContentDescription(item.getTitle());
-        actionButton.setOnClickListener(new View.OnClickListener() {
-            public void onClick(View view) {
-                mActivity.onMenuItemSelected(Window.FEATURE_OPTIONS_PANEL, item);
-            }
-        });
-
-        actionBar.addView(actionButton);
-
-        if (item.getItemId() == R.id.menu_refresh) {
-            // Refresh buttons should be stateful, and allow for indeterminate progress indicators,
-            // so add those.
-            ProgressBar indicator = new ProgressBar(mActivity, null,
-                    R.attr.actionbarCompatProgressIndicatorStyle);
-
-            final int buttonWidth = mActivity.getResources().getDimensionPixelSize(
-                    R.dimen.actionbar_compat_button_width);
-            final int buttonHeight = mActivity.getResources().getDimensionPixelSize(
-                    R.dimen.actionbar_compat_height);
-            final int progressIndicatorWidth = buttonWidth / 2;
-
-            LinearLayout.LayoutParams indicatorLayoutParams = new LinearLayout.LayoutParams(
-                    progressIndicatorWidth, progressIndicatorWidth);
-            indicatorLayoutParams.setMargins(
-                    (buttonWidth - progressIndicatorWidth) / 2,
-                    (buttonHeight - progressIndicatorWidth) / 2,
-                    (buttonWidth - progressIndicatorWidth) / 2,
-                    0);
-            indicator.setLayoutParams(indicatorLayoutParams);
-            indicator.setVisibility(View.GONE);
-            indicator.setId(R.id.actionbar_compat_item_refresh_progress);
-            actionBar.addView(indicator);
-        }
-
-        return actionButton;
-    }
-
-    /**
-     * A {@link android.view.MenuInflater} that reads action bar metadata.
-     */
-    private class WrappedMenuInflater extends MenuInflater {
-        MenuInflater mInflater;
-
-        public WrappedMenuInflater(Context context, MenuInflater inflater) {
-            super(context);
-            mInflater = inflater;
-        }
-
-        @Override
-        public void inflate(int menuRes, Menu menu) {
-            loadActionBarMetadata(menuRes);
-            mInflater.inflate(menuRes, menu);
-        }
-
-        /**
-         * Loads action bar metadata from a menu resource, storing a list of menu item IDs that
-         * should be shown on-screen (i.e. those with showAsAction set to always or ifRoom).
-         * @param menuResId
-         */
-        private void loadActionBarMetadata(int menuResId) {
-            XmlResourceParser parser = null;
-            try {
-                parser = mActivity.getResources().getXml(menuResId);
-
-                int eventType = parser.getEventType();
-                int itemId;
-                int showAsAction;
-
-                boolean eof = false;
-                while (!eof) {
-                    switch (eventType) {
-                        case XmlPullParser.START_TAG:
-                            if (!parser.getName().equals("item")) {
-                                break;
-                            }
-
-                            itemId = parser.getAttributeResourceValue(MENU_RES_NAMESPACE,
-                                    MENU_ATTR_ID, 0);
-                            if (itemId == 0) {
-                                break;
-                            }
-
-                            showAsAction = parser.getAttributeIntValue(MENU_RES_NAMESPACE,
-                                    MENU_ATTR_SHOW_AS_ACTION, -1);
-                            if (showAsAction == MenuItem.SHOW_AS_ACTION_ALWAYS ||
-                                    showAsAction == MenuItem.SHOW_AS_ACTION_IF_ROOM) {
-                                mActionItemIds.add(itemId);
-                            }
-                            break;
-
-                        case XmlPullParser.END_DOCUMENT:
-                            eof = true;
-                            break;
-                    }
-
-                    eventType = parser.next();
-                }
-            } catch (XmlPullParserException e) {
-                throw new InflateException("Error inflating menu XML", e);
-            } catch (IOException e) {
-                throw new InflateException("Error inflating menu XML", e);
-            } finally {
-                if (parser != null) {
-                    parser.close();
-                }
-            }
-        }
-
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperHoneycomb.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperHoneycomb.java
deleted file mode 100644
index 16fba69..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperHoneycomb.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.app.Activity;
-import android.content.Context;
-import android.os.Bundle;
-import android.view.LayoutInflater;
-import android.view.Menu;
-import android.view.MenuInflater;
-import android.view.MenuItem;
-import android.view.View;
-
-/**
- * An extension of {@link ActionBarHelper} that provides Android 3.0-specific functionality for
- * Honeycomb tablets. It thus requires API level 11.
- */
-public class ActionBarHelperHoneycomb extends ActionBarHelper {
-    private Menu mOptionsMenu;
-    private View mRefreshIndeterminateProgressView = null;
-
-    protected ActionBarHelperHoneycomb(Activity activity) {
-        super(activity);
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        mOptionsMenu = menu;
-        return super.onCreateOptionsMenu(menu);
-    }
-
-    @Override
-    public void setRefreshActionItemState(boolean refreshing) {
-        // On Honeycomb, we can set the state of the refresh button by giving it a custom
-        // action view.
-        if (mOptionsMenu == null) {
-            return;
-        }
-
-        final MenuItem refreshItem = mOptionsMenu.findItem(R.id.menu_refresh);
-        if (refreshItem != null) {
-            if (refreshing) {
-                if (mRefreshIndeterminateProgressView == null) {
-                    LayoutInflater inflater = (LayoutInflater)
-                            getActionBarThemedContext().getSystemService(
-                                    Context.LAYOUT_INFLATER_SERVICE);
-                    mRefreshIndeterminateProgressView = inflater.inflate(
-                            R.layout.actionbar_indeterminate_progress, null);
-                }
-
-                refreshItem.setActionView(mRefreshIndeterminateProgressView);
-            } else {
-                refreshItem.setActionView(null);
-            }
-        }
-    }
-
-    /**
-     * Returns a {@link Context} suitable for inflating layouts for the action bar. The
-     * implementation for this method in {@link ActionBarHelperICS} asks the action bar for a
-     * themed context.
-     */
-    protected Context getActionBarThemedContext() {
-        return mActivity;
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperICS.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperICS.java
deleted file mode 100644
index d2239db..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/ActionBarHelperICS.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.app.Activity;
-import android.content.Context;
-import android.view.Menu;
-import android.view.MenuItem;
-
-/**
- * An extension of {@link com.example.android.actionbarcompat.ActionBarHelper} that provides Android
- * 4.0-specific functionality for IceCreamSandwich devices. It thus requires API level 14.
- */
-public class ActionBarHelperICS extends ActionBarHelperHoneycomb {
-    protected ActionBarHelperICS(Activity activity) {
-        super(activity);
-    }
-
-    @Override
-    protected Context getActionBarThemedContext() {
-        return mActivity.getActionBar().getThemedContext();
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/MainActivity.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/MainActivity.java
deleted file mode 100644
index facf1ae..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/MainActivity.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.os.Bundle;
-import android.view.Menu;
-import android.view.MenuInflater;
-import android.view.MenuItem;
-import android.view.View;
-import android.widget.Toast;
-
-public class MainActivity extends ActionBarActivity {
-    private boolean mAlternateTitle = false;
-
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.main);
-
-        findViewById(R.id.toggle_title).setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View view) {
-                if (mAlternateTitle) {
-                    setTitle(R.string.app_name);
-                } else {
-                    setTitle(R.string.alternate_title);
-                }
-                mAlternateTitle = !mAlternateTitle;
-            }
-        });
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        MenuInflater menuInflater = getMenuInflater();
-        menuInflater.inflate(R.menu.main, menu);
-
-        // Calling super after populating the menu is necessary here to ensure that the
-        // action bar helpers have a chance to handle this event.
-        return super.onCreateOptionsMenu(menu);
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        switch (item.getItemId()) {
-            case android.R.id.home:
-                Toast.makeText(this, "Tapped home", Toast.LENGTH_SHORT).show();
-                break;
-
-            case R.id.menu_refresh:
-                Toast.makeText(this, "Fake refreshing...", Toast.LENGTH_SHORT).show();
-                getActionBarHelper().setRefreshActionItemState(true);
-                getWindow().getDecorView().postDelayed(
-                        new Runnable() {
-                            @Override
-                            public void run() {
-                                getActionBarHelper().setRefreshActionItemState(false);
-                            }
-                        }, 1000);
-                break;
-
-            case R.id.menu_search:
-                Toast.makeText(this, "Tapped search", Toast.LENGTH_SHORT).show();
-                break;
-
-            case R.id.menu_share:
-                Toast.makeText(this, "Tapped share", Toast.LENGTH_SHORT).show();
-                break;
-        }
-        return super.onOptionsItemSelected(item);
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/SimpleMenu.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/SimpleMenu.java
deleted file mode 100644
index 8b694d0..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/SimpleMenu.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.res.Resources;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.SubMenu;
-
-import java.util.ArrayList;
-
-/**
- * A <em>really</em> dumb implementation of the {@link android.view.Menu} interface, that's only
- * useful for our actionbar-compat purposes. See
- * <code>com.android.internal.view.menu.MenuBuilder</code> in AOSP for a more complete
- * implementation.
- */
-public class SimpleMenu implements Menu {
-
-    private Context mContext;
-    private Resources mResources;
-
-    private ArrayList<SimpleMenuItem> mItems;
-
-    public SimpleMenu(Context context) {
-        mContext = context;
-        mResources = context.getResources();
-        mItems = new ArrayList<SimpleMenuItem>();
-    }
-
-    public Context getContext() {
-        return mContext;
-    }
-
-    public Resources getResources() {
-        return mResources;
-    }
-
-    public MenuItem add(CharSequence title) {
-        return addInternal(0, 0, title);
-    }
-
-    public MenuItem add(int titleRes) {
-        return addInternal(0, 0, mResources.getString(titleRes));
-    }
-
-    public MenuItem add(int groupId, int itemId, int order, CharSequence title) {
-        return addInternal(itemId, order, title);
-    }
-
-    public MenuItem add(int groupId, int itemId, int order, int titleRes) {
-        return addInternal(itemId, order, mResources.getString(titleRes));
-    }
-
-    /**
-     * Adds an item to the menu.  The other add methods funnel to this.
-     */
-    private MenuItem addInternal(int itemId, int order, CharSequence title) {
-        final SimpleMenuItem item = new SimpleMenuItem(this, itemId, order, title);
-        mItems.add(findInsertIndex(mItems, order), item);
-        return item;
-    }
-
-    private static int findInsertIndex(ArrayList<? extends MenuItem> items, int order) {
-        for (int i = items.size() - 1; i >= 0; i--) {
-            MenuItem item = items.get(i);
-            if (item.getOrder() <= order) {
-                return i + 1;
-            }
-        }
-
-        return 0;
-    }
-
-    public int findItemIndex(int id) {
-        final int size = size();
-
-        for (int i = 0; i < size; i++) {
-            SimpleMenuItem item = mItems.get(i);
-            if (item.getItemId() == id) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    public void removeItem(int itemId) {
-        removeItemAtInt(findItemIndex(itemId));
-    }
-
-    private void removeItemAtInt(int index) {
-        if ((index < 0) || (index >= mItems.size())) {
-            return;
-        }
-        mItems.remove(index);
-    }
-
-    public void clear() {
-        mItems.clear();
-    }
-
-    public MenuItem findItem(int id) {
-        final int size = size();
-        for (int i = 0; i < size; i++) {
-            SimpleMenuItem item = mItems.get(i);
-            if (item.getItemId() == id) {
-                return item;
-            }
-        }
-
-        return null;
-    }
-
-    public int size() {
-        return mItems.size();
-    }
-
-    public MenuItem getItem(int index) {
-        return mItems.get(index);
-    }
-
-    // Unsupported operations.
-
-    public SubMenu addSubMenu(CharSequence charSequence) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public SubMenu addSubMenu(int titleRes) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public SubMenu addSubMenu(int groupId, int itemId, int order, CharSequence title) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public SubMenu addSubMenu(int groupId, int itemId, int order, int titleRes) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public int addIntentOptions(int i, int i1, int i2, ComponentName componentName,
-            Intent[] intents, Intent intent, int i3, MenuItem[] menuItems) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public void removeGroup(int i) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public void setGroupCheckable(int i, boolean b, boolean b1) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public void setGroupVisible(int i, boolean b) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public void setGroupEnabled(int i, boolean b) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public boolean hasVisibleItems() {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public void close() {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public boolean performShortcut(int i, KeyEvent keyEvent, int i1) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public boolean isShortcutKey(int i, KeyEvent keyEvent) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public boolean performIdentifierAction(int i, int i1) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-
-    public void setQwertyMode(boolean b) {
-        throw new UnsupportedOperationException("This operation is not supported for SimpleMenu");
-    }
-}
diff --git a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/SimpleMenuItem.java b/samples/ActionBarCompat/src/com/example/android/actionbarcompat/SimpleMenuItem.java
deleted file mode 100644
index 425ba72..0000000
--- a/samples/ActionBarCompat/src/com/example/android/actionbarcompat/SimpleMenuItem.java
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
- * Copyright 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.example.android.actionbarcompat;
-
-import android.content.Intent;
-import android.graphics.drawable.Drawable;
-import android.view.ActionProvider;
-import android.view.ContextMenu;
-import android.view.MenuItem;
-import android.view.SubMenu;
-import android.view.View;
-
-/**
- * A <em>really</em> dumb implementation of the {@link android.view.MenuItem} interface, that's only
- * useful for our actionbar-compat purposes. See
- * <code>com.android.internal.view.menu.MenuItemImpl</code> in AOSP for a more complete
- * implementation.
- */
-public class SimpleMenuItem implements MenuItem {
-
-    private SimpleMenu mMenu;
-
-    private final int mId;
-    private final int mOrder;
-    private CharSequence mTitle;
-    private CharSequence mTitleCondensed;
-    private Drawable mIconDrawable;
-    private int mIconResId = 0;
-    private boolean mEnabled = true;
-
-    public SimpleMenuItem(SimpleMenu menu, int id, int order, CharSequence title) {
-        mMenu = menu;
-        mId = id;
-        mOrder = order;
-        mTitle = title;
-    }
-
-    public int getItemId() {
-        return mId;
-    }
-
-    public int getOrder() {
-        return mOrder;
-    }
-
-    public MenuItem setTitle(CharSequence title) {
-        mTitle = title;
-        return this;
-    }
-
-    public MenuItem setTitle(int titleRes) {
-        return setTitle(mMenu.getContext().getString(titleRes));
-    }
-
-    public CharSequence getTitle() {
-        return mTitle;
-    }
-
-    public MenuItem setTitleCondensed(CharSequence title) {
-        mTitleCondensed = title;
-        return this;
-    }
-
-    public CharSequence getTitleCondensed() {
-        return mTitleCondensed != null ? mTitleCondensed : mTitle;
-    }
-
-    public MenuItem setIcon(Drawable icon) {
-        mIconResId = 0;
-        mIconDrawable = icon;
-        return this;
-    }
-
-    public MenuItem setIcon(int iconResId) {
-        mIconDrawable = null;
-        mIconResId = iconResId;
-        return this;
-    }
-
-    public Drawable getIcon() {
-        if (mIconDrawable != null) {
-            return mIconDrawable;
-        }
-
-        if (mIconResId != 0) {
-            return mMenu.getResources().getDrawable(mIconResId);
-        }
-
-        return null;
-    }
-
-    public MenuItem setEnabled(boolean enabled) {
-        mEnabled = enabled;
-        return this;
-    }
-
-    public boolean isEnabled() {
-        return mEnabled;
-    }
-
-    // No-op operations. We use no-ops to allow inflation from menu XML.
-
-    public int getGroupId() {
-        // Noop
-        return 0;
-    }
-
-    public View getActionView() {
-        // Noop
-        return null;
-    }
-
-    public MenuItem setActionProvider(ActionProvider actionProvider) {
-        // Noop
-        return this;
-    }
-
-    public ActionProvider getActionProvider() {
-        // Noop
-        return null;
-    }
-
-    public boolean expandActionView() {
-        // Noop
-        return false;
-    }
-
-    public boolean collapseActionView() {
-        // Noop
-        return false;
-    }
-
-    public boolean isActionViewExpanded() {
-        // Noop
-        return false;
-    }
-
-    @Override
-    public MenuItem setOnActionExpandListener(OnActionExpandListener onActionExpandListener) {
-        // Noop
-        return this;
-    }
-
-    public MenuItem setIntent(Intent intent) {
-        // Noop
-        return this;
-    }
-
-    public Intent getIntent() {
-        // Noop
-        return null;
-    }
-
-    public MenuItem setShortcut(char c, char c1) {
-        // Noop
-        return this;
-    }
-
-    public MenuItem setNumericShortcut(char c) {
-        // Noop
-        return this;
-    }
-
-    public char getNumericShortcut() {
-        // Noop
-        return 0;
-    }
-
-    public MenuItem setAlphabeticShortcut(char c) {
-        // Noop
-        return this;
-    }
-
-    public char getAlphabeticShortcut() {
-        // Noop
-        return 0;
-    }
-
-    public MenuItem setCheckable(boolean b) {
-        // Noop
-        return this;
-    }
-
-    public boolean isCheckable() {
-        // Noop
-        return false;
-    }
-
-    public MenuItem setChecked(boolean b) {
-        // Noop
-        return this;
-    }
-
-    public boolean isChecked() {
-        // Noop
-        return false;
-    }
-
-    public MenuItem setVisible(boolean b) {
-        // Noop
-        return this;
-    }
-
-    public boolean isVisible() {
-        // Noop
-        return true;
-    }
-
-    public boolean hasSubMenu() {
-        // Noop
-        return false;
-    }
-
-    public SubMenu getSubMenu() {
-        // Noop
-        return null;
-    }
-
-    public MenuItem setOnMenuItemClickListener(OnMenuItemClickListener onMenuItemClickListener) {
-        // Noop
-        return this;
-    }
-
-    public ContextMenu.ContextMenuInfo getMenuInfo() {
-        // Noop
-        return null;
-    }
-
-    public void setShowAsAction(int i) {
-        // Noop
-    }
-
-    public MenuItem setShowAsActionFlags(int i) {
-        // Noop
-        return null;
-    }
-
-    public MenuItem setActionView(View view) {
-        // Noop
-        return this;
-    }
-
-    public MenuItem setActionView(int i) {
-        // Noop
-        return this;
-    }
-}
diff --git a/samples/ApiDemos/AndroidManifest.xml b/samples/ApiDemos/AndroidManifest.xml
index b74e290..e5e2f27 100644
--- a/samples/ApiDemos/AndroidManifest.xml
+++ b/samples/ApiDemos/AndroidManifest.xml
@@ -1176,7 +1176,6 @@
             </intent-filter>
         </activity>
 
-        <!--
         <activity android:name=".content.TextUndoActivity" android:label="@string/activity_text_undo">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
@@ -1184,7 +1183,6 @@
                 <category android:name="android.intent.category.EMBED" />
             </intent-filter>
         </activity>
-        -->
 
         <activity android:name=".content.ResourcesLayoutReference"
                 android:label="@string/activity_resources_layout_reference">
@@ -1237,6 +1235,13 @@
             </intent-filter>
         </activity>
 
+        <activity android:name=".content.ShareContent" android:label="@string/activity_share_content">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.SAMPLE_CODE" />
+            </intent-filter>
+        </activity>
+
         <activity android:name=".content.ChangedContacts" android:label="@string/activity_changed_contact">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
@@ -1263,8 +1268,25 @@
 
         <provider android:name=".content.FileProvider"
                   android:authorities="com.example.android.apis.content.FileProvider"
+                  android:grantUriPermissions="true"
+                  android:exported="false"
                   android:enabled="@bool/atLeastHoneycombMR2" />
 
+        <activity android:name=".content.ProcessTextLauncher"
+                android:label="@string/process_text_title" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.SAMPLE_CODE" />
+            </intent-filter>
+        </activity>
+        <activity android:name=".content.ProcessText" >
+            <intent-filter >
+                <action android:name="android.intent.action.PROCESS_TEXT"/>
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/plain" />
+            </intent-filter>
+        </activity>
+
         <!-- ************************************* -->
         <!--     HARDWARE PACKAGE SAMPLES          -->
         <!-- ************************************* -->
diff --git a/samples/ApiDemos/res/anim/animator.xml b/samples/ApiDemos/res/anim/animator.xml
index 2432f19..67aca3f 100644
--- a/samples/ApiDemos/res/anim/animator.xml
+++ b/samples/ApiDemos/res/anim/animator.xml
@@ -14,6 +14,7 @@
      limitations under the License.
 -->
 
+<!-- BEGIN_INCLUDE(ValueAnimatorResources) -->
 <animator xmlns:android="http://schemas.android.com/apk/res/android"
     android:duration="1000"
     android:valueFrom="1"
@@ -21,3 +22,4 @@
     android:valueType="floatType"
     android:repeatCount="1"
     android:repeatMode="reverse"/>
+<!-- END_INCLUDE(ValueAnimatorResources) -->
diff --git a/samples/ApiDemos/res/anim/object_animator.xml b/samples/ApiDemos/res/anim/object_animator.xml
index 863d423..dc503d2 100644
--- a/samples/ApiDemos/res/anim/object_animator.xml
+++ b/samples/ApiDemos/res/anim/object_animator.xml
@@ -14,6 +14,7 @@
      limitations under the License.
 -->
 
+<!-- BEGIN_INCLUDE(ObjectAnimatorResources) -->
 <objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
     android:duration="1000"
     android:valueTo="200"
@@ -21,3 +22,4 @@
     android:propertyName="y"
     android:repeatCount="1"
     android:repeatMode="reverse"/>
+<!-- END_INCLUDE(ObjectAnimatorResources) -->
diff --git a/samples/ApiDemos/res/anim/object_animator_pvh.xml b/samples/ApiDemos/res/anim/object_animator_pvh.xml
new file mode 100644
index 0000000..10c4e4d
--- /dev/null
+++ b/samples/ApiDemos/res/anim/object_animator_pvh.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- BEGIN_INCLUDE(PropertyValuesHolderResources) -->
+<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
+                android:duration="1000"
+                android:repeatCount="1"
+                android:repeatMode="reverse">
+    <propertyValuesHolder android:propertyName="x" android:valueTo="400"/>
+    <propertyValuesHolder android:propertyName="y" android:valueTo="200"/>
+</objectAnimator>
+<!-- END_INCLUDE(PropertyValuesHolderResources) -->
diff --git a/samples/ApiDemos/res/anim/object_animator_pvh_kf.xml b/samples/ApiDemos/res/anim/object_animator_pvh_kf.xml
new file mode 100644
index 0000000..cc93a5e
--- /dev/null
+++ b/samples/ApiDemos/res/anim/object_animator_pvh_kf.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
+                android:duration="1000"
+                android:repeatCount="1"
+                android:repeatMode="reverse">
+    <propertyValuesHolder android:propertyName="x" >
+        <keyframe android:fraction="0" android:value="800" />
+        <keyframe android:fraction=".2" android:value="1000" />
+        <keyframe android:fraction="1" android:value="400" />
+    </propertyValuesHolder>
+    <propertyValuesHolder android:propertyName="y" >
+        <keyframe/>
+        <keyframe android:fraction=".2" android:value="300" />
+        <keyframe android:value="1000" />
+    </propertyValuesHolder>
+</objectAnimator>
diff --git a/samples/ApiDemos/res/anim/object_animator_pvh_kf_interpolated.xml b/samples/ApiDemos/res/anim/object_animator_pvh_kf_interpolated.xml
new file mode 100644
index 0000000..96a4cfe
--- /dev/null
+++ b/samples/ApiDemos/res/anim/object_animator_pvh_kf_interpolated.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<objectAnimator xmlns:android="http://schemas.android.com/apk/res/android"
+                android:duration="1000"
+                android:repeatCount="1"
+                android:repeatMode="reverse">
+    <!-- BEGIN_INCLUDE(KeyframeResources) -->
+    <propertyValuesHolder android:propertyName="x" >
+        <keyframe android:fraction="0" android:value="800" />
+        <keyframe android:fraction=".2"
+                  android:interpolator="@android:anim/accelerate_interpolator"
+                  android:value="1000" />
+        <keyframe android:fraction="1"
+                  android:interpolator="@android:anim/accelerate_interpolator"
+                  android:value="400" />
+    </propertyValuesHolder>
+    <propertyValuesHolder android:propertyName="y" >
+        <keyframe/>
+        <keyframe android:fraction=".2"
+                  android:interpolator="@android:anim/accelerate_interpolator"
+                  android:value="300"/>
+        <keyframe android:interpolator="@android:anim/accelerate_interpolator"
+                  android:value="1000" />
+    </propertyValuesHolder>
+    <!-- END_INCLUDE(KeyframeResources) -->
+</objectAnimator>
diff --git a/samples/ApiDemos/res/anim/value_animator_pvh_kf.xml b/samples/ApiDemos/res/anim/value_animator_pvh_kf.xml
new file mode 100644
index 0000000..86b2e17
--- /dev/null
+++ b/samples/ApiDemos/res/anim/value_animator_pvh_kf.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- BEGIN_INCLUDE(ValueAnimatorKeyframeResources) -->
+<animator xmlns:android="http://schemas.android.com/apk/res/android"
+          android:duration="1000"
+          android:repeatCount="1"
+          android:repeatMode="reverse">
+    <propertyValuesHolder>
+        <keyframe android:fraction="0" android:value="1"/>
+        <keyframe android:fraction=".2" android:value=".4"/>
+        <keyframe android:fraction="1" android:value="0"/>
+    </propertyValuesHolder>
+</animator>
+<!-- END_INCLUDE(ValueAnimatorKeyframeResources) -->
diff --git a/samples/ApiDemos/res/layout/process_text_main.xml b/samples/ApiDemos/res/layout/process_text_main.xml
new file mode 100644
index 0000000..c6d31a1
--- /dev/null
+++ b/samples/ApiDemos/res/layout/process_text_main.xml
@@ -0,0 +1,26 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:card_view="http://schemas.android.com/apk/res-auto"
+    android:padding="10dip"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical" >
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/process_text_received_text_title"
+        android:textAppearance="@android:style/TextAppearance.Material.Title" />
+
+    <EditText
+        android:id="@+id/process_text_received_text_editable"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <Button
+        android:id="@+id/process_text_finish_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/process_text_finish" />
+
+</LinearLayout>
diff --git a/samples/ApiDemos/res/layout/process_text_send.xml b/samples/ApiDemos/res/layout/process_text_send.xml
new file mode 100644
index 0000000..4b3d13e
--- /dev/null
+++ b/samples/ApiDemos/res/layout/process_text_send.xml
@@ -0,0 +1,21 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:card_view="http://schemas.android.com/apk/res-auto"
+    android:padding="10dip"
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/process_text_send_title"
+        android:textAppearance="@android:style/TextAppearance.Material.Title" />
+
+    <EditText
+        android:id="@+id/process_text_send_edit"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/process_text_send_description" />
+
+</LinearLayout>
diff --git a/samples/ApiDemos/res/layout/share_content.xml b/samples/ApiDemos/res/layout/share_content.xml
new file mode 100644
index 0000000..e9d5479
--- /dev/null
+++ b/samples/ApiDemos/res/layout/share_content.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Demonstrates selecting various types of contact data. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:padding="4dip"
+    android:gravity="center_horizontal"
+    android:layout_width="match_parent" android:layout_height="match_parent">
+
+    <TextView
+        android:layout_width="match_parent" android:layout_height="wrap_content"
+        android:layout_weight="0"
+        android:textAppearance="?android:attr/textAppearanceMedium"
+        android:paddingBottom="8dip"
+        android:text="@string/share_content_msg"/>
+
+    <Button android:id="@+id/share_image"
+        android:layout_width="wrap_content" android:layout_height="wrap_content"
+        android:text="@string/share_image">
+        <requestFocus />
+    </Button>
+</LinearLayout>
diff --git a/samples/ApiDemos/res/layout/text_undo.xml b/samples/ApiDemos/res/layout/text_undo.xml
index f7d74e8..cf4ac6c 100644
--- a/samples/ApiDemos/res/layout/text_undo.xml
+++ b/samples/ApiDemos/res/layout/text_undo.xml
@@ -14,21 +14,20 @@
      limitations under the License.
 -->
 
-<!-- Demonstrates saving and restoring activity state.
-     See corresponding Java code com.android.sdk.app.SaveRestoreState.java. -->
+<!-- Demonstrates undo/redo behavior on a text field. -->
 
 <ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent" android:layout_height="match_parent">
     <LinearLayout android:orientation="vertical" android:padding="4dip"
         android:layout_width="match_parent" android:layout_height="wrap_content">
 
-        <TextView android:id="@+id/msg"
+        <TextView android:id="@+id/default_edit_msg"
             android:layout_width="match_parent" android:layout_height="wrap_content"
             android:layout_weight="0" android:textAppearance="?android:attr/textAppearanceMedium"
             android:paddingBottom="8dip"
-            android:text="@string/text_undo_msg" />
+            android:text="@string/text_undo_default_edit_msg" />
 
-        <EditText android:id="@+id/text"
+        <EditText android:id="@+id/default_text"
             android:layout_width="match_parent" android:layout_height="wrap_content"
             android:layout_weight="1"
             android:textAppearance="?android:attr/textAppearanceMedium"
@@ -41,18 +40,73 @@
             android:layout_height="match_parent"
             android:paddingTop="8dip">
             <Button
-                android:id="@+id/undo"
+                android:id="@+id/set_text"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
-                android:text="@string/undo"
+                android:text="@string/text_undo_set_text"
+                android:layout_gravity="bottom" />                
+            <Button
+                android:id="@+id/append_text"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="@string/text_undo_append_text"
                 android:layout_gravity="bottom" />
             <Button
-                android:id="@+id/redo"
+                android:id="@+id/insert_text"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
-                android:text="@string/redo"
+                android:text="@string/text_undo_insert_text"
                 android:layout_gravity="bottom" />
         </LinearLayout>
 
+        <TextView android:id="@+id/undo_disabled_msg"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_weight="0"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:paddingBottom="8dip"
+            android:text="@string/text_undo_undo_disabled_msg" />
+
+        <EditText android:id="@+id/undo_disabled_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:freezesText="true"
+            android:allowUndo="false">
+        </EditText>
+
+        <TextView android:id="@+id/length_limit_msg"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_weight="0"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:paddingBottom="8dip"
+            android:text="@string/text_undo_length_limit_msg" />
+
+        <EditText android:id="@+id/length_limit_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:freezesText="true">
+        </EditText>
+
+        <TextView android:id="@+id/credit_card_msg"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_weight="0"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:paddingBottom="8dip"
+            android:text="@string/text_undo_credit_card_msg" />
+
+        <EditText android:id="@+id/credit_card_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:freezesText="true">
+        </EditText>
+
     </LinearLayout>
 </ScrollView>
diff --git a/samples/ApiDemos/res/values/strings.xml b/samples/ApiDemos/res/values/strings.xml
index 65bfba3..6287b7e 100644
--- a/samples/ApiDemos/res/values/strings.xml
+++ b/samples/ApiDemos/res/values/strings.xml
@@ -421,11 +421,14 @@
     <string name="styled_text">Plain, <b>bold</b>, <i>italic</i>, <b><i>bold-italic</i></b></string>
     <string name="styled_text_prog">Assigned programmatically:</string>
 
-    <string name="activity_text_undo">Content/Undo Manager/Text</string>
-    <string name="text_undo_msg">Demonstrates simple use of UndoManager with text editing
-            in a TextView.</string>
-    <string name="undo">Undo</string>
-    <string name="redo">Redo</string>
+    <string name="activity_text_undo">Content/Undo</string>
+    <string name="text_undo_default_edit_msg">TextView with the default Control-Z undo behavior.</string>
+    <string name="text_undo_set_text">SetText</string>
+    <string name="text_undo_append_text">Append</string>
+    <string name="text_undo_insert_text">Insert</string>
+    <string name="text_undo_undo_disabled_msg">TextView with undo disabled.</string>
+    <string name="text_undo_length_limit_msg">TextView with a length limit InputFilter.</string>
+    <string name="text_undo_credit_card_msg">Credit card input field with a TextWatcher.</string>
 
     <string name="activity_resources_layout_reference">Content/Resources/Layout Reference</string>
     <string name="resources_layout_reference_description">Shows how to write layout
@@ -456,6 +459,11 @@
     <string name="pick_phone">Pick a Phone</string>
     <string name="pick_address">Pick an Address</string>
 
+    <string name="activity_share_content">Content/Provider/Share Content</string>
+    <string name="share_content_msg">Share private data of the app by granting access
+        to a specific URI in its content provider.</string>
+    <string name="share_image">Share Image</string>
+
     <string name="activity_changed_contact">Content/Provider/Changed Contacts</string>
 
     <string name="activity_install_apk">Content/Packages/Install Apk</string>
@@ -1556,4 +1564,13 @@
     <string name="mms_status_downloading">Downloading</string>
 
     <string name="mms_enable_receiver">Enable MMS broadcast receiver</string>
+
+    <string name="process_text_title">Content/Process Text Intent</string>
+    <string name="process_text_received_text_title">Received text selection</string>
+    <string name="process_text_finish_readonly">Finish</string>
+    <string name="process_text_finish">Replace</string>
+    <string name="process_text_no_text_received">No text received.</string>
+    <string name="process_text_no_text_process_intent_received">Try selecting some text in another app and find this app\'s name in the list of options for its selection menu.</string>
+    <string name="process_text_send_title">Select text to process</string>
+    <string name="process_text_send_description">Select a piece of text from this box to trigger the text selection action mode. In there, you will find \"Content/Process Text\". That is because this app declares it can handle text processing intents. Try selecting that action to send the selected text to that activity and retrieve processed text back.</string>
 </resources>
diff --git a/samples/ApiDemos/src/com/example/android/apis/animation/AnimationLoading.java b/samples/ApiDemos/src/com/example/android/apis/animation/AnimationLoading.java
index 910ee28..0f05528 100644
--- a/samples/ApiDemos/src/com/example/android/apis/animation/AnimationLoading.java
+++ b/samples/ApiDemos/src/com/example/android/apis/animation/AnimationLoading.java
@@ -78,6 +78,10 @@
             addBall(200, 50);
             addBall(350, 50);
             addBall(500, 50, Color.GREEN);
+            addBall(650, 50);
+            addBall(800, 50);
+            addBall(950, 50);
+            addBall(800, 50, Color.YELLOW);
         }
 
         private void createAnimation() {
@@ -106,8 +110,37 @@
                         loadAnimator(appContext, R.anim.color_animator);
                 colorizer.setTarget(balls.get(3));
 
+                ObjectAnimator animPvh = (ObjectAnimator) AnimatorInflater.
+                        loadAnimator(appContext, R.anim.object_animator_pvh);
+                animPvh.setTarget(balls.get(4));
+
+
+                ObjectAnimator animPvhKf = (ObjectAnimator) AnimatorInflater.
+                        loadAnimator(appContext, R.anim.object_animator_pvh_kf);
+                animPvhKf.setTarget(balls.get(5));
+
+                ValueAnimator faderKf = (ValueAnimator) AnimatorInflater.
+                        loadAnimator(appContext, R.anim.value_animator_pvh_kf);
+                faderKf.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+                    public void onAnimationUpdate(ValueAnimator animation) {
+                        balls.get(6).setAlpha((Float) animation.getAnimatedValue());
+                    }
+                });
+
+                // This animation has an accelerate interpolator applied on each
+                // keyframe interval. In comparison, the animation defined in
+                // R.anim.object_animator_pvh_kf uses the default linear interpolator
+                // throughout the animation. As these two animations use the
+                // exact same path, the effect of the per-keyframe interpolator
+                // has been made obvious.
+                ObjectAnimator animPvhKfInterpolated = (ObjectAnimator) AnimatorInflater.
+                        loadAnimator(appContext, R.anim.object_animator_pvh_kf_interpolated);
+                animPvhKfInterpolated.setTarget(balls.get(7));
+
                 animation = new AnimatorSet();
-                ((AnimatorSet) animation).playTogether(anim, fader, seq, colorizer);
+                ((AnimatorSet) animation).playTogether(anim, fader, seq, colorizer, animPvh,
+                        animPvhKf, faderKf, animPvhKfInterpolated);
+
             }
         }
 
diff --git a/samples/ApiDemos/src/com/example/android/apis/app/DeviceAdminSample.java b/samples/ApiDemos/src/com/example/android/apis/app/DeviceAdminSample.java
index 15fbdc1..71badcd 100644
--- a/samples/ApiDemos/src/com/example/android/apis/app/DeviceAdminSample.java
+++ b/samples/ApiDemos/src/com/example/android/apis/app/DeviceAdminSample.java
@@ -406,8 +406,7 @@
                             if (featureString != null) {
                                 PersistableBundle bundle = new PersistableBundle();
                                 bundle.putStringArray("features", featureString.split(","));
-                                Log.w(TAG, "setTrustAgentConfigurat() is disabled");
-                                // mDPM.setTrustAgentConfiguration(mDeviceAdminSample, agent, bundle);
+                                mDPM.setTrustAgentConfiguration(mDeviceAdminSample, agent, bundle);
                             }
                         } else {
                             Log.w(TAG, "Invalid component: " + component);
diff --git a/samples/ApiDemos/src/com/example/android/apis/content/FileProvider.java b/samples/ApiDemos/src/com/example/android/apis/content/FileProvider.java
index f26bcda..63d891d 100644
--- a/samples/ApiDemos/src/com/example/android/apis/content/FileProvider.java
+++ b/samples/ApiDemos/src/com/example/android/apis/content/FileProvider.java
@@ -111,14 +111,19 @@
     }
 
     @Override
-    public AssetFileDescriptor openAssetFile(Uri uri, String mode) throws FileNotFoundException {
+    public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
         // Try to open an asset with the given name.
         try {
-            InputStream is = getContext().getAssets().open(uri.getPath());
-            // Start a new thread that pipes the stream data back to the caller.
-            return new AssetFileDescriptor(
-                    openPipeHelper(uri, null, null, is, this), 0,
-                    AssetFileDescriptor.UNKNOWN_LENGTH);
+            String path = uri.getPath();
+            int off = path.indexOf('/', 1);
+            if (off < 0 || off >= (path.length()-1)) {
+                throw new FileNotFoundException("Unable to open " + uri);
+            }
+            int cookie = Integer.parseInt(path.substring(1, off));
+            String assetPath = path.substring(off+1);
+            AssetFileDescriptor asset = getContext().getAssets().openNonAssetFd(cookie, assetPath);
+            return new ParcelFileDescriptor(openPipeHelper(uri, null, null,
+                    asset.createInputStream(), this));
         } catch (IOException e) {
             FileNotFoundException fnf = new FileNotFoundException("Unable to open " + uri);
             throw fnf;
diff --git a/samples/ApiDemos/src/com/example/android/apis/content/ProcessText.java b/samples/ApiDemos/src/com/example/android/apis/content/ProcessText.java
new file mode 100644
index 0000000..9b7779b
--- /dev/null
+++ b/samples/ApiDemos/src/com/example/android/apis/content/ProcessText.java
@@ -0,0 +1,57 @@
+package com.example.android.apis.content;
+
+//Need the following import to get access to the app resources, since this
+//class is in a sub-package.
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.EditText;
+
+public class ProcessText extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.process_text_main);
+
+        CharSequence text = getIntent().getCharSequenceExtra(Intent.EXTRA_PROCESS_TEXT);
+        boolean readonly =
+                getIntent().getBooleanExtra(Intent.EXTRA_PROCESS_TEXT_READONLY, false);
+
+        EditText edit = (EditText) findViewById(R.id.process_text_received_text_editable);
+        edit.setText(text);
+        edit.setSelection(edit.getText().length());
+
+        Button finishButton = (Button) findViewById(R.id.process_text_finish_button);
+        finishButton.setText(readonly
+                ? R.string.process_text_finish_readonly : R.string.process_text_finish);
+        finishButton.setOnClickListener(
+                new OnClickListener() {
+                    @Override
+                    public void onClick(View arg0) {
+                        finish();
+                    }
+                });
+    }
+
+    @Override
+    public void finish() {
+        EditText edit = (EditText) findViewById(R.id.process_text_received_text_editable);
+        Intent intent = getIntent();
+        intent.putExtra(Intent.EXTRA_PROCESS_TEXT, edit.getText());
+        setResult(RESULT_OK, intent);
+        super.finish();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        return false;
+    }
+
+}
diff --git a/samples/ApiDemos/src/com/example/android/apis/content/ProcessTextLauncher.java b/samples/ApiDemos/src/com/example/android/apis/content/ProcessTextLauncher.java
new file mode 100644
index 0000000..10863cb
--- /dev/null
+++ b/samples/ApiDemos/src/com/example/android/apis/content/ProcessTextLauncher.java
@@ -0,0 +1,24 @@
+package com.example.android.apis.content;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.Menu;
+
+//Need the following import to get access to the app resources, since this
+//class is in a sub-package.
+import com.example.android.apis.R;
+
+public class ProcessTextLauncher extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.process_text_send);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        return false;
+    }
+
+}
diff --git a/samples/ApiDemos/src/com/example/android/apis/content/ShareContent.java b/samples/ApiDemos/src/com/example/android/apis/content/ShareContent.java
new file mode 100644
index 0000000..247c7fc
--- /dev/null
+++ b/samples/ApiDemos/src/com/example/android/apis/content/ShareContent.java
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2015, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.content;
+
+import android.app.Activity;
+import android.content.ClipData;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.util.TypedValue;
+import android.view.View;
+import android.widget.Button;
+import com.example.android.apis.R;
+
+/**
+ * Example of sharing content from a private content provider.
+ */
+public class ShareContent extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.share_content);
+
+        // Watch for button clicks.
+        ((Button)findViewById(R.id.share_image)).setOnClickListener(new View.OnClickListener() {
+            @Override public void onClick(View v) {
+                Intent intent = new Intent(Intent.ACTION_SEND);
+                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+                Uri.Builder b = new Uri.Builder();
+                b.scheme("content");
+                b.authority("com.example.android.apis.content.FileProvider");
+                TypedValue tv = new TypedValue();
+                getResources().getValue(R.drawable.jellies, tv, true);
+                b.appendEncodedPath(Integer.toString(tv.assetCookie));
+                b.appendEncodedPath(tv.string.toString());
+                Uri uri = b.build();
+                intent.setType("image/jpeg");
+                intent.putExtra(Intent.EXTRA_STREAM, uri);
+                intent.setClipData(ClipData.newUri(getContentResolver(), "image", uri));
+                startActivity(Intent.createChooser(intent, "Select share target"));
+            }
+        });
+    }
+}
diff --git a/samples/ApiDemos/src/com/example/android/apis/content/TextUndoActivity.java b/samples/ApiDemos/src/com/example/android/apis/content/TextUndoActivity.java
index 6b9dc8e..d782d31 100644
--- a/samples/ApiDemos/src/com/example/android/apis/content/TextUndoActivity.java
+++ b/samples/ApiDemos/src/com/example/android/apis/content/TextUndoActivity.java
@@ -16,58 +16,123 @@
 
 package com.example.android.apis.content;
 
-import android.app.Activity;
-//import android.content.UndoManager;
-import android.os.Parcelable;
-import android.view.View;
-import android.widget.Button;
 import com.example.android.apis.R;
 
+import android.app.Activity;
 import android.os.Bundle;
-import android.widget.TextView;
+import android.text.Editable;
+import android.text.InputFilter;
+import android.text.Spanned;
+import android.text.TextWatcher;
+import android.text.method.DigitsKeyListener;
+import android.util.Log;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
 
 /**
  * Simple example of using an UndoManager for editing text in a TextView.
  */
 public class TextUndoActivity extends Activity {
-    //UndoManager mUndoManager;
+    // Characters allowed as input in the credit card field.
+    private static final String CREDIT_CARD_CHARS = "0123456789 ";
+
+    EditText mDefaultText;
+    EditText mLengthLimitText;
+    EditText mCreditCardText;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        /*
-        mUndoManager = new UndoManager();
-        if (savedInstanceState != null) {
-            Parcelable p = savedInstanceState.getParcelable("undo");
-            if (p != null) {
-                mUndoManager.restoreInstanceState(p);
-            }
-        }
-        */
-
         setContentView(R.layout.text_undo);
 
-        /*
-        ((TextView)findViewById(R.id.text)).setUndoManager(mUndoManager, "text");
-        ((Button)findViewById(R.id.undo)).setOnClickListener(new View.OnClickListener() {
+        mDefaultText = (EditText) findViewById(R.id.default_text);
+        ((Button) findViewById(R.id.set_text)).setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                mUndoManager.undo(null, 1);
+                mDefaultText.setText("some text");
             }
         });
-        ((Button)findViewById(R.id.redo)).setOnClickListener(new View.OnClickListener() {
+        ((Button) findViewById(R.id.append_text)).setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                mUndoManager.redo(null, 1);
+                mDefaultText.append(" append");
             }
         });
-        */
+        ((Button) findViewById(R.id.insert_text)).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Editable editable = mDefaultText.getText();
+                editable.insert(0, "insert ");
+            }
+        });
+
+        mLengthLimitText = (EditText) findViewById(R.id.length_limit_text);
+        mLengthLimitText.setFilters(new InputFilter[] { new InputFilter.LengthFilter(4) });
+
+        mCreditCardText = (EditText) findViewById(R.id.credit_card_text);
+        mCreditCardText.setKeyListener(DigitsKeyListener.getInstance(CREDIT_CARD_CHARS));
+        mCreditCardText.addTextChangedListener(new CreditCardTextWatcher());
      }
 
-    @Override
-    protected void onSaveInstanceState(Bundle outState) {
-        super.onSaveInstanceState(outState);
-        //outState.putParcelable("undo", mUndoManager.saveInstanceState());
+    /**
+     * A simple credit card input formatter that adds spaces every 4 characters.
+     */
+    private static class CreditCardTextWatcher implements TextWatcher {
+        @Override
+        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+        }
+
+        @Override
+        public void onTextChanged(CharSequence s, int start, int before, int count) {
+        }
+
+        @Override
+        public void afterTextChanged(Editable s) {
+            String original = s.toString();
+            String formatted = addSpaces(getNumbers(original));
+            // This is an ugly way to avoid infinite recursion, but it's common in app code.
+            if (!formatted.equals(original)) {
+                s.replace(0, s.length(), formatted);
+            }
+        }
+
+        /**
+         * @return Returns a string with a space added every 4 characters.
+         */
+        private static String addSpaces(CharSequence str) {
+            StringBuilder builder = new StringBuilder();
+            int len = str.length();
+            for (int i = 0; i < len; i += 4) {
+                if (i + 4 < len) {
+                    builder.append(str.subSequence(i, i + 4));
+                    builder.append(' ');
+                } else {
+                    // Don't put a space after the end.
+                    builder.append(str.subSequence(i, len));
+                }
+            }
+            return builder.toString();
+        }
+
+        /**
+         * @return Returns a string containing only the digits from a character sequence.
+         */
+        private static String getNumbers(CharSequence cc) {
+            StringBuilder sb = new StringBuilder(16);
+            for (int i = 0, count = cc.length(); i < count; ++i) {
+                char c = cc.charAt(i);
+                if (isNumber(c)) {
+                    sb.append(c);
+                }
+            }
+            return sb.toString();
+        }
+
+        private static boolean isNumber(char c) {
+            return c >= '0' && c <= '9';
+        }
+
     }
 }
diff --git a/samples/ActionBarCompat/Android.mk b/samples/ReceiveShareDemo/Android.mk
similarity index 89%
rename from samples/ActionBarCompat/Android.mk
rename to samples/ReceiveShareDemo/Android.mk
index d9da54a..ad62f63 100644
--- a/samples/ActionBarCompat/Android.mk
+++ b/samples/ReceiveShareDemo/Android.mk
@@ -6,7 +6,7 @@
 # Only compile source java files in this apk.
 LOCAL_SRC_FILES := $(call all-java-files-under, src)
 
-LOCAL_PACKAGE_NAME := ActionBarCompat
+LOCAL_PACKAGE_NAME := ReceiveShareDemo
 
 LOCAL_SDK_VERSION := current
 
diff --git a/samples/ReceiveShareDemo/AndroidManifest.xml b/samples/ReceiveShareDemo/AndroidManifest.xml
new file mode 100644
index 0000000..1e07091
--- /dev/null
+++ b/samples/ReceiveShareDemo/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+  
+          http://www.apache.org/licenses/LICENSE-2.0
+  
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.android.receiveshare">
+    <application android:label="@string/app_name">
+        <activity android:name=".ReceiveShare">
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="*/*" />
+            </intent-filter>
+        </activity>
+
+        <service android:name=".ReceiveShareService" android:process=":service">
+        </service>
+    </application>
+</manifest>
diff --git a/samples/ReceiveShareDemo/res/layout/receive_share.xml b/samples/ReceiveShareDemo/res/layout/receive_share.xml
new file mode 100644
index 0000000..6d33a1b
--- /dev/null
+++ b/samples/ReceiveShareDemo/res/layout/receive_share.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Demonstrates selecting various types of contact data. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical" android:padding="4dip"
+    android:gravity="center_horizontal"
+    android:layout_width="match_parent" android:layout_height="match_parent">
+
+    <TextView
+        android:layout_width="match_parent" android:layout_height="wrap_content"
+        android:layout_weight="0"
+        android:textAppearance="?android:attr/textAppearanceMedium"
+        android:text="@string/receive_share_msg"/>
+
+    <TextView android:id="@+id/receive_share_data"
+        android:layout_width="match_parent" android:layout_height="wrap_content"
+        android:layout_weight="0"
+        android:textAppearance="?android:attr/textAppearanceMedium"
+        android:paddingTop="8dip"
+        android:paddingBottom="8dip"/>
+
+    <Button android:id="@+id/send_to_service"
+        android:layout_width="wrap_content" android:layout_height="wrap_content"
+        android:text="@string/send_to_service">
+        <requestFocus />
+    </Button>
+</LinearLayout>
diff --git a/samples/ReceiveShareDemo/res/values/strings.xml b/samples/ReceiveShareDemo/res/values/strings.xml
new file mode 100644
index 0000000..662ce3b
--- /dev/null
+++ b/samples/ReceiveShareDemo/res/values/strings.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_name">Receive Share Demo</string>
+    <string name="receive_share_msg">Received a share from another application.  This is
+         the data received:</string>
+    <string name="send_to_service">Send to service</string>
+    <string name="preparing_to_process_share">Preparing to process share...</string>
+</resources>
diff --git a/samples/ReceiveShareDemo/src/com/example/android/receiveshare/ReceiveShare.java b/samples/ReceiveShareDemo/src/com/example/android/receiveshare/ReceiveShare.java
new file mode 100644
index 0000000..a0abf6d
--- /dev/null
+++ b/samples/ReceiveShareDemo/src/com/example/android/receiveshare/ReceiveShare.java
@@ -0,0 +1,114 @@
+/**
+ * Copyright (c) 2015, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.receiveshare;
+
+import android.app.Activity;
+import android.content.ClipData;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.res.AssetFileDescriptor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.text.SpannableStringBuilder;
+import android.view.View;
+import android.widget.Button;
+import android.widget.TextView;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class ReceiveShare extends Activity {
+    static Uri getShareUri(Intent intent) {
+        Uri uri = intent.getParcelableExtra(Intent.EXTRA_STREAM);
+        if (uri == null) {
+            ClipData clip = intent.getClipData();
+            if (clip != null && clip.getItemCount() > 0) {
+                uri = clip.getItemAt(0).getUri();
+            }
+        }
+        return uri;
+    }
+
+    static CharSequence buildShareInfo(ContentResolver resolver, Intent intent) {
+        SpannableStringBuilder sb = new SpannableStringBuilder();
+        if (intent.getType() != null) {
+            sb.append("Type: "); sb.append(intent.getType()); sb.append("\n");
+        }
+        CharSequence text = intent.getCharSequenceExtra(Intent.EXTRA_TEXT);
+        if (text != null) {
+            sb.append("Text: "); sb.append(text);
+            String html = intent.getStringExtra(Intent.EXTRA_HTML_TEXT);
+            if (html != null) {
+                sb.append("\n\n"); sb.append("HTML: "); sb.append(html);
+            }
+        } else {
+            Uri uri = getShareUri(intent);
+            if (uri != null) {
+                sb.append("Uri: "); sb.append(uri.toString()); sb.append("\n");
+                try {
+                    AssetFileDescriptor afd = resolver.openAssetFileDescriptor(
+                            uri, "r");
+                    sb.append("Start offset: ");
+                    sb.append(Long.toString(afd.getStartOffset()));
+                    sb.append("\n");
+                    sb.append("Length: ");
+                    sb.append(Long.toString(afd.getLength()));
+                    sb.append("\n");
+                    afd.close();
+                } catch (FileNotFoundException e) {
+                    sb.append(e.toString());
+                } catch (SecurityException e) {
+                    sb.append(e.toString());
+                } catch (IOException e) {
+                    sb.append(e.toString());
+                }
+            }
+        }
+        return sb;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.receive_share);
+
+        Button sendButton = (Button)findViewById(R.id.send_to_service);
+        final Uri uri = getShareUri(getIntent());
+        if (uri != null) {
+            sendButton.setEnabled(true);
+        } else {
+            sendButton.setEnabled(false);
+        }
+
+        TextView content = (TextView)findViewById(R.id.receive_share_data);
+        content.append(buildShareInfo(getContentResolver(), getIntent()));
+
+        // Watch for button clicks.
+        sendButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Intent intent = new Intent(ReceiveShare.this, ReceiveShareService.class);
+                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+                ClipData clip = ClipData.newUri(getContentResolver(), "Something", uri);
+                intent.setClipData(clip);
+                startService(intent);
+                finish();
+            }
+        });
+    }
+}
diff --git a/samples/ReceiveShareDemo/src/com/example/android/receiveshare/ReceiveShareService.java b/samples/ReceiveShareDemo/src/com/example/android/receiveshare/ReceiveShareService.java
new file mode 100644
index 0000000..548650f
--- /dev/null
+++ b/samples/ReceiveShareDemo/src/com/example/android/receiveshare/ReceiveShareService.java
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2015, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.receiveshare;
+
+import android.app.IntentService;
+import android.content.Intent;
+import android.os.Handler;
+import android.util.Log;
+import android.widget.Toast;
+
+public class ReceiveShareService extends IntentService {
+    Handler mHandler;
+
+    public ReceiveShareService() {
+        super("ReceiveShareService");
+    }
+
+    public void onCreate() {
+        super.onCreate();
+        mHandler = new Handler(getMainLooper());
+    }
+
+    @Override
+    protected void onHandleIntent(Intent intent) {
+        mHandler.post(new Runnable() {
+            @Override public void run() {
+                Toast.makeText(ReceiveShareService.this, R.string.preparing_to_process_share,
+                        Toast.LENGTH_LONG).show();
+            }
+        });
+        try {
+            // Give the activity a chance to finish.
+            Thread.sleep(5*1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        final CharSequence text = ReceiveShare.buildShareInfo(getContentResolver(), intent);
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                Toast.makeText(ReceiveShareService.this, text, Toast.LENGTH_LONG).show();
+            }
+        });
+        Log.i("ReceiveShare", text.toString());
+    }
+}
diff --git a/samples/SampleSyncAdapter/Android.mk b/samples/SampleSyncAdapter/Android.mk
index eec507b..3861a95 100644
--- a/samples/SampleSyncAdapter/Android.mk
+++ b/samples/SampleSyncAdapter/Android.mk
@@ -8,7 +8,7 @@
 
 LOCAL_PACKAGE_NAME := SampleSyncAdapter
 
-LOCAL_SDK_VERSION := current
+LOCAL_SDK_VERSION := 15
 
 include $(BUILD_PACKAGE)
 
diff --git a/samples/Support7Demos/AndroidManifest.xml b/samples/Support7Demos/AndroidManifest.xml
index 77a403a..3f3ec1e 100644
--- a/samples/Support7Demos/AndroidManifest.xml
+++ b/samples/Support7Demos/AndroidManifest.xml
@@ -176,6 +176,15 @@
             </intent-filter>
         </activity>
 
+        <activity android:name=".app.ActionBarTintIcons"
+                  android:label="@string/action_bar_tint_icons"
+                  android:theme="@style/Theme.AppCompat.Light">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="com.example.android.supportv7.SAMPLE_CODE" />
+            </intent-filter>
+        </activity>
+
         <activity android:name=".app.ActionBarSettingsActionProviderActivity"
                 android:label="@string/action_bar_settings_action_provider"
                 android:theme="@style/Theme.AppCompat.Light.DarkActionBar">
@@ -298,6 +307,15 @@
             </intent-filter>
         </activity>
 
+        <activity android:name=".app.ToolbarTintIcons"
+                  android:label="@string/toolbar_icon_tint"
+                  android:theme="@style/Theme.AppCompat.Light.NoActionBar">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="com.example.android.supportv7.SAMPLE_CODE" />
+            </intent-filter>
+        </activity>
+
         <activity android:name=".app.DialogUsage"
                   android:label="@string/dialog_usage"
                   android:theme="@style/Theme.AppCompat.Light">
diff --git a/samples/Support7Demos/res/drawable-hdpi/ic_edit.png b/samples/Support7Demos/res/drawable-hdpi/ic_edit.png
new file mode 100644
index 0000000..b900af0
--- /dev/null
+++ b/samples/Support7Demos/res/drawable-hdpi/ic_edit.png
Binary files differ
diff --git a/samples/Support7Demos/res/layout/toolbar_tint_icons.xml b/samples/Support7Demos/res/layout/toolbar_tint_icons.xml
new file mode 100644
index 0000000..ee30e06
--- /dev/null
+++ b/samples/Support7Demos/res/layout/toolbar_tint_icons.xml
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              xmlns:app="http://schemas.android.com/apk/res-auto"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical">
+
+    <android.support.v7.widget.Toolbar
+            android:id="@+id/toolbar"
+            android:layout_height="wrap_content"
+            android:layout_width="match_parent"
+            android:background="?attr/colorPrimary"
+            app:navigationTint="#FF0000"
+            app:overflowTint="#0000FF"/>
+
+    <Button
+            android:id="@+id/btn_tint_navigation"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/tint_navigation"/>
+
+    <Button
+            android:id="@+id/btn_tint_navigation_clear"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/tint_navigation_clear"/>
+
+    <Button
+            android:id="@+id/btn_tint_overflow"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/tint_overflow"/>
+
+    <Button
+            android:id="@+id/btn_tint_overflow_clear"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/tint_overflow_clear"/>
+
+</LinearLayout>
\ No newline at end of file
diff --git a/samples/Support7Demos/res/menu/actions_tint.xml b/samples/Support7Demos/res/menu/actions_tint.xml
new file mode 100644
index 0000000..b218697
--- /dev/null
+++ b/samples/Support7Demos/res/menu/actions_tint.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 Google Inc.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+      xmlns:app="http://schemas.android.com/apk/res-auto">
+    <item android:id="@+id/action_search"
+          android:title="@string/action_bar_search"
+          android:icon="@drawable/abc_ic_search_api_mtrl_alpha"
+          app:showAsAction="always"
+          app:iconTint="#FF0000"/>
+
+    <item android:id="@+id/action_edit"
+          android:title="@string/action_bar_edit"
+          android:icon="@drawable/ic_edit"
+          app:showAsAction="always"/>
+
+    <item android:id="@+id/action_force_overflow"
+          android:title="@string/dummy"
+          app:showAsAction="never"/>
+</menu>
diff --git a/samples/Support7Demos/res/values/strings.xml b/samples/Support7Demos/res/values/strings.xml
index d34dab5..2353c18 100644
--- a/samples/Support7Demos/res/values/strings.xml
+++ b/samples/Support7Demos/res/values/strings.xml
@@ -62,6 +62,7 @@
     <string name="appcompat_widgets_buttons">AppCompat/Widgets/Buttons</string>
     <string name="appcompat_widgets_spinners">AppCompat/Widgets/Spinners</string>
     <string name="appcompat_widgets_text_input">AppCompat/Widgets/Text Input</string>
+    <string name="action_bar_tint_icons">AppCompat/Action Bar/Tinted Icons</string>
 
     <string name="action_bar_search">Search</string>
     <string name="action_bar_add">Add</string>
@@ -132,6 +133,7 @@
     <string name="toolbar_display_options">AppCompat/Toolbar/Toolbar Display Options</string>
     <string name="toolbar_fragment_pager">AppCompat/Toolbar/Toolbar Fragment ViewPager</string>
     <string name="toolbar_action_mode">AppCompat/Toolbar/Action Mode</string>
+    <string name="toolbar_icon_tint">AppCompat/Toolbar/Tinted Icons</string>
 
     <string name="dialog_usage">AppCompat/Dialog/Dialog Usage</string>
     <string name="dialog_title">My great dialog</string>
@@ -178,6 +180,12 @@
     <string name="sorted_list_activity">Sorted List</string>
     <string name="add_new_item">Add New Item</string>
     <string name="start_action_mode">Start Action Mode</string>
+    <string name="tint_navigation">Tint navigation button</string>
+    <string name="tint_navigation_clear">Clear navigation button tint</string>
+    <string name="tint_overflow">Tint overflow button</string>
+    <string name="tint_overflow_clear">Clear overflow button tint</string>
+    <string name="dummy">Dummy item</string>
+
     <string name="swipe_to_dismiss_activity">RecyclerView/ItemTouchHelper/Swipe To Dismiss</string>
     <string name="drag_and_drop_activity">RecyclerView/ItemTouchHelper/Drag and Drop Activity</string>
     <string name="swipe_start">start</string>
diff --git a/samples/Support7Demos/src/com/example/android/supportv7/app/ActionBarTintIcons.java b/samples/Support7Demos/src/com/example/android/supportv7/app/ActionBarTintIcons.java
new file mode 100644
index 0000000..b8d6472
--- /dev/null
+++ b/samples/Support7Demos/src/com/example/android/supportv7/app/ActionBarTintIcons.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.supportv7.app;
+
+import com.example.android.supportv7.R;
+
+import android.content.res.ColorStateList;
+import android.graphics.Color;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.support.v4.view.MenuItemCompat;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.SearchView;
+import android.text.TextUtils;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.widget.TextView;
+import android.widget.Toast;
+
+/**
+ * This demonstrates the use of tinted menu items, both via menu resources and dynamically via
+ * MenuItemCompat.
+ */
+public class ActionBarTintIcons extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.actions_tint, menu);
+
+        MenuItem item = menu.findItem(R.id.action_edit);
+        MenuItemCompat.setIconTintList(item, ColorStateList.valueOf(Color.GREEN));
+
+        return true;
+    }
+}
diff --git a/samples/Support7Demos/src/com/example/android/supportv7/app/ToolbarTintIcons.java b/samples/Support7Demos/src/com/example/android/supportv7/app/ToolbarTintIcons.java
new file mode 100644
index 0000000..150cbd5
--- /dev/null
+++ b/samples/Support7Demos/src/com/example/android/supportv7/app/ToolbarTintIcons.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.supportv7.app;
+
+import com.example.android.supportv7.R;
+
+import android.content.res.ColorStateList;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+import android.view.Menu;
+import android.view.View;
+
+/**
+ * This demonstrates the use of tinted navigation and overflow items.
+ */
+public class ToolbarTintIcons extends AppCompatActivity implements View.OnClickListener {
+
+    private Toolbar mToolbar;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.toolbar_tint_icons);
+
+        mToolbar = (Toolbar) findViewById(R.id.toolbar);
+        setSupportActionBar(mToolbar);
+
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        findViewById(R.id.btn_tint_navigation).setOnClickListener(this);
+        findViewById(R.id.btn_tint_navigation_clear).setOnClickListener(this);
+        findViewById(R.id.btn_tint_overflow).setOnClickListener(this);
+        findViewById(R.id.btn_tint_overflow_clear).setOnClickListener(this);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.actions_tint, menu);
+        return true;
+    }
+
+    @Override
+    public void onClick(View v) {
+        switch (v.getId()) {
+            case R.id.btn_tint_navigation:
+                mToolbar.setNavigationTintList(ColorStateList.valueOf(Color.BLUE));
+                break;
+            case R.id.btn_tint_navigation_clear:
+                mToolbar.setNavigationTintList(null);
+                break;
+            case R.id.btn_tint_overflow:
+                mToolbar.setOverflowTintList(ColorStateList.valueOf(Color.RED));
+                break;
+            case R.id.btn_tint_overflow_clear:
+                mToolbar.setOverflowTintList(null);
+                break;
+        }
+    }
+}
diff --git a/samples/Wiktionary/Android.mk b/samples/Wiktionary/Android.mk
index d6ce1f1..0d015fd 100644
--- a/samples/Wiktionary/Android.mk
+++ b/samples/Wiktionary/Android.mk
@@ -8,7 +8,7 @@
 
 LOCAL_PACKAGE_NAME := Wiktionary
 
-LOCAL_SDK_VERSION := current
+LOCAL_SDK_VERSION := 8
 
 include $(BUILD_PACKAGE)
 
diff --git a/samples/WiktionarySimple/Android.mk b/samples/WiktionarySimple/Android.mk
index a5a1423..670cd82 100644
--- a/samples/WiktionarySimple/Android.mk
+++ b/samples/WiktionarySimple/Android.mk
@@ -8,7 +8,7 @@
 
 LOCAL_PACKAGE_NAME := WiktionarySimple
 
-LOCAL_SDK_VERSION := current
+LOCAL_SDK_VERSION := 8
 
 include $(BUILD_PACKAGE)
 
diff --git a/samples/XmlAdapters/Android.mk b/samples/XmlAdapters/Android.mk
index e12ce57..6c46e19 100644
--- a/samples/XmlAdapters/Android.mk
+++ b/samples/XmlAdapters/Android.mk
@@ -10,7 +10,7 @@
 
 LOCAL_PROGUARD_ENABLED := disabled
 
-LOCAL_SDK_VERSION := current
+LOCAL_SDK_VERSION := 8
 
 include $(BUILD_PACKAGE)
 
diff --git a/samples/samples_source.prop_template b/samples/samples_source.prop_template
index 1524e33..d3cdfd5 100644
--- a/samples/samples_source.prop_template
+++ b/samples/samples_source.prop_template
@@ -1,4 +1,4 @@
 Pkg.UserSrc=false
-Pkg.Revision=5
+Pkg.Revision=1
 AndroidVersion.ApiLevel=${PLATFORM_SDK_VERSION}
 AndroidVersion.CodeName=${PLATFORM_VERSION_CODENAME}
diff --git a/sdk/build_tools_source.prop_template b/sdk/build_tools_source.prop_template
index c9bfc2f..5d62307 100644
--- a/sdk/build_tools_source.prop_template
+++ b/sdk/build_tools_source.prop_template
@@ -1,3 +1,3 @@
 Pkg.UserSrc=false
-Pkg.Revision=${PLATFORM_SDK_VERSION}.0.2
+Pkg.Revision=${PLATFORM_SDK_VERSION}.0.0
 
diff --git a/sdk/platform_source.prop_template b/sdk/platform_source.prop_template
index 0eb8dd2..000931a 100644
--- a/sdk/platform_source.prop_template
+++ b/sdk/platform_source.prop_template
@@ -1,10 +1,10 @@
 Pkg.Desc=Android SDK Platform ${PLATFORM_VERSION}
 Pkg.UserSrc=false
 Platform.Version=${PLATFORM_VERSION}
-Platform.CodeName=LOLLIPOP_MR1
-Pkg.Revision=2
+Platform.CodeName=MNC
+Pkg.Revision=1
 AndroidVersion.ApiLevel=${PLATFORM_SDK_VERSION}
 AndroidVersion.CodeName=${PLATFORM_VERSION_CODENAME}
-Layoutlib.Api=14
-Layoutlib.Revision=2
+Layoutlib.Api=13
+Layoutlib.Revision=1
 Platform.MinToolsRev=22
diff --git a/sdk/support_source.prop_template b/sdk/support_source.prop_template
index 03d6962..f5b217e 100644
--- a/sdk/support_source.prop_template
+++ b/sdk/support_source.prop_template
@@ -1,5 +1,5 @@
 Pkg.UserSrc=false
-Pkg.Revision=${PLATFORM_SDK_VERSION}.1.1
+Pkg.Revision=${PLATFORM_SDK_VERSION}.0.0
 Extra.Vendor=android
 Extra.VendorId=android
 Extra.VendorDisplay=Android
diff --git a/testrunner/adb_interface.py b/testrunner/adb_interface.py
index dc43a93..fdbcb78 100755
--- a/testrunner/adb_interface.py
+++ b/testrunner/adb_interface.py
@@ -51,7 +51,7 @@
     """Direct all future commands to Android target with the given serial."""
     self._target_arg = "-s %s" % serial
 
-  def SendCommand(self, command_string, timeout_time=20, retry_count=3):
+  def SendCommand(self, command_string, timeout_time=60, retry_count=3):
     """Send a command via adb.
 
     Args:
diff --git a/testrunner/test_defs.xml b/testrunner/test_defs.xml
index 19cba74..4d9ee5f 100644
--- a/testrunner/test_defs.xml
+++ b/testrunner/test_defs.xml
@@ -554,6 +554,11 @@
     build_path="external/android-clat"
     description="clatd unit tests." />
 
+<!-- dhcpcd -->
+<test-native name="dhcpcd"
+    build_path="external/dhcpcd"
+    description="dhcpcd unit tests." />
+
 <!-- Libjingle -->
 <test-native name="libjingle"
     build_path="vendor/google/libraries/libjingle"
diff --git a/tools/emulator/test-apps/SmokeTests/src/com/android/emulator/smoketests/sms/SmsTest.java b/tools/emulator/test-apps/SmokeTests/src/com/android/emulator/smoketests/sms/SmsTest.java
index 2e18cc4..6b99ea5 100644
--- a/tools/emulator/test-apps/SmokeTests/src/com/android/emulator/smoketests/sms/SmsTest.java
+++ b/tools/emulator/test-apps/SmokeTests/src/com/android/emulator/smoketests/sms/SmsTest.java
@@ -21,7 +21,7 @@
 import android.database.Cursor;
 import android.os.Bundle;
 import android.os.HandlerThread;
-import android.support.test.InjectContext;
+import android.support.test.InstrumentationRegistry;
 
 import org.junit.Assert;
 import static junit.framework.Assert.assertEquals;
@@ -42,8 +42,6 @@
     public final static String BODY = "test sms";
     private final static int SMS_POLL_TIME_MS = 10 * 1000;
     private final static int SIXY_SECONDS_OF_LOOPS = 6;
-    @InjectContext
-    public Context mContext;
 
     /**
      * Verify that an SMS has been received with the correct number and body
@@ -63,7 +61,7 @@
     }
 
     private Cursor getSmsCursor() throws java.lang.InterruptedException {
-        ContentResolver r = mContext.getContentResolver();
+        ContentResolver r = InstrumentationRegistry.getTargetContext().getContentResolver();
         Uri message = Uri.parse("content://sms/");
         Cursor c;
 
diff --git a/tools/idegen/src/Configuration.java b/tools/idegen/src/Configuration.java
index c09be1a..bd643b9 100644
--- a/tools/idegen/src/Configuration.java
+++ b/tools/idegen/src/Configuration.java
@@ -123,16 +123,27 @@
          */
 
         boolean firstJavaFile = true;
-	File[] files = directory.listFiles();
-	if (files == null) {
-	    return;
-	}
+        File[] files = directory.listFiles();
+        if (files == null) {
+            return;
+        }
         for (File file : files) {
             // Trim preceding "./" from path.
             String path = file.getPath().substring(2);
 
-            // Keep track of source roots for .java files.
-            if (path.endsWith(".java") && !file.isDirectory()) {
+            if (file.isDirectory()) {
+                // Traverse nested directories.
+                if (excludes.exclude(path)) {
+                    // Don't recurse into excluded dirs.
+                    Log.debug("Excluding: " + path);
+                    excludedDirs.add(file);
+                } else {
+                    traverse(file, sourceRoots, jarFiles, excludedDirs,
+                            excludes);
+                }
+            } else if (path.endsWith(".java")) {
+                // Keep track of source roots for .java files.
+                // Do not check excludes in this branch.
                 if (firstJavaFile) {
                     // Only parse one .java file per directory.
                     firstJavaFile = false;
@@ -142,30 +153,12 @@
                         sourceRoots.add(sourceRoot);
                     }
                 }
-                                
-                continue;
-            }
-
-            // Keep track of .jar files.
-            if (path.endsWith(".jar")) {
-                if (!excludes.exclude(path)) {
-                    jarFiles.add(file);
-                } else {
-                    Log.debug("Skipped: " + file);
-                }
-
-                continue;
-            }
-
-            // Traverse nested directories.
-            if (file.isDirectory()) {
+            } else if (path.endsWith(".jar")) {
+                // Keep track of .jar files.
                 if (excludes.exclude(path)) {
-                    // Don't recurse into excluded dirs.
-                    Log.debug("Excluding: " + path);
-                    excludedDirs.add(file);
+                    Log.debug("Skipped: " + file);
                 } else {
-                    traverse(file, sourceRoots, jarFiles, excludedDirs,
-                            excludes);
+                    jarFiles.add(file);
                 }
             }
         }
diff --git a/tools/recovery_l10n/res/values-en-rAU/strings.xml b/tools/recovery_l10n/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..b70d678c
--- /dev/null
+++ b/tools/recovery_l10n/res/values-en-rAU/strings.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recovery_installing" msgid="7864047928003865598">"Installing system update…"</string>
+    <string name="recovery_erasing" msgid="4612809744968710197">"Erasing…"</string>
+    <string name="recovery_no_command" msgid="1915703879031023455">"No command."</string>
+    <string name="recovery_error" msgid="4550265746256727080">"Error!"</string>
+</resources>
diff --git a/tools/recovery_l10n/res/values-pa-rIN/strings.xml b/tools/recovery_l10n/res/values-pa-rIN/strings.xml
new file mode 100644
index 0000000..39ef32f
--- /dev/null
+++ b/tools/recovery_l10n/res/values-pa-rIN/strings.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recovery_installing" msgid="7864047928003865598">"ਸਿਸਟਮ ਅਪਡੇਟ ਇੰਸਟੌਲ ਕਰ ਰਿਹਾ ਹੈ…"</string>
+    <string name="recovery_erasing" msgid="4612809744968710197">"ਹਟਾ ਰਿਹਾ ਹੈ…"</string>
+    <string name="recovery_no_command" msgid="1915703879031023455">"ਕੋਈ ਕਮਾਂਡ ਨਹੀਂ।"</string>
+    <string name="recovery_error" msgid="4550265746256727080">"ਅਸ਼ੁੱਧੀ!"</string>
+</resources>
diff --git a/tools/recovery_l10n/res/values-sk/strings.xml b/tools/recovery_l10n/res/values-sk/strings.xml
index e55f83f..cae6bce 100644
--- a/tools/recovery_l10n/res/values-sk/strings.xml
+++ b/tools/recovery_l10n/res/values-sk/strings.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="recovery_installing" msgid="7864047928003865598">"Prebieha inštalácia aktualizácie systému..."</string>
+    <string name="recovery_installing" msgid="7864047928003865598">"Inštalácia aktualizácie systému..."</string>
     <string name="recovery_erasing" msgid="4612809744968710197">"Prebieha mazanie..."</string>
     <string name="recovery_no_command" msgid="1915703879031023455">"Žiadny príkaz."</string>
     <string name="recovery_error" msgid="4550265746256727080">"Chyba!"</string>
